steven j bethard steven bethardgmail com new maintainer as of 29 august 2019 raymond hettinger raymond hettingergmail com commandline parsing library this module is an optparseinspired commandline parsing library that handles both optional and positional arguments produces highly informative usage messages supports parsers that dispatch to subparsers the following is a simple usage example that sums integers from the commandline and writes the result to a file parser argparse argumentparser description sum the integers at the command line parser addargument integers metavar int nargs typeint help an integer to be summed parser addargument log defaultsys stdout typeargparse filetype w help the file where the sum should be written args parser parseargs args log write s sumargs integers args log close the module contains the following public classes argumentparser the main entry point for commandline parsing as the example above shows the addargument method is used to populate the parser with actions for optional and positional arguments then the parseargs method is invoked to convert the args at the commandline into an object with attributes argumenterror the exception raised by argumentparser objects when there are errors with the parser s actions errors raised while parsing the commandline are caught by argumentparser and emitted as commandline messages filetype a factory for defining types of files to be created as the example above shows instances of filetype are typically passed as the type argument of addargument calls action the base class for parser actions typically actions are selected by passing strings like storetrue or appendconst to the action argument of addargument however for greater customization of argumentparser actions subclasses of action may be defined and passed as the action argument helpformatter rawdescriptionhelpformatter rawtexthelpformatter argumentdefaultshelpformatter formatter classes which may be passed as the formatterclass argument to the argumentparser constructor helpformatter is the default rawdescriptionhelpformatter and rawtexthelpformatter tell the parser not to change the formatting for help text and argumentdefaultshelpformatter adds information about argument defaults to the help all other classes in this module are considered implementation details also note that helpformatter and rawdescriptionhelpformatter are only considered public as object names the api of the formatter objects is still considered an implementation detail utility functions and classes abstract base class that provides repr the repr method returns a string in the format classnameattrname attrname the attributes are determined either by a classlevel attribute kwargnames or by inspecting the instance dict the copy module is used only in the append and appendconst actions and it is needed only when the default value isn t a list delay its import for speeding up the common case formatting help formatter for generating usage messages and argument help strings only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail default setting for width section and indentation methods format the indented section return nothing if the section was empty add the heading if the section was nonempty join the sectioninitial newline the heading and the help message building methods find all invocations update the maximum item length add the item to the list helpformatting methods if usage is specified use that if no optionals or positionals are available usage is just prog if optionals and positionals are available calculate usage split optionals from positionals build full usage string wrap the usage parts if it s too long break usage into wrappable parts helper for wrapping lines if prog is short follow it with optionals or positionals if prog is long put it on its own line join lines into usage prefix with usage find group indices and identify actions in groups collect all actions format strings suppressed arguments are marked with none remove separators for suppressed arguments produce all arg strings if it s in a group strip the outer add the action string to the list produce the first way to invoke the option in brackets if the optional doesn t take a value format is s or long if the optional takes a value format is s args or long args make it look optional if it s not required or in a group add the action string to the list insert things at the necessary indices join all the action items with spaces clean up separators for mutually exclusive groups return the text determine the required width and the entry label no help start on same line and add a final newline short action name start on the same line and pad two spaces long action name start on the next line collect the pieces of the action help if there was help for the action add lines of help text or add a newline if the description doesn t end with one if there are any subactions add their help as well return a single string if the optional doesn t take a value format is s long if the optional takes a value format is s args long args the textwrap module is used only for formatting help delay its import for speeding up the common usage of argparse help message formatter which retains any formatting in descriptions only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail help message formatter which retains formatting of all help text only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail help message formatter which adds default values to argument help only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail add the default value to the option help message argumentdefaultshelpformatter and booleanoptionalaction when it isn t already present this code will do that detecting cornercases to prevent duplicates or cases where it wouldn t make sense to the end user help message formatter which uses the argument type as the default metavar value instead of the argument dest only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail options and arguments an error from creating or using an argument optional or positional the string value of this exception is the message augmented with information about the argument that caused it an error from trying to convert a command line string to a type pass action classes class actionattributeholder def initself optionstrings dest nargsnone constnone defaultnone typenone choicesnone requiredfalse helpnone metavarnone self optionstrings optionstrings self dest dest self nargs nargs self const const self default default self type type self choices choices self required required self help help self metavar metavar def getkwargsself names optionstrings dest nargs const default type choices required help metavar return name getattrself name for name in names def formatusageself return self optionstrings0 def callself parser namespace values optionstringnone raise notimplementederror call not defined fixme remove together with booleanoptionalaction deprecated arguments deprecateddefault object class booleanoptionalactionaction def initself optionstrings dest defaultnone typedeprecateddefault choicesdeprecateddefault requiredfalse helpnone metavardeprecateddefault optionstrings for optionstring in optionstrings optionstrings appendoptionstring if optionstring startswith optionstring no optionstring2 optionstrings appendoptionstring we need deprecated special value to ban explicit arguments that match default value like parser addargument f actionbooleanoptionalaction typeint for fieldname in type choices metavar if localsfieldname is not deprecateddefault import warnings warnings deprecated fieldname name r is deprecated as of python 3 12 and will be removed in python remove remove3 14 if type is deprecateddefault type none if choices is deprecateddefault choices none if metavar is deprecateddefault metavar none super init optionstringsoptionstrings destdest nargs0 defaultdefault typetype choiceschoices requiredrequired helphelp metavarmetavar def callself parser namespace values optionstringnone if optionstring in self optionstrings setattrnamespace self dest not optionstring startswith no def formatusageself return joinself optionstrings class storeactionaction def initself optionstrings dest nargsnone constnone defaultnone typenone choicesnone requiredfalse helpnone metavarnone if nargs 0 raise valueerror nargs for store actions must be 0 if you have nothing to store actions such as store true or store const may be more appropriate if const is not none and nargs optional raise valueerror nargs must be r to supply const optional superstoreaction self init optionstringsoptionstrings destdest nargsnargs constconst defaultdefault typetype choiceschoices requiredrequired helphelp metavarmetavar def callself parser namespace values optionstringnone setattrnamespace self dest values class storeconstactionaction def initself optionstrings dest constnone defaultnone requiredfalse helpnone metavarnone superstoreconstaction self init optionstringsoptionstrings destdest nargs0 constconst defaultdefault requiredrequired helphelp def callself parser namespace values optionstringnone setattrnamespace self dest self const class storetrueactionstoreconstaction def initself optionstrings dest defaultfalse requiredfalse helpnone superstoretrueaction self init optionstringsoptionstrings destdest consttrue defaultdefault requiredrequired helphelp class storefalseactionstoreconstaction def initself optionstrings dest defaulttrue requiredfalse helpnone superstorefalseaction self init optionstringsoptionstrings destdest constfalse defaultdefault requiredrequired helphelp class appendactionaction def initself optionstrings dest nargsnone constnone defaultnone typenone choicesnone requiredfalse helpnone metavarnone if nargs 0 raise valueerror nargs for append actions must be 0 if arg strings are not supplying the value to append the append const action may be more appropriate if const is not none and nargs optional raise valueerror nargs must be r to supply const optional superappendaction self init optionstringsoptionstrings destdest nargsnargs constconst defaultdefault typetype choiceschoices requiredrequired helphelp metavarmetavar def callself parser namespace values optionstringnone items getattrnamespace self dest none items copyitemsitems items appendvalues setattrnamespace self dest items class appendconstactionaction def initself optionstrings dest constnone defaultnone requiredfalse helpnone metavarnone superappendconstaction self init optionstringsoptionstrings destdest nargs0 constconst defaultdefault requiredrequired helphelp metavarmetavar def callself parser namespace values optionstringnone items getattrnamespace self dest none items copyitemsitems items appendself const setattrnamespace self dest items class countactionaction def initself optionstrings dest defaultnone requiredfalse helpnone supercountaction self init optionstringsoptionstrings destdest nargs0 defaultdefault requiredrequired helphelp def callself parser namespace values optionstringnone count getattrnamespace self dest none if count is none count 0 setattrnamespace self dest count 1 class helpactionaction def initself optionstrings destsuppress defaultsuppress helpnone superhelpaction self init optionstringsoptionstrings destdest defaultdefault nargs0 helphelp def callself parser namespace values optionstringnone parser printhelp parser exit class versionactionaction def initself optionstrings versionnone destsuppress defaultsuppress helpshow program s version number and exit superversionaction self init optionstringsoptionstrings destdest defaultdefault nargs0 helphelp self version version def callself parser namespace values optionstringnone version self version if version is none version parser version formatter parser getformatter formatter addtextversion parser printmessageformatter formathelp sys stdout parser exit class subparsersactionaction class choicespseudoactionaction def initself name aliases help metavar dest name if aliases metavar s joinaliases sup supersubparsersaction choicespseudoaction self sup initoptionstrings destdest helphelp metavarmetavar def initself optionstrings prog parserclass destsuppress requiredfalse helpnone metavarnone self progprefix prog self parserclass parserclass self nameparsermap self choicesactions supersubparsersaction self init optionstringsoptionstrings destdest nargsparser choicesself nameparsermap requiredrequired helphelp metavarmetavar def addparserself name kwargs set prog from the existing prefix if kwargs get prog is none kwargs prog s s self progprefix name aliases kwargs pop aliases if name in self nameparsermap raise argumenterrorself conflicting subparser s name for alias in aliases if alias in self nameparsermap raise argumenterror self conflicting subparser alias s alias create a pseudoaction to hold the choice help if help in kwargs help kwargs pop help choiceaction self choicespseudoactionname aliases help self choicesactions appendchoiceaction create the parser and add it to the map parser self parserclasskwargs self nameparsermapname parser make parser available under aliases also for alias in aliases self nameparsermapalias parser return parser def getsubactionsself return self choicesactions def callself parser namespace values optionstringnone parsername values0 argstrings values1 set the parser name if requested if self dest is not suppress setattrnamespace self dest parsername select the parser try parser self nameparsermapparsername except keyerror args parsername parsername choices joinself nameparsermap msg unknown parser parsernamer choices choicess args raise argumenterrorself msg parse all the remaining options into the namespace store any unrecognized options on the object so that the top level parser can decide what to do with them in case this subparser defines new defaults we parse them in a new namespace object and then update the original namespace for the relevant parts subnamespace argstrings parser parseknownargsargstrings none for key value in varssubnamespace items setattrnamespace key value if argstrings varsnamespace setdefaultunrecognizedargsattr getattrnamespace unrecognizedargsattr extendargstrings class extendactionappendaction def callself parser namespace values optionstringnone items getattrnamespace self dest none items copyitemsitems items extendvalues setattrnamespace self dest items type classes class filetypeobject def initself mode r bufsize1 encodingnone errorsnone self mode mode self bufsize bufsize self encoding encoding self errors errors def callself string the special argument means sys stdin out if string if r in self mode return sys stdin buffer if b in self mode else sys stdin elif anyc in self mode for c in wax return sys stdout buffer if b in self mode else sys stdout else msg argument with mode r self mode raise valueerrormsg all other arguments are used as file names try return openstring self mode self bufsize self encoding self errors except oserror as e args filename string error e message can t open filenames errors raise argumenttypeerrormessage args def reprself args self mode self bufsize kwargs encoding self encoding errors self errors argsstr joinreprarg for arg in args if arg 1 sr kw arg for kw arg in kwargs if arg is not none return ss typeself name argsstr optional and positional parsing class namespaceattributeholder def initself kwargs for name in kwargs setattrself name kwargsname def eqself other if not isinstanceother namespace return notimplemented return varsself varsother def containsself key return key in self dict class actionscontainerobject def initself description prefixchars argumentdefault conflicthandler superactionscontainer self init self description description self argumentdefault argumentdefault self prefixchars prefixchars self conflicthandler conflicthandler set up registries self registries register actions self register action none storeaction self register action store storeaction self register action storeconst storeconstaction self register action storetrue storetrueaction self register action storefalse storefalseaction self register action append appendaction self register action appendconst appendconstaction self register action count countaction self register action help helpaction self register action version versionaction self register action parsers subparsersaction self register action extend extendaction raise an exception if the conflict handler is invalid self gethandler action storage self actions self optionstringactions groups self actiongroups self mutuallyexclusivegroups defaults storage self defaults determines whether an option looks like a negative number self negativenumbermatcher re compiler dd d whether or not there are any optionals that look like negative numbers uses a list so it can be shared and edited self hasnegativenumberoptionals registration methods def registerself registryname value object registry self registries setdefaultregistryname registryvalue object def registrygetself registryname value defaultnone return self registriesregistryname getvalue default namespace default accessor methods def setdefaultsself kwargs self defaults updatekwargs if these defaults match any existing arguments replace the previous default on the object with the new one for action in self actions if action dest in kwargs action default kwargsaction dest def getdefaultself dest for action in self actions if action dest dest and action default is not none return action default return self defaults getdest none adding argument actions def addargumentself args kwargs if no positional args are supplied or only one is supplied and it doesn t look like an option string parse a positional argument chars self prefixchars if not args or lenargs 1 and args00 not in chars if args and dest in kwargs raise valueerror dest supplied twice for positional argument kwargs self getpositionalkwargsargs kwargs otherwise we re adding an optional argument else kwargs self getoptionalkwargsargs kwargs if no default was supplied use the parserlevel default if default not in kwargs dest kwargs dest if dest in self defaults kwargs default self defaultsdest elif self argumentdefault is not none kwargs default self argumentdefault create the action object and add it to the parser actionclass self popactionclasskwargs if not callableactionclass raise valueerror unknown action s actionclass action actionclasskwargs raise an error if the action type is not callable typefunc self registryget type action type action type if not callabletypefunc raise valueerror r is not callable typefunc if typefunc is filetype raise valueerror r is a filetype class object instance of it must be passed typefunc raise an error if the metavar does not match the type if hasattrself getformatter try self getformatter formatargsaction none except typeerror raise valueerrorlength of metavar tuple does not match nargs return self addactionaction def addargumentgroupself args kwargs group argumentgroupself args kwargs self actiongroups appendgroup return group def addmutuallyexclusivegroupself kwargs group mutuallyexclusivegroupself kwargs self mutuallyexclusivegroups appendgroup return group def addactionself action resolve any conflicts self checkconflictaction add to actions list self actions appendaction action container self index the action by any option strings it has for optionstring in action optionstrings self optionstringactionsoptionstring action set the flag if any option strings look like negative numbers for optionstring in action optionstrings if self negativenumbermatcher matchoptionstring if not self hasnegativenumberoptionals self hasnegativenumberoptionals appendtrue return the created action return action def removeactionself action self actions removeaction def addcontaineractionsself container collect groups by titles titlegroupmap for group in self actiongroups if group title in titlegroupmap this branch could happen if a derived class added groups with duplicated titles in init msg cannot merge actions two groups are named r raise valueerrormsg group title titlegroupmapgroup title group map each action to its group groupmap for group in container actiongroups if a group with the title exists use that otherwise create a new group matching the container s group if group title not in titlegroupmap titlegroupmapgroup title self addargumentgroup titlegroup title descriptiongroup description conflicthandlergroup conflicthandler map the actions to their new group for action in group groupactions groupmapaction titlegroupmapgroup title add container s mutually exclusive groups note if addmutuallyexclusivegroup ever gains title and description then this code will need to be expanded as above for group in container mutuallyexclusivegroups mutexgroup self addmutuallyexclusivegroup requiredgroup required map the actions to their new mutex group for action in group groupactions groupmapaction mutexgroup add all actions to this container or their group for action in container actions groupmap getaction self addactionaction def getpositionalkwargsself dest kwargs make sure required is not specified if required in kwargs msg required is an invalid argument for positionals raise typeerrormsg mark positional arguments as required if at least one is always required if kwargs get nargs not in optional zeroormore kwargs required true if kwargs get nargs zeroormore and default not in kwargs kwargs required true return the keyword arguments with no option strings return dictkwargs destdest optionstrings def getoptionalkwargsself args kwargs determine short and long option strings optionstrings longoptionstrings for optionstring in args error on strings that don t start with an appropriate prefix if not optionstring0 in self prefixchars args option optionstring prefixchars self prefixchars msg invalid option string optionr must start with a character prefixcharsr raise valueerrormsg args strings starting with two prefix characters are long options optionstrings appendoptionstring if lenoptionstring 1 and optionstring1 in self prefixchars longoptionstrings appendoptionstring infer destination foobar foobar and x x dest kwargs pop dest none if dest is none if longoptionstrings destoptionstring longoptionstrings0 else destoptionstring optionstrings0 dest destoptionstring lstripself prefixchars if not dest msg dest is required for options like r raise valueerrormsg optionstring dest dest replace return the updated keyword arguments return dictkwargs destdest optionstringsoptionstrings def popactionclassself kwargs defaultnone action kwargs pop action default return self registryget action action action def gethandlerself determine function from conflict handler string handlerfuncname handleconflicts self conflicthandler try return getattrself handlerfuncname except attributeerror msg invalid conflictresolution value r raise valueerrormsg self conflicthandler def checkconflictself action find all options that conflict with this option confloptionals for optionstring in action optionstrings if optionstring in self optionstringactions confloptional self optionstringactionsoptionstring confloptionals appendoptionstring confloptional resolve any conflicts if confloptionals conflicthandler self gethandler conflicthandleraction confloptionals def handleconflicterrorself action conflictingactions message ngettext conflicting option string s conflicting option strings s lenconflictingactions conflictstring joinoptionstring for optionstring action in conflictingactions raise argumenterroraction message conflictstring def handleconflictresolveself action conflictingactions remove all conflicting options for optionstring action in conflictingactions remove the conflicting option action optionstrings removeoptionstring self optionstringactions popoptionstring none if the option now has no option string remove it from the container holding it if not action optionstrings action container removeactionaction class argumentgroupactionscontainer def initself container titlenone descriptionnone kwargs add any missing keyword arguments by checking the container update kwargs setdefault update conflicthandler container conflicthandler update prefixchars container prefixchars update argumentdefault container argumentdefault superinit superargumentgroup self init superinitdescriptiondescription kwargs group attributes self title title self groupactions share most attributes with the container self registries container registries self actions container actions self optionstringactions container optionstringactions self defaults container defaults self hasnegativenumberoptionals container hasnegativenumberoptionals self mutuallyexclusivegroups container mutuallyexclusivegroups def addactionself action action superargumentgroup self addactionaction self groupactions appendaction return action def removeactionself action superargumentgroup self removeactionaction self groupactions removeaction def addargumentgroupself args kwargs import warnings warnings warn nesting argument groups is deprecated categorydeprecationwarning stacklevel2 return super addargumentgroupargs kwargs class mutuallyexclusivegroupargumentgroup def initself container requiredfalse supermutuallyexclusivegroup self initcontainer self required required self container container def addactionself action if action required msg mutually exclusive arguments must be optional raise valueerrormsg action self container addactionaction self groupactions appendaction return action def removeactionself action self container removeactionaction self groupactions removeaction def addmutuallyexclusivegroupself args kwargs import warnings warnings warn nesting mutually exclusive groups is deprecated categorydeprecationwarning stacklevel2 return super addmutuallyexclusivegroupargs kwargs class argumentparserattributeholder actionscontainer def initself prognone usagenone descriptionnone epilognone parents formatterclasshelpformatter prefixchars fromfileprefixcharsnone argumentdefaultnone conflicthandler error addhelptrue allowabbrevtrue exitonerrortrue superinit superargumentparser self init superinitdescriptiondescription prefixcharsprefixchars argumentdefaultargumentdefault conflicthandlerconflicthandler default setting for prog if prog is none prog os path basenamesys argv0 self prog prog self usage usage self epilog epilog self formatterclass formatterclass self fromfileprefixchars fromfileprefixchars self addhelp addhelp self allowabbrev allowabbrev self exitonerror exitonerror addgroup self addargumentgroup self positionals addgroup positional arguments self optionals addgroup options self subparsers none register types def identitystring return string self register type none identity add help argument if necessary using explicit default to override global argumentdefault defaultprefix if in prefixchars else prefixchars0 if self addhelp self addargument defaultprefix h defaultprefix2 help action help defaultsuppress help show this help message and exit add parent arguments and defaults for parent in parents if not isinstanceparent argumentparser raise typeerror parents must be a list of argumentparser self addcontaineractionsparent defaults parent defaults self defaults updatedefaults pretty repr methods def getkwargsself names prog usage description formatterclass conflicthandler addhelp return name getattrself name for name in names optionalpositional adding methods def addsubparsersself kwargs if self subparsers is not none self error cannot have multiple subparser arguments add the parser class to the arguments if it s not present kwargs setdefault parserclass typeself if title in kwargs or description in kwargs title kwargs pop title subcommands description kwargs pop description none self subparsers self addargumentgrouptitle description else self subparsers self positionals prog defaults to the usage message of this parser skipping optional arguments and with no usage prefix if kwargs get prog is none formatter self getformatter positionals self getpositionalactions groups self mutuallyexclusivegroups formatter addusageself usage positionals groups kwargs prog formatter formathelp strip create the parsers action and add it to the positionals list parsersclass self popactionclasskwargs parsers action parsersclassoptionstrings kwargs self subparsers addactionaction return the created parsers action return action def addactionself action if action optionstrings self optionals addactionaction else self positionals addactionaction return action def getoptionalactionsself return action for action in self actions if action optionstrings def getpositionalactionsself return action for action in self actions if not action optionstrings command line argument parsing methods def parseargsself argsnone namespacenone args argv self parseknownargsargs namespace if argv msg unrecognized arguments s self errormsg joinargv return args def parseknownargsself argsnone namespacenone if args is none args default to the system args args sys argv1 else make sure that args are mutable args listargs default namespace built from parser defaults if namespace is none namespace namespace add any action defaults that aren t present for action in self actions if action dest is not suppress if not hasattrnamespace action dest if action default is not suppress setattrnamespace action dest action default add any parser defaults that aren t present for dest in self defaults if not hasattrnamespace dest setattrnamespace dest self defaultsdest parse the arguments and exit if there are any errors if self exitonerror try namespace args self parseknownargsargs namespace except argumenterror as err self errorstrerr else namespace args self parseknownargsargs namespace if hasattrnamespace unrecognizedargsattr args extendgetattrnamespace unrecognizedargsattr delattrnamespace unrecognizedargsattr return namespace args def parseknownargsself argstrings namespace replace arg strings that are file references if self fromfileprefixchars is not none argstrings self readargsfromfilesargstrings map all mutually exclusive arguments to the other arguments they can t occur with actionconflicts for mutexgroup in self mutuallyexclusivegroups groupactions mutexgroup groupactions for i mutexaction in enumeratemutexgroup groupactions conflicts actionconflicts setdefaultmutexaction conflicts extendgroupactions i conflicts extendgroupactionsi 1 find all option indices and determine the argstringpattern which has an o if there is an option at an index an a if there is an argument or a if there is a optionstringindices argstringpatternparts argstringsiter iterargstrings for i argstring in enumerateargstringsiter all args after are nonoptions if argstring argstringpatternparts append for argstring in argstringsiter argstringpatternparts append a otherwise add the arg to the arg strings and note the index if it was an option else optiontuple self parseoptionalargstring if optiontuple is none pattern a else optionstringindicesi optiontuple pattern o argstringpatternparts appendpattern join the pieces together to form the pattern argstringspattern joinargstringpatternparts converts arg strings to the appropriate and then takes the action seenactions set seennondefaultactions set def takeactionaction argumentstrings optionstringnone seenactions addaction argumentvalues self getvaluesaction argumentstrings error if this argument is not allowed with other previously seen arguments assuming that actions that use the default value don t really count as present if argumentvalues is not action default seennondefaultactions addaction for conflictaction in actionconflicts getaction if conflictaction in seennondefaultactions msg not allowed with argument s actionname getactionnameconflictaction raise argumenterroraction msg actionname take the action if we didn t receive a suppress value e g from a default if argumentvalues is not suppress actionself namespace argumentvalues optionstring function to convert argstrings into an optional action def consumeoptionalstartindex get the optional identified at this index optiontuple optionstringindicesstartindex action optionstring explicitarg optiontuple identify additional optionals in the same arg string e g xyz is the same as x y z if no args are required matchargument self matchargument actiontuples while true if we found no optional action skip it if action is none extras appendargstringsstartindex return startindex 1 if there is an explicit argument try to match the optional s string arguments to only this if explicitarg is not none argcount matchargumentaction a if the action is a singledash option and takes no arguments try to parse more singledash options out of the tail of the option string chars self prefixchars if argcount 0 and optionstring1 not in chars and explicitarg actiontuples appendaction optionstring char optionstring0 optionstring char explicitarg0 newexplicitarg explicitarg1 or none optionalsmap self optionstringactions if optionstring in optionalsmap action optionalsmapoptionstring explicitarg newexplicitarg else msg ignored explicit argument r raise argumenterroraction msg explicitarg if the action expect exactly one argument we ve successfully matched the option exit the loop elif argcount 1 stop startindex 1 args explicitarg actiontuples appendaction args optionstring break error if a doubledash option did not use the explicit argument else msg ignored explicit argument r raise argumenterroraction msg explicitarg if there is no explicit argument try to match the optional s string arguments with the following strings if successful exit the loop else start startindex 1 selectedpatterns argstringspatternstart argcount matchargumentaction selectedpatterns stop start argcount args argstringsstart stop actiontuples appendaction args optionstring break add the optional to the list and return the index at which the optional s string args stopped assert actiontuples for action args optionstring in actiontuples takeactionaction args optionstring return stop the list of positionals left to be parsed this is modified by consumepositionals positionals self getpositionalactions function to convert argstrings into positional actions def consumepositionalsstartindex match as many positionals as possible matchpartial self matchargumentspartial selectedpattern argstringspatternstartindex argcounts matchpartialpositionals selectedpattern slice off the appropriate arg strings for each positional and add the positional and its args to the list for action argcount in zippositionals argcounts args argstringsstartindex startindex argcount startindex argcount takeactionaction args slice off the positionals that we just parsed and return the index at which the positionals string args stopped positionals positionalslenargcounts return startindex consume positionals and optionals alternately until we have passed the last option string extras startindex 0 if optionstringindices maxoptionstringindex maxoptionstringindices else maxoptionstringindex 1 while startindex maxoptionstringindex consume any positionals preceding the next option nextoptionstringindex min index for index in optionstringindices if index startindex if startindex nextoptionstringindex positionalsendindex consumepositionalsstartindex only try to parse the next optional if we didn t consume the option string during the positionals parsing if positionalsendindex startindex startindex positionalsendindex continue else startindex positionalsendindex if we consumed all the positionals we could and we re not at the index of an option string there were extra arguments if startindex not in optionstringindices strings argstringsstartindex nextoptionstringindex extras extendstrings startindex nextoptionstringindex consume the next optional and any arguments for it startindex consumeoptionalstartindex consume any positionals following the last optional stopindex consumepositionalsstartindex if we didn t consume all the argument strings there were extras extras extendargstringsstopindex make sure all required actions were present and also convert action defaults which were not given as arguments requiredactions for action in self actions if action not in seenactions if action required requiredactions appendgetactionnameaction else convert action default now instead of doing it before parsing arguments to avoid calling convert functions twice which may fail if the argument was given but only if it was defined already in the namespace if action default is not none and isinstanceaction default str and hasattrnamespace action dest and action default is getattrnamespace action dest setattrnamespace action dest self getvalueaction action default if requiredactions self error the following arguments are required s joinrequiredactions make sure all required groups had one option present for group in self mutuallyexclusivegroups if group required for action in group groupactions if action in seennondefaultactions break if no actions were used report the error else names getactionnameaction for action in group groupactions if action help is not suppress msg one of the arguments s is required self errormsg joinnames return the updated namespace and the extra arguments return namespace extras def readargsfromfilesself argstrings expand arguments referencing files newargstrings for argstring in argstrings for regular arguments just add them back into the list if not argstring or argstring0 not in self fromfileprefixchars newargstrings appendargstring replace arguments referencing files with the file content else try with openargstring1 encodingsys getfilesystemencoding errorssys getfilesystemencodeerrors as argsfile argstrings for argline in argsfile read splitlines for arg in self convertarglinetoargsargline argstrings appendarg argstrings self readargsfromfilesargstrings newargstrings extendargstrings except oserror as err self errorstrerr return the modified argument list return newargstrings def convertarglinetoargsself argline return argline def matchargumentself action argstringspattern match the pattern for this action to the arg strings nargspattern self getnargspatternaction match re matchnargspattern argstringspattern raise an exception if we weren t able to find a match if match is none nargserrors none expected one argument optional expected at most one argument oneormore expected at least one argument msg nargserrors getaction nargs if msg is none msg ngettext expected s argument expected s arguments action nargs action nargs raise argumenterroraction msg return the number of arguments matched return lenmatch group1 def matchargumentspartialself actions argstringspattern progressively shorten the actions list by slicing off the final actions until we find a match result for i in rangelenactions 0 1 actionsslice actions i pattern joinself getnargspatternaction for action in actionsslice match re matchpattern argstringspattern if match is not none result extendlenstring for string in match groups break return the list of arg string counts return result def parseoptionalself argstring if it s an empty string it was meant to be a positional if not argstring return none if it doesn t start with a prefix it was meant to be positional if not argstring0 in self prefixchars return none if the option string is present in the parser return the action if argstring in self optionstringactions action self optionstringactionsargstring return action argstring none if it s just a single character it was meant to be positional if lenargstring 1 return none if the option string before the is present return the action if in argstring optionstring explicitarg argstring split 1 if optionstring in self optionstringactions action self optionstringactionsoptionstring return action optionstring explicitarg search through all possible prefixes of the option string and all actions in the parser for possible interpretations optiontuples self getoptiontuplesargstring if multiple actions match the option string was ambiguous if lenoptiontuples 1 options joinoptionstring for action optionstring explicitarg in optiontuples args option argstring matches options msg ambiguous option options could match matchess self errormsg args if exactly one action matched this segmentation is good so return the parsed action elif lenoptiontuples 1 optiontuple optiontuples return optiontuple if it was not found as an option but it looks like a negative number it was meant to be positional unless there are negativenumberlike options if self negativenumbermatcher matchargstring if not self hasnegativenumberoptionals return none if it contains a space it was meant to be a positional if in argstring return none it was meant to be an optional but there is no such option in this parser though it might be a valid option in a subparser return none argstring none def getoptiontuplesself optionstring result option strings starting with two prefix characters are only split at the chars self prefixchars if optionstring0 in chars and optionstring1 in chars if self allowabbrev if in optionstring optionprefix explicitarg optionstring split 1 else optionprefix optionstring explicitarg none for optionstring in self optionstringactions if optionstring startswithoptionprefix action self optionstringactionsoptionstring tup action optionstring explicitarg result appendtup single character options can be concatenated with their arguments but multiple character options always have to have their argument separate elif optionstring0 in chars and optionstring1 not in chars optionprefix optionstring explicitarg none shortoptionprefix optionstring 2 shortexplicitarg optionstring2 for optionstring in self optionstringactions if optionstring shortoptionprefix action self optionstringactionsoptionstring tup action optionstring shortexplicitarg result appendtup elif optionstring startswithoptionprefix action self optionstringactionsoptionstring tup action optionstring explicitarg result appendtup shouldn t ever get here else self error unexpected option string s optionstring return the collected option tuples return result def getnargspatternself action in all examples below we have to allow for args which are represented as in the pattern nargs action nargs the default none is assumed to be a single argument if nargs is none nargspattern a allow zero or one arguments elif nargs optional nargspattern a allow zero or more arguments elif nargs zeroormore nargspattern a allow one or more arguments elif nargs oneormore nargspattern aa allow any number of options or arguments elif nargs remainder nargspattern ao allow one argument followed by any number of options or arguments elif nargs parser nargspattern aao suppress action like nargs0 elif nargs suppress nargspattern all others should be integers else nargspattern s join a nargs if this is an optional action is not allowed if action optionstrings nargspattern nargspattern replace nargspattern nargspattern replace return the pattern return nargspattern alt command line argument parsing allowing free intermix def parseintermixedargsself argsnone namespacenone args argv self parseknownintermixedargsargs namespace if argv msg unrecognized arguments s self errormsg joinargv return args def parseknownintermixedargsself argsnone namespacenone returns a namespace and list of extras positional can be freely intermixed with optionals optionals are first parsed with all positional arguments deactivated the extras are then parsed if the parser definition is incompatible with the intermixed assumptions e g use of remainder subparsers a typeerror is raised positionals are deactivated by setting nargs and default to suppress this blocks the addition of that positional to the namespace positionals self getpositionalactions a action for action in positionals if action nargs in parser remainder if a raise typeerror parseintermixedargs positional arg with nargss a0 nargs if action dest for group in self mutuallyexclusivegroups for action in group groupactions if action in positionals raise typeerror parseintermixedargs positional in mutuallyexclusivegroup try saveusage self usage try if self usage is none capture the full usage for use in error messages self usage self formatusage7 for action in positionals deactivate positionals action savenargs action nargs action nargs 0 action nargs suppress action savedefault action default action default suppress namespace remainingargs self parseknownargsargs namespace for action in positionals remove the empty positional values from namespace if hasattrnamespace action dest and getattrnamespace action dest from warnings import warn warn do not expect s in s action dest namespace delattrnamespace action dest finally restore nargs and usage before exiting for action in positionals action nargs action savenargs action default action savedefault optionals self getoptionalactions try parse positionals optionals aren t normally required but they could be so make sure they aren t for action in optionals action saverequired action required action required false for group in self mutuallyexclusivegroups group saverequired group required group required false namespace extras self parseknownargsremainingargs namespace finally restore parser values before exiting for action in optionals action required action saverequired for group in self mutuallyexclusivegroups group required group saverequired finally self usage saveusage return namespace extras value conversion methods def getvaluesself action argstrings for everything but parser remainder args strip out first if action nargs not in parser remainder try argstrings remove except valueerror pass optional argument produces a default when not present if not argstrings and action nargs optional if action optionstrings value action const else value action default if isinstancevalue str value self getvalueaction value self checkvalueaction value when nargs on a positional if there were no commandline args use the default if it is anything other than none elif not argstrings and action nargs zeroormore and not action optionstrings if action default is not none value action default self checkvalueaction value else since argstrings is always at this point there is no need to use self checkvalueaction value value argstrings single argument or optional argument produces a single value elif lenargstrings 1 and action nargs in none optional argstring argstrings value self getvalueaction argstring self checkvalueaction value remainder arguments convert all values checking none elif action nargs remainder value self getvalueaction v for v in argstrings parser arguments convert all values but check only the first elif action nargs parser value self getvalueaction v for v in argstrings self checkvalueaction value0 suppress argument does not put anything in the namespace elif action nargs suppress value suppress all other types of nargs produce a list else value self getvalueaction v for v in argstrings for v in value self checkvalueaction v return the converted value return value def getvalueself action argstring typefunc self registryget type action type action type if not callabletypefunc msg r is not callable raise argumenterroraction msg typefunc convert the value to the appropriate type try result typefuncargstring argumenttypeerrors indicate errors except argumenttypeerror as err msg strerr raise argumenterroraction msg typeerrors or valueerrors also indicate errors except typeerror valueerror name getattraction type name repraction type args type name value argstring msg invalid types value valuer raise argumenterroraction msg args return the converted value return result def checkvalueself action value converted value must be one of the choices if specified if action choices is not none and value not in action choices args value value choices joinmaprepr action choices msg invalid choice valuer choose from choicess raise argumenterroraction msg args helpformatting methods def formatusageself formatter self getformatter formatter addusageself usage self actions self mutuallyexclusivegroups return formatter formathelp def formathelpself formatter self getformatter usage formatter addusageself usage self actions self mutuallyexclusivegroups description formatter addtextself description positionals optionals and userdefined groups for actiongroup in self actiongroups formatter startsectionactiongroup title formatter addtextactiongroup description formatter addargumentsactiongroup groupactions formatter endsection epilog formatter addtextself epilog determine help from format above return formatter formathelp def getformatterself return self formatterclassprogself prog helpprinting methods def printusageself filenone if file is none file sys stdout self printmessageself formatusage file def printhelpself filenone if file is none file sys stdout self printmessageself formathelp file def printmessageself message filenone if message file file or sys stderr try file writemessage except attributeerror oserror pass exiting methods def exitself status0 messagenone if message self printmessagemessage sys stderr sys exitstatus def errorself message self printusagesys stderr args prog self prog message message self exit2 progs error messagesn args steven j bethard steven bethard gmail com new maintainer as of 29 august 2019 raymond hettinger raymond hettinger gmail com command line parsing library this module is an optparse inspired command line parsing library that handles both optional and positional arguments produces highly informative usage messages supports parsers that dispatch to sub parsers the following is a simple usage example that sums integers from the command line and writes the result to a file parser argparse argumentparser description sum the integers at the command line parser add_argument integers metavar int nargs type int help an integer to be summed parser add_argument log default sys stdout type argparse filetype w help the file where the sum should be written args parser parse_args args log write s sum args integers args log close the module contains the following public classes argumentparser the main entry point for command line parsing as the example above shows the add_argument method is used to populate the parser with actions for optional and positional arguments then the parse_args method is invoked to convert the args at the command line into an object with attributes argumenterror the exception raised by argumentparser objects when there are errors with the parser s actions errors raised while parsing the command line are caught by argumentparser and emitted as command line messages filetype a factory for defining types of files to be created as the example above shows instances of filetype are typically passed as the type argument of add_argument calls action the base class for parser actions typically actions are selected by passing strings like store_true or append_const to the action argument of add_argument however for greater customization of argumentparser actions subclasses of action may be defined and passed as the action argument helpformatter rawdescriptionhelpformatter rawtexthelpformatter argumentdefaultshelpformatter formatter classes which may be passed as the formatter_class argument to the argumentparser constructor helpformatter is the default rawdescriptionhelpformatter and rawtexthelpformatter tell the parser not to change the formatting for help text and argumentdefaultshelpformatter adds information about argument defaults to the help all other classes in this module are considered implementation details also note that helpformatter and rawdescriptionhelpformatter are only considered public as object names the api of the formatter objects is still considered an implementation detail utility functions and classes abstract base class that provides __repr__ the __repr__ method returns a string in the format classname attr name attr name the attributes are determined either by a class level attribute _kwarg_names or by inspecting the instance __dict__ the copy module is used only in the append and append_const actions and it is needed only when the default value isn t a list delay its import for speeding up the common case formatting help formatter for generating usage messages and argument help strings only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail default setting for width section and indentation methods format the indented section return nothing if the section was empty add the heading if the section was non empty join the section initial newline the heading and the help message building methods find all invocations update the maximum item length add the item to the list help formatting methods if usage is specified use that if no optionals or positionals are available usage is just prog if optionals and positionals are available calculate usage split optionals from positionals build full usage string wrap the usage parts if it s too long break usage into wrappable parts helper for wrapping lines if prog is short follow it with optionals or positionals if prog is long put it on its own line join lines into usage prefix with usage find group indices and identify actions in groups collect all actions format strings suppressed arguments are marked with none remove separators for suppressed arguments produce all arg strings if it s in a group strip the outer add the action string to the list produce the first way to invoke the option in brackets if the optional doesn t take a value format is s or long if the optional takes a value format is s args or long args make it look optional if it s not required or in a group add the action string to the list insert things at the necessary indices join all the action items with spaces clean up separators for mutually exclusive groups return the text determine the required width and the entry label no help start on same line and add a final newline short action name start on the same line and pad two spaces long action name start on the next line collect the pieces of the action help if there was help for the action add lines of help text or add a newline if the description doesn t end with one if there are any sub actions add their help as well return a single string if the optional doesn t take a value format is s long if the optional takes a value format is s args long args the textwrap module is used only for formatting help delay its import for speeding up the common usage of argparse help message formatter which retains any formatting in descriptions only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail help message formatter which retains formatting of all help text only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail help message formatter which adds default values to argument help only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail add the default value to the option help message argumentdefaultshelpformatter and booleanoptionalaction when it isn t already present this code will do that detecting cornercases to prevent duplicates or cases where it wouldn t make sense to the end user help message formatter which uses the argument type as the default metavar value instead of the argument dest only the name of this class is considered a public api all the methods provided by the class are considered an implementation detail options and arguments an error from creating or using an argument optional or positional the string value of this exception is the message augmented with information about the argument that caused it an error from trying to convert a command line string to a type action classes information about how to convert command line strings to python objects action objects are used by an argumentparser to represent the information needed to parse a single argument from one or more strings from the command line the keyword arguments to the action constructor are also all attributes of action instances keyword arguments option_strings a list of command line option strings which should be associated with this action dest the name of the attribute to hold the created object s nargs the number of command line arguments that should be consumed by default one argument will be consumed and a single value will be produced other values include n an integer consumes n arguments and produces a list consumes zero or one arguments consumes zero or more arguments and produces a list consumes one or more arguments and produces a list note that the difference between the default and nargs 1 is that with the default a single value will be produced while with nargs 1 a list containing a single value will be produced const the value to be produced if the option is specified and the option uses an action that takes no values default the value to be produced if the option is not specified type a callable that accepts a single string argument and returns the converted value the standard python types str int float and complex are useful examples of such callables if none str is used choices a container of values that should be allowed if not none after a command line argument has been converted to the appropriate type an exception will be raised if it is not a member of this collection required true if the action must always be specified at the command line this is only meaningful for optional command line arguments help the help string describing the argument metavar the name to be used for the option s argument with the help string if none the dest value will be used as the name fixme remove together with booleanoptionalaction deprecated arguments we need _deprecated special value to ban explicit arguments that match default value like parser add_argument f action booleanoptionalaction type int set prog from the existing prefix create a pseudo action to hold the choice help create the parser and add it to the map make parser available under aliases also set the parser name if requested select the parser parse all the remaining options into the namespace store any unrecognized options on the object so that the top level parser can decide what to do with them in case this subparser defines new defaults we parse them in a new namespace object and then update the original namespace for the relevant parts type classes factory for creating file object types instances of filetype are typically passed as type arguments to the argumentparser add_argument method keyword arguments mode a string indicating how the file is to be opened accepts the same values as the builtin open function bufsize the file s desired buffer size accepts the same values as the builtin open function encoding the file s encoding accepts the same values as the builtin open function errors a string indicating how encoding and decoding errors are to be handled accepts the same value as the builtin open function the special argument means sys std in out all other arguments are used as file names optional and positional parsing simple object for storing attributes implements equality by attribute names and values and provides a simple string representation set up registries register actions raise an exception if the conflict handler is invalid action storage groups defaults storage determines whether an option looks like a negative number whether or not there are any optionals that look like negative numbers uses a list so it can be shared and edited registration methods namespace default accessor methods if these defaults match any existing arguments replace the previous default on the object with the new one adding argument actions add_argument dest name value add_argument option_string option_string name value if no positional args are supplied or only one is supplied and it doesn t look like an option string parse a positional argument otherwise we re adding an optional argument if no default was supplied use the parser level default create the action object and add it to the parser raise an error if the action type is not callable raise an error if the metavar does not match the type resolve any conflicts add to actions list index the action by any option strings it has set the flag if any option strings look like negative numbers return the created action collect groups by titles this branch could happen if a derived class added groups with duplicated titles in __init__ map each action to its group if a group with the title exists use that otherwise create a new group matching the container s group map the actions to their new group add container s mutually exclusive groups note if add_mutually_exclusive_group ever gains title and description then this code will need to be expanded as above map the actions to their new mutex group add all actions to this container or their group make sure required is not specified mark positional arguments as required if at least one is always required return the keyword arguments with no option strings determine short and long option strings error on strings that don t start with an appropriate prefix strings starting with two prefix characters are long options infer destination foo bar foo_bar and x x return the updated keyword arguments determine function from conflict handler string find all options that conflict with this option resolve any conflicts remove all conflicting options remove the conflicting option if the option now has no option string remove it from the container holding it add any missing keyword arguments by checking the container group attributes share most attributes with the container object for parsing command line strings into python objects keyword arguments prog the name of the program default os path basename sys argv 0 usage a usage message default auto generated from arguments description a description of what the program does epilog text following the argument descriptions parents parsers whose arguments should be copied into this one formatter_class helpformatter class for printing help messages prefix_chars characters that prefix optional arguments fromfile_prefix_chars characters that prefix files containing additional arguments argument_default the default value for all arguments conflict_handler string indicating how to handle conflicts add_help add a h help option allow_abbrev allow long options to be abbreviated unambiguously exit_on_error determines whether or not argumentparser exits with error info when an error occurs default setting for prog register types add help argument if necessary using explicit default to override global argument_default add parent arguments and defaults pretty __repr__ methods optional positional adding methods add the parser class to the arguments if it s not present prog defaults to the usage message of this parser skipping optional arguments and with no usage prefix create the parsers action and add it to the positionals list return the created parsers action command line argument parsing methods args default to the system args make sure that args are mutable default namespace built from parser defaults add any action defaults that aren t present add any parser defaults that aren t present parse the arguments and exit if there are any errors replace arg strings that are file references map all mutually exclusive arguments to the other arguments they can t occur with find all option indices and determine the arg_string_pattern which has an o if there is an option at an index an a if there is an argument or a if there is a all args after are non options otherwise add the arg to the arg strings and note the index if it was an option join the pieces together to form the pattern converts arg strings to the appropriate and then takes the action error if this argument is not allowed with other previously seen arguments assuming that actions that use the default value don t really count as present take the action if we didn t receive a suppress value e g from a default function to convert arg_strings into an optional action get the optional identified at this index identify additional optionals in the same arg string e g xyz is the same as x y z if no args are required if we found no optional action skip it if there is an explicit argument try to match the optional s string arguments to only this if the action is a single dash option and takes no arguments try to parse more single dash options out of the tail of the option string if the action expect exactly one argument we ve successfully matched the option exit the loop error if a double dash option did not use the explicit argument if there is no explicit argument try to match the optional s string arguments with the following strings if successful exit the loop add the optional to the list and return the index at which the optional s string args stopped the list of positionals left to be parsed this is modified by consume_positionals function to convert arg_strings into positional actions match as many positionals as possible slice off the appropriate arg strings for each positional and add the positional and its args to the list slice off the positionals that we just parsed and return the index at which the positionals string args stopped consume positionals and optionals alternately until we have passed the last option string consume any positionals preceding the next option only try to parse the next optional if we didn t consume the option string during the positionals parsing if we consumed all the positionals we could and we re not at the index of an option string there were extra arguments consume the next optional and any arguments for it consume any positionals following the last optional if we didn t consume all the argument strings there were extras make sure all required actions were present and also convert action defaults which were not given as arguments convert action default now instead of doing it before parsing arguments to avoid calling convert functions twice which may fail if the argument was given but only if it was defined already in the namespace make sure all required groups had one option present if no actions were used report the error return the updated namespace and the extra arguments expand arguments referencing files for regular arguments just add them back into the list replace arguments referencing files with the file content return the modified argument list match the pattern for this action to the arg strings raise an exception if we weren t able to find a match return the number of arguments matched progressively shorten the actions list by slicing off the final actions until we find a match return the list of arg string counts if it s an empty string it was meant to be a positional if it doesn t start with a prefix it was meant to be positional if the option string is present in the parser return the action if it s just a single character it was meant to be positional if the option string before the is present return the action search through all possible prefixes of the option string and all actions in the parser for possible interpretations if multiple actions match the option string was ambiguous if exactly one action matched this segmentation is good so return the parsed action if it was not found as an option but it looks like a negative number it was meant to be positional unless there are negative number like options if it contains a space it was meant to be a positional it was meant to be an optional but there is no such option in this parser though it might be a valid option in a subparser option strings starting with two prefix characters are only split at the single character options can be concatenated with their arguments but multiple character options always have to have their argument separate shouldn t ever get here return the collected option tuples in all examples below we have to allow for args which are represented as in the pattern the default none is assumed to be a single argument allow zero or one arguments allow zero or more arguments allow one or more arguments allow any number of options or arguments allow one argument followed by any number of options or arguments suppress action like nargs 0 all others should be integers if this is an optional action is not allowed return the pattern alt command line argument parsing allowing free intermix returns a namespace and list of extras positional can be freely intermixed with optionals optionals are first parsed with all positional arguments deactivated the extras are then parsed if the parser definition is incompatible with the intermixed assumptions e g use of remainder subparsers a typeerror is raised positionals are deactivated by setting nargs and default to suppress this blocks the addition of that positional to the namespace capture the full usage for use in error messages deactivate positionals action nargs 0 remove the empty positional values from namespace restore nargs and usage before exiting parse positionals optionals aren t normally required but they could be so make sure they aren t restore parser values before exiting value conversion methods for everything but parser remainder args strip out first optional argument produces a default when not present when nargs on a positional if there were no command line args use the default if it is anything other than none since arg_strings is always at this point there is no need to use self _check_value action value single argument or optional argument produces a single value remainder arguments convert all values checking none parser arguments convert all values but check only the first suppress argument does not put anything in the namespace all other types of nargs produce a list return the converted value convert the value to the appropriate type argumenttypeerrors indicate errors typeerrors or valueerrors also indicate errors return the converted value converted value must be one of the choices if specified help formatting methods usage description positionals optionals and user defined groups epilog determine help from format above help printing methods exiting methods error message string prints a usage message incorporating the message to stderr and exits if you override this in a subclass it should not return it should either exit or raise an exception
__version__ = '1.1'
__all__ = [
    'ArgumentParser',
    'ArgumentError',
    'ArgumentTypeError',
    'BooleanOptionalAction',
    'FileType',
    'HelpFormatter',
    'ArgumentDefaultsHelpFormatter',
    'RawDescriptionHelpFormatter',
    'RawTextHelpFormatter',
    'MetavarTypeHelpFormatter',
    'Namespace',
    'Action',
    'ONE_OR_MORE',
    'OPTIONAL',
    'PARSER',
    'REMAINDER',
    'SUPPRESS',
    'ZERO_OR_MORE',
]


import os as _os
import re as _re
import sys as _sys

from gettext import gettext as _, ngettext

SUPPRESS = '==SUPPRESS=='

OPTIONAL = '?'
ZERO_OR_MORE = '*'
ONE_OR_MORE = '+'
PARSER = 'A...'
REMAINDER = '...'
_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'





class _AttributeHolder(object):
    

    def __repr__(self):
        type_name = type(self).__name__
        arg_strings = []
        star_args = {}
        for arg in self._get_args():
            arg_strings.append(repr(arg))
        for name, value in self._get_kwargs():
            if name.isidentifier():
                arg_strings.append('%s=%r' % (name, value))
            else:
                star_args[name] = value
        if star_args:
            arg_strings.append('**%s' % repr(star_args))
        return '%s(%s)' % (type_name, ', '.join(arg_strings))

    def _get_kwargs(self):
        return list(self.__dict__.items())

    def _get_args(self):
        return []


def _copy_items(items):
    if items is None:
        return []
    
    
    
    if type(items) is list:
        return items[:]
    import copy
    return copy.copy(items)







class HelpFormatter(object):
    

    def __init__(self,
                 prog,
                 indent_increment=2,
                 max_help_position=24,
                 width=None):

        
        if width is None:
            import shutil
            width = shutil.get_terminal_size().columns
            width -= 2

        self._prog = prog
        self._indent_increment = indent_increment
        self._max_help_position = min(max_help_position,
                                      max(width - 20, indent_increment * 2))
        self._width = width

        self._current_indent = 0
        self._level = 0
        self._action_max_length = 0

        self._root_section = self._Section(self, None)
        self._current_section = self._root_section

        self._whitespace_matcher = _re.compile(r'\s+', _re.ASCII)
        self._long_break_matcher = _re.compile(r'\n\n\n+')

    
    
    
    def _indent(self):
        self._current_indent += self._indent_increment
        self._level += 1

    def _dedent(self):
        self._current_indent -= self._indent_increment
        assert self._current_indent >= 0, 'Indent decreased below 0.'
        self._level -= 1

    class _Section(object):

        def __init__(self, formatter, parent, heading=None):
            self.formatter = formatter
            self.parent = parent
            self.heading = heading
            self.items = []

        def format_help(self):
            
            if self.parent is not None:
                self.formatter._indent()
            join = self.formatter._join_parts
            item_help = join([func(*args) for func, args in self.items])
            if self.parent is not None:
                self.formatter._dedent()

            
            if not item_help:
                return ''

            
            if self.heading is not SUPPRESS and self.heading is not None:
                current_indent = self.formatter._current_indent
                heading = '%*s%s:\n' % (current_indent, '', self.heading)
            else:
                heading = ''

            
            return join(['\n', heading, item_help, '\n'])

    def _add_item(self, func, args):
        self._current_section.items.append((func, args))

    
    
    
    def start_section(self, heading):
        self._indent()
        section = self._Section(self, self._current_section, heading)
        self._add_item(section.format_help, [])
        self._current_section = section

    def end_section(self):
        self._current_section = self._current_section.parent
        self._dedent()

    def add_text(self, text):
        if text is not SUPPRESS and text is not None:
            self._add_item(self._format_text, [text])

    def add_usage(self, usage, actions, groups, prefix=None):
        if usage is not SUPPRESS:
            args = usage, actions, groups, prefix
            self._add_item(self._format_usage, args)

    def add_argument(self, action):
        if action.help is not SUPPRESS:

            
            get_invocation = self._format_action_invocation
            invocations = [get_invocation(action)]
            for subaction in self._iter_indented_subactions(action):
                invocations.append(get_invocation(subaction))

            
            invocation_length = max(map(len, invocations))
            action_length = invocation_length + self._current_indent
            self._action_max_length = max(self._action_max_length,
                                          action_length)

            
            self._add_item(self._format_action, [action])

    def add_arguments(self, actions):
        for action in actions:
            self.add_argument(action)

    
    
    
    def format_help(self):
        help = self._root_section.format_help()
        if help:
            help = self._long_break_matcher.sub('\n\n', help)
            help = help.strip('\n') + '\n'
        return help

    def _join_parts(self, part_strings):
        return ''.join([part
                        for part in part_strings
                        if part and part is not SUPPRESS])

    def _format_usage(self, usage, actions, groups, prefix):
        if prefix is None:
            prefix = _('usage: ')

        
        if usage is not None:
            usage = usage % dict(prog=self._prog)

        
        elif usage is None and not actions:
            usage = '%(prog)s' % dict(prog=self._prog)

        
        elif usage is None:
            prog = '%(prog)s' % dict(prog=self._prog)

            
            optionals = []
            positionals = []
            for action in actions:
                if action.option_strings:
                    optionals.append(action)
                else:
                    positionals.append(action)

            
            format = self._format_actions_usage
            action_usage = format(optionals + positionals, groups)
            usage = ' '.join([s for s in [prog, action_usage] if s])

            
            text_width = self._width - self._current_indent
            if len(prefix) + len(usage) > text_width:

                
                part_regexp = (
                    r'\(.*?\)+(?=\s|$)|'
                    r'\[.*?\]+(?=\s|$)|'
                    r'\S+'
                )
                opt_usage = format(optionals, groups)
                pos_usage = format(positionals, groups)
                opt_parts = _re.findall(part_regexp, opt_usage)
                pos_parts = _re.findall(part_regexp, pos_usage)
                assert ' '.join(opt_parts) == opt_usage
                assert ' '.join(pos_parts) == pos_usage

                
                def get_lines(parts, indent, prefix=None):
                    lines = []
                    line = []
                    indent_length = len(indent)
                    if prefix is not None:
                        line_len = len(prefix) - 1
                    else:
                        line_len = indent_length - 1
                    for part in parts:
                        if line_len + 1 + len(part) > text_width and line:
                            lines.append(indent + ' '.join(line))
                            line = []
                            line_len = indent_length - 1
                        line.append(part)
                        line_len += len(part) + 1
                    if line:
                        lines.append(indent + ' '.join(line))
                    if prefix is not None:
                        lines[0] = lines[0][indent_length:]
                    return lines

                
                if len(prefix) + len(prog) <= 0.75 * text_width:
                    indent = ' ' * (len(prefix) + len(prog) + 1)
                    if opt_parts:
                        lines = get_lines([prog] + opt_parts, indent, prefix)
                        lines.extend(get_lines(pos_parts, indent))
                    elif pos_parts:
                        lines = get_lines([prog] + pos_parts, indent, prefix)
                    else:
                        lines = [prog]

                
                else:
                    indent = ' ' * len(prefix)
                    parts = opt_parts + pos_parts
                    lines = get_lines(parts, indent)
                    if len(lines) > 1:
                        lines = []
                        lines.extend(get_lines(opt_parts, indent))
                        lines.extend(get_lines(pos_parts, indent))
                    lines = [prog] + lines

                
                usage = '\n'.join(lines)

        
        return '%s%s\n\n' % (prefix, usage)

    def _format_actions_usage(self, actions, groups):
        
        group_actions = set()
        inserts = {}
        for group in groups:
            if not group._group_actions:
                raise ValueError(f'empty group {group}')

            try:
                start = actions.index(group._group_actions[0])
            except ValueError:
                continue
            else:
                group_action_count = len(group._group_actions)
                end = start + group_action_count
                if actions[start:end] == group._group_actions:

                    suppressed_actions_count = 0
                    for action in group._group_actions:
                        group_actions.add(action)
                        if action.help is SUPPRESS:
                            suppressed_actions_count += 1

                    exposed_actions_count = group_action_count - suppressed_actions_count

                    if not group.required:
                        if start in inserts:
                            inserts[start] += ' ['
                        else:
                            inserts[start] = '['
                        if end in inserts:
                            inserts[end] += ']'
                        else:
                            inserts[end] = ']'
                    elif exposed_actions_count > 1:
                        if start in inserts:
                            inserts[start] += ' ('
                        else:
                            inserts[start] = '('
                        if end in inserts:
                            inserts[end] += ')'
                        else:
                            inserts[end] = ')'
                    for i in range(start + 1, end):
                        inserts[i] = '|'

        
        parts = []
        for i, action in enumerate(actions):

            
            
            if action.help is SUPPRESS:
                parts.append(None)
                if inserts.get(i) == '|':
                    inserts.pop(i)
                elif inserts.get(i + 1) == '|':
                    inserts.pop(i + 1)

            
            elif not action.option_strings:
                default = self._get_default_metavar_for_positional(action)
                part = self._format_args(action, default)

                
                if action in group_actions:
                    if part[0] == '[' and part[-1] == ']':
                        part = part[1:-1]

                
                parts.append(part)

            
            else:
                option_string = action.option_strings[0]

                
                
                if action.nargs == 0:
                    part = action.format_usage()

                
                
                else:
                    default = self._get_default_metavar_for_optional(action)
                    args_string = self._format_args(action, default)
                    part = '%s %s' % (option_string, args_string)

                
                if not action.required and action not in group_actions:
                    part = '[%s]' % part

                
                parts.append(part)

        
        for i in sorted(inserts, reverse=True):
            parts[i:i] = [inserts[i]]

        
        text = ' '.join([item for item in parts if item is not None])

        
        open = r'[\[(]'
        close = r'[\])]'
        text = _re.sub(r'(%s) ' % open, r'\1', text)
        text = _re.sub(r' (%s)' % close, r'\1', text)
        text = _re.sub(r'%s *%s' % (open, close), r'', text)
        text = text.strip()

        
        return text

    def _format_text(self, text):
        if '%(prog)' in text:
            text = text % dict(prog=self._prog)
        text_width = max(self._width - self._current_indent, 11)
        indent = ' ' * self._current_indent
        return self._fill_text(text, text_width, indent) + '\n\n'

    def _format_action(self, action):
        
        help_position = min(self._action_max_length + 2,
                            self._max_help_position)
        help_width = max(self._width - help_position, 11)
        action_width = help_position - self._current_indent - 2
        action_header = self._format_action_invocation(action)

        
        if not action.help:
            tup = self._current_indent, '', action_header
            action_header = '%*s%s\n' % tup

        
        elif len(action_header) <= action_width:
            tup = self._current_indent, '', action_width, action_header
            action_header = '%*s%-*s  ' % tup
            indent_first = 0

        
        else:
            tup = self._current_indent, '', action_header
            action_header = '%*s%s\n' % tup
            indent_first = help_position

        
        parts = [action_header]

        
        if action.help and action.help.strip():
            help_text = self._expand_help(action)
            if help_text:
                help_lines = self._split_lines(help_text, help_width)
                parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
                for line in help_lines[1:]:
                    parts.append('%*s%s\n' % (help_position, '', line))

        
        elif not action_header.endswith('\n'):
            parts.append('\n')

        
        for subaction in self._iter_indented_subactions(action):
            parts.append(self._format_action(subaction))

        
        return self._join_parts(parts)

    def _format_action_invocation(self, action):
        if not action.option_strings:
            default = self._get_default_metavar_for_positional(action)
            metavar, = self._metavar_formatter(action, default)(1)
            return metavar

        else:
            parts = []

            
            
            if action.nargs == 0:
                parts.extend(action.option_strings)

            
            
            else:
                default = self._get_default_metavar_for_optional(action)
                args_string = self._format_args(action, default)
                for option_string in action.option_strings:
                    parts.append('%s %s' % (option_string, args_string))

            return ', '.join(parts)

    def _metavar_formatter(self, action, default_metavar):
        if action.metavar is not None:
            result = action.metavar
        elif action.choices is not None:
            choice_strs = [str(choice) for choice in action.choices]
            result = '{%s}' % ','.join(choice_strs)
        else:
            result = default_metavar

        def format(tuple_size):
            if isinstance(result, tuple):
                return result
            else:
                return (result, ) * tuple_size
        return format

    def _format_args(self, action, default_metavar):
        get_metavar = self._metavar_formatter(action, default_metavar)
        if action.nargs is None:
            result = '%s' % get_metavar(1)
        elif action.nargs == OPTIONAL:
            result = '[%s]' % get_metavar(1)
        elif action.nargs == ZERO_OR_MORE:
            metavar = get_metavar(1)
            if len(metavar) == 2:
                result = '[%s [%s ...]]' % metavar
            else:
                result = '[%s ...]' % metavar
        elif action.nargs == ONE_OR_MORE:
            result = '%s [%s ...]' % get_metavar(2)
        elif action.nargs == REMAINDER:
            result = '...'
        elif action.nargs == PARSER:
            result = '%s ...' % get_metavar(1)
        elif action.nargs == SUPPRESS:
            result = ''
        else:
            try:
                formats = ['%s' for _ in range(action.nargs)]
            except TypeError:
                raise ValueError("invalid nargs value") from None
            result = ' '.join(formats) % get_metavar(action.nargs)
        return result

    def _expand_help(self, action):
        params = dict(vars(action), prog=self._prog)
        for name in list(params):
            if params[name] is SUPPRESS:
                del params[name]
        for name in list(params):
            if hasattr(params[name], '__name__'):
                params[name] = params[name].__name__
        if params.get('choices') is not None:
            choices_str = ', '.join([str(c) for c in params['choices']])
            params['choices'] = choices_str
        return self._get_help_string(action) % params

    def _iter_indented_subactions(self, action):
        try:
            get_subactions = action._get_subactions
        except AttributeError:
            pass
        else:
            self._indent()
            yield from get_subactions()
            self._dedent()

    def _split_lines(self, text, width):
        text = self._whitespace_matcher.sub(' ', text).strip()
        
        
        import textwrap
        return textwrap.wrap(text, width)

    def _fill_text(self, text, width, indent):
        text = self._whitespace_matcher.sub(' ', text).strip()
        import textwrap
        return textwrap.fill(text, width,
                             initial_indent=indent,
                             subsequent_indent=indent)

    def _get_help_string(self, action):
        return action.help

    def _get_default_metavar_for_optional(self, action):
        return action.dest.upper()

    def _get_default_metavar_for_positional(self, action):
        return action.dest


class RawDescriptionHelpFormatter(HelpFormatter):
    

    def _fill_text(self, text, width, indent):
        return ''.join(indent + line for line in text.splitlines(keepends=True))


class RawTextHelpFormatter(RawDescriptionHelpFormatter):
    

    def _split_lines(self, text, width):
        return text.splitlines()


class ArgumentDefaultsHelpFormatter(HelpFormatter):
    

    def _get_help_string(self, action):
        
        help = action.help
        if help is None:
            help = ''

        if '%(default)' not in help:
            if action.default is not SUPPRESS:
                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
                if action.option_strings or action.nargs in defaulting_nargs:
                    help += ' (default: %(default)s)'
        return help



class MetavarTypeHelpFormatter(HelpFormatter):
    

    def _get_default_metavar_for_optional(self, action):
        return action.type.__name__

    def _get_default_metavar_for_positional(self, action):
        return action.type.__name__






def _get_action_name(argument):
    if argument is None:
        return None
    elif argument.option_strings:
        return '/'.join(argument.option_strings)
    elif argument.metavar not in (None, SUPPRESS):
        return argument.metavar
    elif argument.dest not in (None, SUPPRESS):
        return argument.dest
    elif argument.choices:
        return '{' + ','.join(argument.choices) + '}'
    else:
        return None


class ArgumentError(Exception):
    

    def __init__(self, argument, message):
        self.argument_name = _get_action_name(argument)
        self.message = message

    def __str__(self):
        if self.argument_name is None:
            format = '%(message)s'
        else:
            format = _('argument %(argument_name)s: %(message)s')
        return format % dict(message=self.message,
                             argument_name=self.argument_name)


class ArgumentTypeError(Exception):
    
    pass






class Action(_AttributeHolder):
    

    def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        self.option_strings = option_strings
        self.dest = dest
        self.nargs = nargs
        self.const = const
        self.default = default
        self.type = type
        self.choices = choices
        self.required = required
        self.help = help
        self.metavar = metavar

    def _get_kwargs(self):
        names = [
            'option_strings',
            'dest',
            'nargs',
            'const',
            'default',
            'type',
            'choices',
            'required',
            'help',
            'metavar',
        ]
        return [(name, getattr(self, name)) for name in names]

    def format_usage(self):
        return self.option_strings[0]

    def __call__(self, parser, namespace, values, option_string=None):
        raise NotImplementedError(_('.__call__() not defined'))



_deprecated_default = object()

class BooleanOptionalAction(Action):
    def __init__(self,
                 option_strings,
                 dest,
                 default=None,
                 type=_deprecated_default,
                 choices=_deprecated_default,
                 required=False,
                 help=None,
                 metavar=_deprecated_default):

        _option_strings = []
        for option_string in option_strings:
            _option_strings.append(option_string)

            if option_string.startswith('--'):
                option_string = '--no-' + option_string[2:]
                _option_strings.append(option_string)

        
        
        
        for field_name in ('type', 'choices', 'metavar'):
            if locals()[field_name] is not _deprecated_default:
                import warnings
                warnings._deprecated(
                    field_name,
                    "{name!r} is deprecated as of Python 3.12 and will be "
                    "removed in Python {remove}.",
                    remove=(3, 14))

        if type is _deprecated_default:
            type = None
        if choices is _deprecated_default:
            choices = None
        if metavar is _deprecated_default:
            metavar = None

        super().__init__(
            option_strings=_option_strings,
            dest=dest,
            nargs=0,
            default=default,
            type=type,
            choices=choices,
            required=required,
            help=help,
            metavar=metavar)


    def __call__(self, parser, namespace, values, option_string=None):
        if option_string in self.option_strings:
            setattr(namespace, self.dest, not option_string.startswith('--no-'))

    def format_usage(self):
        return ' | '.join(self.option_strings)


class _StoreAction(Action):

    def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        if nargs == 0:
            raise ValueError('nargs for store actions must be != 0; if you '
                             'have nothing to store, actions such as store '
                             'true or store const may be more appropriate')
        if const is not None and nargs != OPTIONAL:
            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
        super(_StoreAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=nargs,
            const=const,
            default=default,
            type=type,
            choices=choices,
            required=required,
            help=help,
            metavar=metavar)

    def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, self.dest, values)


class _StoreConstAction(Action):

    def __init__(self,
                 option_strings,
                 dest,
                 const=None,
                 default=None,
                 required=False,
                 help=None,
                 metavar=None):
        super(_StoreConstAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=0,
            const=const,
            default=default,
            required=required,
            help=help)

    def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, self.dest, self.const)


class _StoreTrueAction(_StoreConstAction):

    def __init__(self,
                 option_strings,
                 dest,
                 default=False,
                 required=False,
                 help=None):
        super(_StoreTrueAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            const=True,
            default=default,
            required=required,
            help=help)


class _StoreFalseAction(_StoreConstAction):

    def __init__(self,
                 option_strings,
                 dest,
                 default=True,
                 required=False,
                 help=None):
        super(_StoreFalseAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            const=False,
            default=default,
            required=required,
            help=help)


class _AppendAction(Action):

    def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        if nargs == 0:
            raise ValueError('nargs for append actions must be != 0; if arg '
                             'strings are not supplying the value to append, '
                             'the append const action may be more appropriate')
        if const is not None and nargs != OPTIONAL:
            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
        super(_AppendAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=nargs,
            const=const,
            default=default,
            type=type,
            choices=choices,
            required=required,
            help=help,
            metavar=metavar)

    def __call__(self, parser, namespace, values, option_string=None):
        items = getattr(namespace, self.dest, None)
        items = _copy_items(items)
        items.append(values)
        setattr(namespace, self.dest, items)


class _AppendConstAction(Action):

    def __init__(self,
                 option_strings,
                 dest,
                 const=None,
                 default=None,
                 required=False,
                 help=None,
                 metavar=None):
        super(_AppendConstAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=0,
            const=const,
            default=default,
            required=required,
            help=help,
            metavar=metavar)

    def __call__(self, parser, namespace, values, option_string=None):
        items = getattr(namespace, self.dest, None)
        items = _copy_items(items)
        items.append(self.const)
        setattr(namespace, self.dest, items)


class _CountAction(Action):

    def __init__(self,
                 option_strings,
                 dest,
                 default=None,
                 required=False,
                 help=None):
        super(_CountAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=0,
            default=default,
            required=required,
            help=help)

    def __call__(self, parser, namespace, values, option_string=None):
        count = getattr(namespace, self.dest, None)
        if count is None:
            count = 0
        setattr(namespace, self.dest, count + 1)


class _HelpAction(Action):

    def __init__(self,
                 option_strings,
                 dest=SUPPRESS,
                 default=SUPPRESS,
                 help=None):
        super(_HelpAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            default=default,
            nargs=0,
            help=help)

    def __call__(self, parser, namespace, values, option_string=None):
        parser.print_help()
        parser.exit()


class _VersionAction(Action):

    def __init__(self,
                 option_strings,
                 version=None,
                 dest=SUPPRESS,
                 default=SUPPRESS,
                 help="show program's version number and exit"):
        super(_VersionAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            default=default,
            nargs=0,
            help=help)
        self.version = version

    def __call__(self, parser, namespace, values, option_string=None):
        version = self.version
        if version is None:
            version = parser.version
        formatter = parser._get_formatter()
        formatter.add_text(version)
        parser._print_message(formatter.format_help(), _sys.stdout)
        parser.exit()


class _SubParsersAction(Action):

    class _ChoicesPseudoAction(Action):

        def __init__(self, name, aliases, help):
            metavar = dest = name
            if aliases:
                metavar += ' (%s)' % ', '.join(aliases)
            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
            sup.__init__(option_strings=[], dest=dest, help=help,
                         metavar=metavar)

    def __init__(self,
                 option_strings,
                 prog,
                 parser_class,
                 dest=SUPPRESS,
                 required=False,
                 help=None,
                 metavar=None):

        self._prog_prefix = prog
        self._parser_class = parser_class
        self._name_parser_map = {}
        self._choices_actions = []

        super(_SubParsersAction, self).__init__(
            option_strings=option_strings,
            dest=dest,
            nargs=PARSER,
            choices=self._name_parser_map,
            required=required,
            help=help,
            metavar=metavar)

    def add_parser(self, name, **kwargs):
        
        if kwargs.get('prog') is None:
            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)

        aliases = kwargs.pop('aliases', ())

        if name in self._name_parser_map:
            raise ArgumentError(self, _('conflicting subparser: %s') % name)
        for alias in aliases:
            if alias in self._name_parser_map:
                raise ArgumentError(
                    self, _('conflicting subparser alias: %s') % alias)

        
        if 'help' in kwargs:
            help = kwargs.pop('help')
            choice_action = self._ChoicesPseudoAction(name, aliases, help)
            self._choices_actions.append(choice_action)

        
        parser = self._parser_class(**kwargs)
        self._name_parser_map[name] = parser

        
        for alias in aliases:
            self._name_parser_map[alias] = parser

        return parser

    def _get_subactions(self):
        return self._choices_actions

    def __call__(self, parser, namespace, values, option_string=None):
        parser_name = values[0]
        arg_strings = values[1:]

        
        if self.dest is not SUPPRESS:
            setattr(namespace, self.dest, parser_name)

        
        try:
            parser = self._name_parser_map[parser_name]
        except KeyError:
            args = {'parser_name': parser_name,
                    'choices': ', '.join(self._name_parser_map)}
            msg = _('unknown parser %(parser_name)r (choices: %(choices)s)') % args
            raise ArgumentError(self, msg)

        
        
        

        
        
        
        subnamespace, arg_strings = parser.parse_known_args(arg_strings, None)
        for key, value in vars(subnamespace).items():
            setattr(namespace, key, value)

        if arg_strings:
            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)

class _ExtendAction(_AppendAction):
    def __call__(self, parser, namespace, values, option_string=None):
        items = getattr(namespace, self.dest, None)
        items = _copy_items(items)
        items.extend(values)
        setattr(namespace, self.dest, items)





class FileType(object):
    

    def __init__(self, mode='r', bufsize=-1, encoding=None, errors=None):
        self._mode = mode
        self._bufsize = bufsize
        self._encoding = encoding
        self._errors = errors

    def __call__(self, string):
        
        if string == '-':
            if 'r' in self._mode:
                return _sys.stdin.buffer if 'b' in self._mode else _sys.stdin
            elif any(c in self._mode for c in 'wax'):
                return _sys.stdout.buffer if 'b' in self._mode else _sys.stdout
            else:
                msg = _('argument "-" with mode %r') % self._mode
                raise ValueError(msg)

        
        try:
            return open(string, self._mode, self._bufsize, self._encoding,
                        self._errors)
        except OSError as e:
            args = {'filename': string, 'error': e}
            message = _("can't open '%(filename)s': %(error)s")
            raise ArgumentTypeError(message % args)

    def __repr__(self):
        args = self._mode, self._bufsize
        kwargs = [('encoding', self._encoding), ('errors', self._errors)]
        args_str = ', '.join([repr(arg) for arg in args if arg != -1] +
                             ['%s=%r' % (kw, arg) for kw, arg in kwargs
                              if arg is not None])
        return '%s(%s)' % (type(self).__name__, args_str)





class Namespace(_AttributeHolder):
    

    def __init__(self, **kwargs):
        for name in kwargs:
            setattr(self, name, kwargs[name])

    def __eq__(self, other):
        if not isinstance(other, Namespace):
            return NotImplemented
        return vars(self) == vars(other)

    def __contains__(self, key):
        return key in self.__dict__


class _ActionsContainer(object):

    def __init__(self,
                 description,
                 prefix_chars,
                 argument_default,
                 conflict_handler):
        super(_ActionsContainer, self).__init__()

        self.description = description
        self.argument_default = argument_default
        self.prefix_chars = prefix_chars
        self.conflict_handler = conflict_handler

        
        self._registries = {}

        
        self.register('action', None, _StoreAction)
        self.register('action', 'store', _StoreAction)
        self.register('action', 'store_const', _StoreConstAction)
        self.register('action', 'store_true', _StoreTrueAction)
        self.register('action', 'store_false', _StoreFalseAction)
        self.register('action', 'append', _AppendAction)
        self.register('action', 'append_const', _AppendConstAction)
        self.register('action', 'count', _CountAction)
        self.register('action', 'help', _HelpAction)
        self.register('action', 'version', _VersionAction)
        self.register('action', 'parsers', _SubParsersAction)
        self.register('action', 'extend', _ExtendAction)

        
        self._get_handler()

        
        self._actions = []
        self._option_string_actions = {}

        
        self._action_groups = []
        self._mutually_exclusive_groups = []

        
        self._defaults = {}

        
        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')

        
        
        self._has_negative_number_optionals = []

    
    
    
    def register(self, registry_name, value, object):
        registry = self._registries.setdefault(registry_name, {})
        registry[value] = object

    def _registry_get(self, registry_name, value, default=None):
        return self._registries[registry_name].get(value, default)

    
    
    
    def set_defaults(self, **kwargs):
        self._defaults.update(kwargs)

        
        
        for action in self._actions:
            if action.dest in kwargs:
                action.default = kwargs[action.dest]

    def get_default(self, dest):
        for action in self._actions:
            if action.dest == dest and action.default is not None:
                return action.default
        return self._defaults.get(dest, None)


    
    
    
    def add_argument(self, *args, **kwargs):
        

        
        
        
        chars = self.prefix_chars
        if not args or len(args) == 1 and args[0][0] not in chars:
            if args and 'dest' in kwargs:
                raise ValueError('dest supplied twice for positional argument')
            kwargs = self._get_positional_kwargs(*args, **kwargs)

        
        else:
            kwargs = self._get_optional_kwargs(*args, **kwargs)

        
        if 'default' not in kwargs:
            dest = kwargs['dest']
            if dest in self._defaults:
                kwargs['default'] = self._defaults[dest]
            elif self.argument_default is not None:
                kwargs['default'] = self.argument_default

        
        action_class = self._pop_action_class(kwargs)
        if not callable(action_class):
            raise ValueError('unknown action "%s"' % (action_class,))
        action = action_class(**kwargs)

        
        type_func = self._registry_get('type', action.type, action.type)
        if not callable(type_func):
            raise ValueError('%r is not callable' % (type_func,))

        if type_func is FileType:
            raise ValueError('%r is a FileType class object, instance of it'
                             ' must be passed' % (type_func,))

        
        if hasattr(self, "_get_formatter"):
            try:
                self._get_formatter()._format_args(action, None)
            except TypeError:
                raise ValueError("length of metavar tuple does not match nargs")

        return self._add_action(action)

    def add_argument_group(self, *args, **kwargs):
        group = _ArgumentGroup(self, *args, **kwargs)
        self._action_groups.append(group)
        return group

    def add_mutually_exclusive_group(self, **kwargs):
        group = _MutuallyExclusiveGroup(self, **kwargs)
        self._mutually_exclusive_groups.append(group)
        return group

    def _add_action(self, action):
        
        self._check_conflict(action)

        
        self._actions.append(action)
        action.container = self

        
        for option_string in action.option_strings:
            self._option_string_actions[option_string] = action

        
        for option_string in action.option_strings:
            if self._negative_number_matcher.match(option_string):
                if not self._has_negative_number_optionals:
                    self._has_negative_number_optionals.append(True)

        
        return action

    def _remove_action(self, action):
        self._actions.remove(action)

    def _add_container_actions(self, container):
        
        title_group_map = {}
        for group in self._action_groups:
            if group.title in title_group_map:
                
                
                msg = _('cannot merge actions - two groups are named %r')
                raise ValueError(msg % (group.title))
            title_group_map[group.title] = group

        
        group_map = {}
        for group in container._action_groups:

            
            
            if group.title not in title_group_map:
                title_group_map[group.title] = self.add_argument_group(
                    title=group.title,
                    description=group.description,
                    conflict_handler=group.conflict_handler)

            
            for action in group._group_actions:
                group_map[action] = title_group_map[group.title]

        
        
        
        for group in container._mutually_exclusive_groups:
            mutex_group = self.add_mutually_exclusive_group(
                required=group.required)

            
            for action in group._group_actions:
                group_map[action] = mutex_group

        
        for action in container._actions:
            group_map.get(action, self)._add_action(action)

    def _get_positional_kwargs(self, dest, **kwargs):
        
        if 'required' in kwargs:
            msg = _("'required' is an invalid argument for positionals")
            raise TypeError(msg)

        
        
        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
            kwargs['required'] = True
        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
            kwargs['required'] = True

        
        return dict(kwargs, dest=dest, option_strings=[])

    def _get_optional_kwargs(self, *args, **kwargs):
        
        option_strings = []
        long_option_strings = []
        for option_string in args:
            
            if not option_string[0] in self.prefix_chars:
                args = {'option': option_string,
                        'prefix_chars': self.prefix_chars}
                msg = _('invalid option string %(option)r: '
                        'must start with a character %(prefix_chars)r')
                raise ValueError(msg % args)

            
            option_strings.append(option_string)
            if len(option_string) > 1 and option_string[1] in self.prefix_chars:
                long_option_strings.append(option_string)

        
        dest = kwargs.pop('dest', None)
        if dest is None:
            if long_option_strings:
                dest_option_string = long_option_strings[0]
            else:
                dest_option_string = option_strings[0]
            dest = dest_option_string.lstrip(self.prefix_chars)
            if not dest:
                msg = _('dest= is required for options like %r')
                raise ValueError(msg % option_string)
            dest = dest.replace('-', '_')

        
        return dict(kwargs, dest=dest, option_strings=option_strings)

    def _pop_action_class(self, kwargs, default=None):
        action = kwargs.pop('action', default)
        return self._registry_get('action', action, action)

    def _get_handler(self):
        
        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
        try:
            return getattr(self, handler_func_name)
        except AttributeError:
            msg = _('invalid conflict_resolution value: %r')
            raise ValueError(msg % self.conflict_handler)

    def _check_conflict(self, action):

        
        confl_optionals = []
        for option_string in action.option_strings:
            if option_string in self._option_string_actions:
                confl_optional = self._option_string_actions[option_string]
                confl_optionals.append((option_string, confl_optional))

        
        if confl_optionals:
            conflict_handler = self._get_handler()
            conflict_handler(action, confl_optionals)

    def _handle_conflict_error(self, action, conflicting_actions):
        message = ngettext('conflicting option string: %s',
                           'conflicting option strings: %s',
                           len(conflicting_actions))
        conflict_string = ', '.join([option_string
                                     for option_string, action
                                     in conflicting_actions])
        raise ArgumentError(action, message % conflict_string)

    def _handle_conflict_resolve(self, action, conflicting_actions):

        
        for option_string, action in conflicting_actions:

            
            action.option_strings.remove(option_string)
            self._option_string_actions.pop(option_string, None)

            
            
            if not action.option_strings:
                action.container._remove_action(action)


class _ArgumentGroup(_ActionsContainer):

    def __init__(self, container, title=None, description=None, **kwargs):
        
        update = kwargs.setdefault
        update('conflict_handler', container.conflict_handler)
        update('prefix_chars', container.prefix_chars)
        update('argument_default', container.argument_default)
        super_init = super(_ArgumentGroup, self).__init__
        super_init(description=description, **kwargs)

        
        self.title = title
        self._group_actions = []

        
        self._registries = container._registries
        self._actions = container._actions
        self._option_string_actions = container._option_string_actions
        self._defaults = container._defaults
        self._has_negative_number_optionals = \
            container._has_negative_number_optionals
        self._mutually_exclusive_groups = container._mutually_exclusive_groups

    def _add_action(self, action):
        action = super(_ArgumentGroup, self)._add_action(action)
        self._group_actions.append(action)
        return action

    def _remove_action(self, action):
        super(_ArgumentGroup, self)._remove_action(action)
        self._group_actions.remove(action)

    def add_argument_group(self, *args, **kwargs):
        import warnings
        warnings.warn(
            "Nesting argument groups is deprecated.",
            category=DeprecationWarning,
            stacklevel=2
        )
        return super().add_argument_group(*args, **kwargs)


class _MutuallyExclusiveGroup(_ArgumentGroup):

    def __init__(self, container, required=False):
        super(_MutuallyExclusiveGroup, self).__init__(container)
        self.required = required
        self._container = container

    def _add_action(self, action):
        if action.required:
            msg = _('mutually exclusive arguments must be optional')
            raise ValueError(msg)
        action = self._container._add_action(action)
        self._group_actions.append(action)
        return action

    def _remove_action(self, action):
        self._container._remove_action(action)
        self._group_actions.remove(action)

    def add_mutually_exclusive_group(self, *args, **kwargs):
        import warnings
        warnings.warn(
            "Nesting mutually exclusive groups is deprecated.",
            category=DeprecationWarning,
            stacklevel=2
        )
        return super().add_mutually_exclusive_group(*args, **kwargs)


class ArgumentParser(_AttributeHolder, _ActionsContainer):
    

    def __init__(self,
                 prog=None,
                 usage=None,
                 description=None,
                 epilog=None,
                 parents=[],
                 formatter_class=HelpFormatter,
                 prefix_chars='-',
                 fromfile_prefix_chars=None,
                 argument_default=None,
                 conflict_handler='error',
                 add_help=True,
                 allow_abbrev=True,
                 exit_on_error=True):

        superinit = super(ArgumentParser, self).__init__
        superinit(description=description,
                  prefix_chars=prefix_chars,
                  argument_default=argument_default,
                  conflict_handler=conflict_handler)

        
        if prog is None:
            prog = _os.path.basename(_sys.argv[0])

        self.prog = prog
        self.usage = usage
        self.epilog = epilog
        self.formatter_class = formatter_class
        self.fromfile_prefix_chars = fromfile_prefix_chars
        self.add_help = add_help
        self.allow_abbrev = allow_abbrev
        self.exit_on_error = exit_on_error

        add_group = self.add_argument_group
        self._positionals = add_group(_('positional arguments'))
        self._optionals = add_group(_('options'))
        self._subparsers = None

        
        def identity(string):
            return string
        self.register('type', None, identity)

        
        
        default_prefix = '-' if '-' in prefix_chars else prefix_chars[0]
        if self.add_help:
            self.add_argument(
                default_prefix+'h', default_prefix*2+'help',
                action='help', default=SUPPRESS,
                help=_('show this help message and exit'))

        
        for parent in parents:
            if not isinstance(parent, ArgumentParser):
                raise TypeError('parents must be a list of ArgumentParser')
            self._add_container_actions(parent)
            defaults = parent._defaults
            self._defaults.update(defaults)

    
    
    
    def _get_kwargs(self):
        names = [
            'prog',
            'usage',
            'description',
            'formatter_class',
            'conflict_handler',
            'add_help',
        ]
        return [(name, getattr(self, name)) for name in names]

    
    
    
    def add_subparsers(self, **kwargs):
        if self._subparsers is not None:
            self.error(_('cannot have multiple subparser arguments'))

        
        kwargs.setdefault('parser_class', type(self))

        if 'title' in kwargs or 'description' in kwargs:
            title = _(kwargs.pop('title', 'subcommands'))
            description = _(kwargs.pop('description', None))
            self._subparsers = self.add_argument_group(title, description)
        else:
            self._subparsers = self._positionals

        
        
        if kwargs.get('prog') is None:
            formatter = self._get_formatter()
            positionals = self._get_positional_actions()
            groups = self._mutually_exclusive_groups
            formatter.add_usage(self.usage, positionals, groups, '')
            kwargs['prog'] = formatter.format_help().strip()

        
        parsers_class = self._pop_action_class(kwargs, 'parsers')
        action = parsers_class(option_strings=[], **kwargs)
        self._subparsers._add_action(action)

        
        return action

    def _add_action(self, action):
        if action.option_strings:
            self._optionals._add_action(action)
        else:
            self._positionals._add_action(action)
        return action

    def _get_optional_actions(self):
        return [action
                for action in self._actions
                if action.option_strings]

    def _get_positional_actions(self):
        return [action
                for action in self._actions
                if not action.option_strings]

    
    
    
    def parse_args(self, args=None, namespace=None):
        args, argv = self.parse_known_args(args, namespace)
        if argv:
            msg = _('unrecognized arguments: %s')
            self.error(msg % ' '.join(argv))
        return args

    def parse_known_args(self, args=None, namespace=None):
        if args is None:
            
            args = _sys.argv[1:]
        else:
            
            args = list(args)

        
        if namespace is None:
            namespace = Namespace()

        
        for action in self._actions:
            if action.dest is not SUPPRESS:
                if not hasattr(namespace, action.dest):
                    if action.default is not SUPPRESS:
                        setattr(namespace, action.dest, action.default)

        
        for dest in self._defaults:
            if not hasattr(namespace, dest):
                setattr(namespace, dest, self._defaults[dest])

        
        if self.exit_on_error:
            try:
                namespace, args = self._parse_known_args(args, namespace)
            except ArgumentError as err:
                self.error(str(err))
        else:
            namespace, args = self._parse_known_args(args, namespace)

        if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
            args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
            delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
        return namespace, args

    def _parse_known_args(self, arg_strings, namespace):
        
        if self.fromfile_prefix_chars is not None:
            arg_strings = self._read_args_from_files(arg_strings)

        
        
        action_conflicts = {}
        for mutex_group in self._mutually_exclusive_groups:
            group_actions = mutex_group._group_actions
            for i, mutex_action in enumerate(mutex_group._group_actions):
                conflicts = action_conflicts.setdefault(mutex_action, [])
                conflicts.extend(group_actions[:i])
                conflicts.extend(group_actions[i + 1:])

        
        
        
        option_string_indices = {}
        arg_string_pattern_parts = []
        arg_strings_iter = iter(arg_strings)
        for i, arg_string in enumerate(arg_strings_iter):

            
            if arg_string == '--':
                arg_string_pattern_parts.append('-')
                for arg_string in arg_strings_iter:
                    arg_string_pattern_parts.append('A')

            
            
            else:
                option_tuple = self._parse_optional(arg_string)
                if option_tuple is None:
                    pattern = 'A'
                else:
                    option_string_indices[i] = option_tuple
                    pattern = 'O'
                arg_string_pattern_parts.append(pattern)

        
        arg_strings_pattern = ''.join(arg_string_pattern_parts)

        
        seen_actions = set()
        seen_non_default_actions = set()

        def take_action(action, argument_strings, option_string=None):
            seen_actions.add(action)
            argument_values = self._get_values(action, argument_strings)

            
            
            
            if argument_values is not action.default:
                seen_non_default_actions.add(action)
                for conflict_action in action_conflicts.get(action, []):
                    if conflict_action in seen_non_default_actions:
                        msg = _('not allowed with argument %s')
                        action_name = _get_action_name(conflict_action)
                        raise ArgumentError(action, msg % action_name)

            
            
            if argument_values is not SUPPRESS:
                action(self, namespace, argument_values, option_string)

        
        def consume_optional(start_index):

            
            option_tuple = option_string_indices[start_index]
            action, option_string, explicit_arg = option_tuple

            
            
            match_argument = self._match_argument
            action_tuples = []
            while True:

                
                if action is None:
                    extras.append(arg_strings[start_index])
                    return start_index + 1

                
                
                if explicit_arg is not None:
                    arg_count = match_argument(action, 'A')

                    
                    
                    
                    chars = self.prefix_chars
                    if (
                        arg_count == 0
                        and option_string[1] not in chars
                        and explicit_arg != ''
                    ):
                        action_tuples.append((action, [], option_string))
                        char = option_string[0]
                        option_string = char + explicit_arg[0]
                        new_explicit_arg = explicit_arg[1:] or None
                        optionals_map = self._option_string_actions
                        if option_string in optionals_map:
                            action = optionals_map[option_string]
                            explicit_arg = new_explicit_arg
                        else:
                            msg = _('ignored explicit argument %r')
                            raise ArgumentError(action, msg % explicit_arg)

                    
                    
                    elif arg_count == 1:
                        stop = start_index + 1
                        args = [explicit_arg]
                        action_tuples.append((action, args, option_string))
                        break

                    
                    
                    else:
                        msg = _('ignored explicit argument %r')
                        raise ArgumentError(action, msg % explicit_arg)

                
                
                
                else:
                    start = start_index + 1
                    selected_patterns = arg_strings_pattern[start:]
                    arg_count = match_argument(action, selected_patterns)
                    stop = start + arg_count
                    args = arg_strings[start:stop]
                    action_tuples.append((action, args, option_string))
                    break

            
            
            assert action_tuples
            for action, args, option_string in action_tuples:
                take_action(action, args, option_string)
            return stop

        
        
        positionals = self._get_positional_actions()

        
        def consume_positionals(start_index):
            
            match_partial = self._match_arguments_partial
            selected_pattern = arg_strings_pattern[start_index:]
            arg_counts = match_partial(positionals, selected_pattern)

            
            
            for action, arg_count in zip(positionals, arg_counts):
                args = arg_strings[start_index: start_index + arg_count]
                start_index += arg_count
                take_action(action, args)

            
            
            positionals[:] = positionals[len(arg_counts):]
            return start_index

        
        
        extras = []
        start_index = 0
        if option_string_indices:
            max_option_string_index = max(option_string_indices)
        else:
            max_option_string_index = -1
        while start_index <= max_option_string_index:

            
            next_option_string_index = min([
                index
                for index in option_string_indices
                if index >= start_index])
            if start_index != next_option_string_index:
                positionals_end_index = consume_positionals(start_index)

                
                
                if positionals_end_index > start_index:
                    start_index = positionals_end_index
                    continue
                else:
                    start_index = positionals_end_index

            
            
            if start_index not in option_string_indices:
                strings = arg_strings[start_index:next_option_string_index]
                extras.extend(strings)
                start_index = next_option_string_index

            
            start_index = consume_optional(start_index)

        
        stop_index = consume_positionals(start_index)

        
        extras.extend(arg_strings[stop_index:])

        
        
        required_actions = []
        for action in self._actions:
            if action not in seen_actions:
                if action.required:
                    required_actions.append(_get_action_name(action))
                else:
                    
                    
                    
                    
                    if (action.default is not None and
                        isinstance(action.default, str) and
                        hasattr(namespace, action.dest) and
                        action.default is getattr(namespace, action.dest)):
                        setattr(namespace, action.dest,
                                self._get_value(action, action.default))

        if required_actions:
            self.error(_('the following arguments are required: %s') %
                       ', '.join(required_actions))

        
        for group in self._mutually_exclusive_groups:
            if group.required:
                for action in group._group_actions:
                    if action in seen_non_default_actions:
                        break

                
                else:
                    names = [_get_action_name(action)
                             for action in group._group_actions
                             if action.help is not SUPPRESS]
                    msg = _('one of the arguments %s is required')
                    self.error(msg % ' '.join(names))

        
        return namespace, extras

    def _read_args_from_files(self, arg_strings):
        
        new_arg_strings = []
        for arg_string in arg_strings:

            
            if not arg_string or arg_string[0] not in self.fromfile_prefix_chars:
                new_arg_strings.append(arg_string)

            
            else:
                try:
                    with open(arg_string[1:],
                              encoding=_sys.getfilesystemencoding(),
                              errors=_sys.getfilesystemencodeerrors()) as args_file:
                        arg_strings = []
                        for arg_line in args_file.read().splitlines():
                            for arg in self.convert_arg_line_to_args(arg_line):
                                arg_strings.append(arg)
                        arg_strings = self._read_args_from_files(arg_strings)
                        new_arg_strings.extend(arg_strings)
                except OSError as err:
                    self.error(str(err))

        
        return new_arg_strings

    def convert_arg_line_to_args(self, arg_line):
        return [arg_line]

    def _match_argument(self, action, arg_strings_pattern):
        
        nargs_pattern = self._get_nargs_pattern(action)
        match = _re.match(nargs_pattern, arg_strings_pattern)

        
        if match is None:
            nargs_errors = {
                None: _('expected one argument'),
                OPTIONAL: _('expected at most one argument'),
                ONE_OR_MORE: _('expected at least one argument'),
            }
            msg = nargs_errors.get(action.nargs)
            if msg is None:
                msg = ngettext('expected %s argument',
                               'expected %s arguments',
                               action.nargs) % action.nargs
            raise ArgumentError(action, msg)

        
        return len(match.group(1))

    def _match_arguments_partial(self, actions, arg_strings_pattern):
        
        
        result = []
        for i in range(len(actions), 0, -1):
            actions_slice = actions[:i]
            pattern = ''.join([self._get_nargs_pattern(action)
                               for action in actions_slice])
            match = _re.match(pattern, arg_strings_pattern)
            if match is not None:
                result.extend([len(string) for string in match.groups()])
                break

        
        return result

    def _parse_optional(self, arg_string):
        
        if not arg_string:
            return None

        
        if not arg_string[0] in self.prefix_chars:
            return None

        
        if arg_string in self._option_string_actions:
            action = self._option_string_actions[arg_string]
            return action, arg_string, None

        
        if len(arg_string) == 1:
            return None

        
        if '=' in arg_string:
            option_string, explicit_arg = arg_string.split('=', 1)
            if option_string in self._option_string_actions:
                action = self._option_string_actions[option_string]
                return action, option_string, explicit_arg

        
        
        option_tuples = self._get_option_tuples(arg_string)

        
        if len(option_tuples) > 1:
            options = ', '.join([option_string
                for action, option_string, explicit_arg in option_tuples])
            args = {'option': arg_string, 'matches': options}
            msg = _('ambiguous option: %(option)s could match %(matches)s')
            self.error(msg % args)

        
        
        elif len(option_tuples) == 1:
            option_tuple, = option_tuples
            return option_tuple

        
        
        
        if self._negative_number_matcher.match(arg_string):
            if not self._has_negative_number_optionals:
                return None

        
        if ' ' in arg_string:
            return None

        
        
        return None, arg_string, None

    def _get_option_tuples(self, option_string):
        result = []

        
        
        chars = self.prefix_chars
        if option_string[0] in chars and option_string[1] in chars:
            if self.allow_abbrev:
                if '=' in option_string:
                    option_prefix, explicit_arg = option_string.split('=', 1)
                else:
                    option_prefix = option_string
                    explicit_arg = None
                for option_string in self._option_string_actions:
                    if option_string.startswith(option_prefix):
                        action = self._option_string_actions[option_string]
                        tup = action, option_string, explicit_arg
                        result.append(tup)

        
        
        
        elif option_string[0] in chars and option_string[1] not in chars:
            option_prefix = option_string
            explicit_arg = None
            short_option_prefix = option_string[:2]
            short_explicit_arg = option_string[2:]

            for option_string in self._option_string_actions:
                if option_string == short_option_prefix:
                    action = self._option_string_actions[option_string]
                    tup = action, option_string, short_explicit_arg
                    result.append(tup)
                elif option_string.startswith(option_prefix):
                    action = self._option_string_actions[option_string]
                    tup = action, option_string, explicit_arg
                    result.append(tup)

        
        else:
            self.error(_('unexpected option string: %s') % option_string)

        
        return result

    def _get_nargs_pattern(self, action):
        
        
        nargs = action.nargs

        
        if nargs is None:
            nargs_pattern = '(-*A-*)'

        
        elif nargs == OPTIONAL:
            nargs_pattern = '(-*A?-*)'

        
        elif nargs == ZERO_OR_MORE:
            nargs_pattern = '(-*[A-]*)'

        
        elif nargs == ONE_OR_MORE:
            nargs_pattern = '(-*A[A-]*)'

        
        elif nargs == REMAINDER:
            nargs_pattern = '([-AO]*)'

        
        elif nargs == PARSER:
            nargs_pattern = '(-*A[-AO]*)'

        
        elif nargs == SUPPRESS:
            nargs_pattern = '(-*-*)'

        
        else:
            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)

        
        if action.option_strings:
            nargs_pattern = nargs_pattern.replace('-*', '')
            nargs_pattern = nargs_pattern.replace('-', '')

        
        return nargs_pattern

    
    
    

    def parse_intermixed_args(self, args=None, namespace=None):
        args, argv = self.parse_known_intermixed_args(args, namespace)
        if argv:
            msg = _('unrecognized arguments: %s')
            self.error(msg % ' '.join(argv))
        return args

    def parse_known_intermixed_args(self, args=None, namespace=None):
        
        
        
        
        
        
        
        
        
        
        

        positionals = self._get_positional_actions()
        a = [action for action in positionals
             if action.nargs in [PARSER, REMAINDER]]
        if a:
            raise TypeError('parse_intermixed_args: positional arg'
                            ' with nargs=%s'%a[0].nargs)

        if [action.dest for group in self._mutually_exclusive_groups
            for action in group._group_actions if action in positionals]:
            raise TypeError('parse_intermixed_args: positional in'
                            ' mutuallyExclusiveGroup')

        try:
            save_usage = self.usage
            try:
                if self.usage is None:
                    
                    self.usage = self.format_usage()[7:]
                for action in positionals:
                    
                    action.save_nargs = action.nargs
                    
                    action.nargs = SUPPRESS
                    action.save_default = action.default
                    action.default = SUPPRESS
                namespace, remaining_args = self.parse_known_args(args,
                                                                  namespace)
                for action in positionals:
                    
                    if (hasattr(namespace, action.dest)
                            and getattr(namespace, action.dest)==[]):
                        from warnings import warn
                        warn('Do not expect %s in %s' % (action.dest, namespace))
                        delattr(namespace, action.dest)
            finally:
                
                for action in positionals:
                    action.nargs = action.save_nargs
                    action.default = action.save_default
            optionals = self._get_optional_actions()
            try:
                
                
                for action in optionals:
                    action.save_required = action.required
                    action.required = False
                for group in self._mutually_exclusive_groups:
                    group.save_required = group.required
                    group.required = False
                namespace, extras = self.parse_known_args(remaining_args,
                                                          namespace)
            finally:
                
                for action in optionals:
                    action.required = action.save_required
                for group in self._mutually_exclusive_groups:
                    group.required = group.save_required
        finally:
            self.usage = save_usage
        return namespace, extras

    
    
    
    def _get_values(self, action, arg_strings):
        
        if action.nargs not in [PARSER, REMAINDER]:
            try:
                arg_strings.remove('--')
            except ValueError:
                pass

        
        if not arg_strings and action.nargs == OPTIONAL:
            if action.option_strings:
                value = action.const
            else:
                value = action.default
            if isinstance(value, str):
                value = self._get_value(action, value)
                self._check_value(action, value)

        
        
        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
              not action.option_strings):
            if action.default is not None:
                value = action.default
                self._check_value(action, value)
            else:
                
                
                value = arg_strings

        
        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
            arg_string, = arg_strings
            value = self._get_value(action, arg_string)
            self._check_value(action, value)

        
        elif action.nargs == REMAINDER:
            value = [self._get_value(action, v) for v in arg_strings]

        
        elif action.nargs == PARSER:
            value = [self._get_value(action, v) for v in arg_strings]
            self._check_value(action, value[0])

        
        elif action.nargs == SUPPRESS:
            value = SUPPRESS

        
        else:
            value = [self._get_value(action, v) for v in arg_strings]
            for v in value:
                self._check_value(action, v)

        
        return value

    def _get_value(self, action, arg_string):
        type_func = self._registry_get('type', action.type, action.type)
        if not callable(type_func):
            msg = _('%r is not callable')
            raise ArgumentError(action, msg % type_func)

        
        try:
            result = type_func(arg_string)

        
        except ArgumentTypeError as err:
            msg = str(err)
            raise ArgumentError(action, msg)

        
        except (TypeError, ValueError):
            name = getattr(action.type, '__name__', repr(action.type))
            args = {'type': name, 'value': arg_string}
            msg = _('invalid %(type)s value: %(value)r')
            raise ArgumentError(action, msg % args)

        
        return result

    def _check_value(self, action, value):
        
        if action.choices is not None and value not in action.choices:
            args = {'value': value,
                    'choices': ', '.join(map(repr, action.choices))}
            msg = _('invalid choice: %(value)r (choose from %(choices)s)')
            raise ArgumentError(action, msg % args)

    
    
    
    def format_usage(self):
        formatter = self._get_formatter()
        formatter.add_usage(self.usage, self._actions,
                            self._mutually_exclusive_groups)
        return formatter.format_help()

    def format_help(self):
        formatter = self._get_formatter()

        
        formatter.add_usage(self.usage, self._actions,
                            self._mutually_exclusive_groups)

        
        formatter.add_text(self.description)

        
        for action_group in self._action_groups:
            formatter.start_section(action_group.title)
            formatter.add_text(action_group.description)
            formatter.add_arguments(action_group._group_actions)
            formatter.end_section()

        
        formatter.add_text(self.epilog)

        
        return formatter.format_help()

    def _get_formatter(self):
        return self.formatter_class(prog=self.prog)

    
    
    
    def print_usage(self, file=None):
        if file is None:
            file = _sys.stdout
        self._print_message(self.format_usage(), file)

    def print_help(self, file=None):
        if file is None:
            file = _sys.stdout
        self._print_message(self.format_help(), file)

    def _print_message(self, message, file=None):
        if message:
            file = file or _sys.stderr
            try:
                file.write(message)
            except (AttributeError, OSError):
                pass

    
    
    
    def exit(self, status=0, message=None):
        if message:
            self._print_message(message, _sys.stderr)
        _sys.exit(status)

    def error(self, message):
        
        self.print_usage(_sys.stderr)
        args = {'prog': self.prog, 'message': message}
        self.exit(2, _('%(prog)s: error: %(message)s\n') % args)