|hfdZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd l mZdd l mZdd lmZd#d ZdZdZGddeZGddeZdZd$dZdZd%dZdZ d&dZ!dZ" d'dZ#dZ$dZ%dZ&dZ'd Z(d!Z)d"Z*y)(aPython Fire is a library for creating CLIs from absolutely any Python object. You can call Fire on any Python object: functions, classes, modules, objects, dictionaries, lists, tuples, etc. They all work! Python Fire turns any Python object into a command line interface. Simply call the Fire function as your main method to create a CLI. When using Fire to build a CLI, your main method includes a call to Fire. Eg: def main(argv): fire.Fire(Component) A Fire CLI command is run by consuming the arguments in the command in order to access a member of current component, call the current component (if it's a function), or instantiate the current component (if it's a class). The target component begins as Component, and at each operation the component becomes the result of the preceding operation. For example "command fn arg1 arg2" might access the "fn" property of the initial target component, and then call that function with arguments 'arg1' and 'arg2'. Additional examples are available in the examples directory. Fire Flags, common to all Fire CLIs, must go after a separating "--". For example, to get help for a command you might run: `command -- --help`. The available flags for all Fire CLIs are: -v --verbose: Include private members in help and usage information. -h --help: Provide help and usage information for the command. -i --interactive: Drop into a Python REPL after running the command. --completion: Write the Bash completion script for the tool to stdout. --completion fish: Write the Fish completion script for the tool to stdout. --separator SEPARATOR: Use SEPARATOR in place of the default separator, '-'. --trace: Get the Fire Trace for the command. N) completion) decorators) formatting)helptext) inspectutils)interact)parser)trace) value_types) console_ioc|xs0tjjtjd}t |t rtj|}n:t |ttfr|}n!|tjdd}n tdtj|\}}tj}|j|\}}i} |j s|Vt#j$d} | d} | j&} | j(} | j+| | j+| t-|||| |}|j/rt1|t3d||j4r}|j6rqd|dg}|j9}t;j<|||j>}|jA|tC|tjD t3d||j4r-d|g}tC|tjD t3d||j6r\|j9}t;j<|||j>}|g}tC|tjD t3d|tG||j>| |j9}|S) aThis function, Fire, is the main entrypoint for Python Fire. Executes a command either from the `command` argument or from sys.argv by recursively traversing the target object `component`'s members consuming arguments, evaluating functions, and instantiating classes as it goes. When building a CLI with Fire, your main method should call this function. Args: component: The initial target component. command: Optional. If supplied, this is the command executed. If not supplied, then the command is taken from sys.argv instead. This can be a string or a list of strings; a list of strings is preferred. name: Optional. The name of the command as entered at the command line. Used in interactive mode and for generating the completion script. serialize: Optional. If supplied, all objects are serialized to text via the provided callable. Returns: The result of executing the Fire command. Execution begins with the initial target component. The component is updated by using the command arguments to either access a member of the current component, call the current component (if it's a function), or instantiate the current component (if it's a class). When all arguments are consumed and there's no function left to call or class left to instantiate, the resulting current component is the final result. Raises: ValueError: If the command argument is supplied, but not a string or a sequence of arguments. FireExit: When Fire encounters a FireError, Fire will raise a FireExit with code 2. When used with the help or trace flags, Fire will raise a FireExit with code 0 if successful. rNzAThe command argument must be a string or a sequence of arguments.z Fire trace:  r verboseout)r serialize)$ospathbasenamesysargv isinstancestrshlexsplitlisttuple ValueErrorr SeparateFlagArgs CreateParserparse_known_args interactiveinspectstack f_globalsf_localsupdate_FireHasError _DisplayErrorFireExit show_trace show_help GetResultrHelpTextrappendDisplaystderr _PrintResult) componentcommandnamerargs flag_args argparserparsed_flag_args unused_argscontextcaller caller_framecaller_globals caller_localscomponent_traceoutputresult help_texts H/var/www/html/test/engine/venv/lib/python3.12/site-packages/fire/core.pyFirerIIsmB  .!!#((1+.$ ;;w D'D%=) D 88AB" NN=!)T+;WdK//" 1o &&O$=$=o.b1 2F  & & (F!!o/F/FHI MM) F # 1o &&o./ 0F F # 1o &&  & & (F!!o/F/FHI[F F # 1o &&66)M  $ $ && -cZdj|dz}tj||y)Nrr)joinr More)linesrtexts rHr4r4s# 5 D $ //$C rJc2tj|||S)z9Returns the text of the completion script for a Fire CLI.shell)rScript)r9r7rRs rHCompletionScriptrTs   4% 88rJceZdZdZy) FireErrorzException used by Fire when a Fire command cannot be executed. These exceptions are not raised by the Fire function, but rather are caught and added to the FireTrace. N)__name__ __module__ __qualname____doc__rJrHrVrVsrJrVc"eZdZdZfdZxZS)r.akAn exception raised by Fire to the client in the case of a FireError. The trace of the Fire program is available on the `trace` property. This exception inherits from SystemExit, so clients may explicitly catch it with `except SystemExit` or `except FireExit`. If not caught, this exception will cause the client program to exit without a stacktrace. c2t||||_y)zConstructs a FireExit exception. Args: code: (int) Exit code for the Fire CLI. component_trace: (FireTrace) The trace for the Fire command. N)super__init__r )selfcoderD __class__s rHr_zFireExit.__init__s GT DJrJ)rWrXrYrZr_ __classcell__)rbs@rHr.r.s!!rJr.cd}|r|d}|dvr|j}tj|stj|r*t j |}t ||\}}}||v}n"ttj|}||v}|rLd|_ |jd} tdtj| dtj|S) aYDetermines if the user is trying to access help without '--' separator. For example, mycmd.py --help instead of mycmd.py -- --help. Args: component_trace: (FireTrace) The trace for the Fire command. remaining_args: List of remaining args that haven't been consumed yet. Returns: True if help is requested, False otherwise. Frz-hz--helpT -- --help$INFO: Showing help with the command . file)r1r&isclass isroutinerGetFullArgSpec_ParseKeywordArgsdict getmembersr0 GetCommandprintrquoterr5) rDremaining_argsr0targetr7fn_spec_remaining_kwargsmembersr8s rH_IsHelpShortcutrzs) A F !!!++-i  #w'8'8'C--i8!2>7!K Q.. w)))45')  $O ++-.j9G 0W1E0Fc Jzz rJc|j}|rt|s td|||}tj|rt t |yt|ttttjfr|D]}t t|ytj|rt t|t"r+tj$|rt t'||yt|t(rt t|yt|tj*r| t |yyt-j.|||}|g}t1|t2j4y)zEPrints the result of the Fire call to stdout in a human readable way.z3The argument `serialize` must be empty or callable:Nrr)r1callablerVr HasCustomStrrrrrrset frozensettypes GeneratorType_OneLineResultr&isgeneratorfunctionNotImplementedErrorro IsSimpleGroup _DictAsStringr VALUE_TYPESrr2r4rstdout)rDrrrFirGrEs rHr6r6s2  $ $ && I   ? LL v Ff% #f+ sIu/B/BCD  N1 ""6* &$K$=$=f$E - ()&%  . !&+112  Fm!!ow8I[F F #rJc|j}g}d}dD] }||jdjvsd}"|r|jd}t dt j |dtjtj|||j }|j|t|tj y t tjd |jdj!ztjtj"|||j }t |tjy ) z.Prints the Fire trace and the error to stdout.FreTrfrgrhrirrzERROR: N)r1elementsr:rqrrrrsrr5rr2rr3r4rError ErrorAsStr UsageText)rDrFrEr0 help_flagr8rG error_texts rHr-r-s%  $ $ && &)#iO,,R0555i ++-.j9G 0W1E0Fc Jzz!!&*9*A*ACI MM) F # *  9 %  $ $R ( 3 3 5 6zz##F/,;,C,CEJ *3::&rJc tj|}|jDcic]"\}}tj|||||r||$}}}|syt d|j D}d|dzd}g}|jD]P\}}tj|||||s!|j|dt|} |j| Rd j|Scc}}w) zReturns a dict as a string. Args: result: The dict to convert to a string verbose: Whether to include 'hidden' members, those keys starting with _. Returns: A string representing the dict ) class_attrsrz{}c3DK|]}tt|ywN)lenr).0keys rH z _DictAsString..HsCcCCMCs z{key:rz s} {value}:)rvaluer) rGetClassAttrsDictitemsr MemberVisiblemaxkeysformatrr3rL) rFrrrrresult_visible longest_key format_stringrNlines rHrr1s..v6+#)<<>S%  ! !&#u.97 L 5j.  C^-@-@-BCC+;?+=9- %LLNjc5U (/1  ! !Qi~e7L ! Md ll4  5 %s'C5c|t|trt|jddStj|rd|j dStj |rd|j dS tj|dS#ttf$rt|jddcYSwxYw)z2Returns result serialized to a single line string.r z z  ^'88 {~ 1 c7Ce$  '+++ useXv 7 v.a f  " "9 -"**," > !"6*  >>#s #~ 5"6>>#s#;<   " JC s3x IG    '+++ vx6 ;,f5 56 ~7"3= ~4'0 =.'66yA&++ v}h @ )7$7    %"! >  ',Q/e\ul3  '9+5 B OON +  0#$$& N *#z1$N"~'E  B0.A   | K LL d$5_ MF''/ I )io.Ik#Ih(Ig"i NN9g&&&( a7 5667* %7 ;SB 567~7 56677 5667s[#P! Q AR$R*! Q*QQ .Q=<Q= R' R""R'* S3S  Sct|}|d}||jddg}|D]}||vst|||g|ddfcStd|)atReturns a subcomponent of component by consuming an arg from args. Given a starting component and args, this function gets a member from that component, consuming one arg in the process. Args: component: The component from which to get a member. args: Args from which to consume in the search for the next component. Returns: component: The component that was found by consuming an arg. consumed_args: The args that were consumed by getting this member. remaining_args: The remaining args that haven't been consumed yet. Raises: FireError: If we cannot consume an argument to get a member. rrrwrNzCould not consume arg:)dirrgetattrrV)r7r:ryr arg_namesarg_names rHrrnss  N' Q#  kk#s) ;h7 Y )C5$qr( ::; *C00rJc |s|}tj|\}}tj|}|dk(r |jn|}t ||} | |\\} } } } }tj |r,tj}|j|| i| }n|| i| }|dk(rtj}n&|dk(rtj}ntj}|j||| |||||| fS)aCall the component by consuming args from args, and update the FireTrace. The component could be a class, a routine, or a callable object. This function calls the component and adds the appropriate action to component_trace. Args: component: The component to call args: Args for calling the component component_trace: FireTrace object that contains action trace treatment: Type of treatment used. Indicating whether we treat the component as a class, a routine, or a callable. target: Target in FireTrace element, default is None. If the value is None, the component itself will be used as target. Returns: component: The object that is the result of the callable call. remaining_args: The remaining args that haven't been consumed yet. r|rr)action)rrr GetMetadata__call__ _MakeParseFnIsCoroutineFunctionasyncioget_event_looprun_until_completer INSTANTIATED_CLASSCALLED_ROUTINECALLED_CALLABLEAddCalledComponent)r7r:rDrrurrmetadatafnparsevarargskwargsrrtcapacitylooprs rHrrs&  F!00;(F  # #I .(&*4y)" r8 $%?DT{<7F]NH%%b)  ! ! #D''G(>v(>?IG&v&I'  % %FI  ! !F  " "F$$&( % N ""rJctj|tjtjz t j t jz fd}|S)aCreates a parse function for fn. Args: fn: The function or class to create the parse function for. metadata: Additional metadata about the component the parse function is for. Returns: A parse function for fn. The parse function accepts a list of arguments and returns (varargs, kwargs), remaining_args. The original function fn can then be called with fn(*varargs, **kwargs). The remaining_args are the leftover args from the arguments to the parse function. c0t| \}}}t j j|| \}}}} js j rd}t |t jz } j |r td|t t |z }|r td| j|g}}ng}t|D]\} } t| dd || <||z}||z }|dt|t|z } ||f| ||fS)zAParses the list of `args` into (varargs, kwargs), remaining_args.TNzUnexpected kwargs present:zMissing required flags:) rn _ParseArgsr:defaultsrvarkwr~ kwonlyargsrV enumerate _ParseValuer)r:rrxrt parsed_argsrextra_kwmissing_kwonlyrrrrrvrnum_required_argsrequired_kwonlys rH_ParseFnz_MakeParseFn.._ParseFns>/@w/O,F n5? g&&(965"1K'--h6{S!3!344H}} 2H ==)CK7N / @@" .~gg!'*@ u"5$h?gen@G#G&&N9#d)c.&99:M V m^X EErJ)rrmrr:rr~rkwonlydefaults)rrrrvrrs ` @@@rHrrsd  ' ' +'',,'#g.>.>*??**+c'2H2H.II/"FH /rJc|jtj}d}g}t|D]\} } |j | d} | t | | | |} |j | :|r3|r1|j d} t | | | |} |j | o| |kr td| d}| |z } |j || |jD]\} } t | d| ||| <||||fS)aParses the positional and named arguments from the available supplied args. Modifies kwargs, removing args as they are used. Args: fn_args: A list of argument names that the target function accepts, including positional and named arguments, but not the varargs or kwargs names. fn_defaults: A list of the default values in the function argspec. num_required_args: The number of required arguments from the function's argspec. This is the number of arguments without a default value. kwargs: Dict with named command line arguments and their values. remaining_args: The remaining command line arguments, which may still be used as positional arguments. metadata: Metadata about the function, typically from Fire decorators. Returns: parsed_args: A list of values to be used as positional arguments for calling the target function. kwargs: The input dict kwargs modified with the used kwargs removed. remaining_args: A list of the supplied args that have not been used yet. capacity: Whether the call could have taken args in place of defaults. Raises: FireError: If additional positional arguments are expected, but none are available. FNrz9The function received no value for the required argument:T) getrACCEPTS_POSITIONAL_ARGSrpoprr3rVr)fn_args fn_defaultsrrrtraccepts_positional_argsrrrrr default_indexrs rHrrs'6%LL)K)KL (+g&7jeS JJsD !E %X6e 3""1%E5#x85! $ $ GN N  11 ;}56'7*LLN:jc5eT39F3K: fnh 66rJci}g}g}|j}|j|jz}|s|||fSd}t|D]\}} |rd} t | rwd| v} | j d} | r| j dd\} } n| } d} | jdd} | xr$|dzt|k(xst ||dz}d}| |vs|r| jdr| d d|vs|r| }nYt| dk(rK|Dcgc] }|d | k(s |}}t|dk(r|d }nt|dkDrtd | d ||sd}nI| rd }nD|r%d }||vrd} n9|jdr|d d}d} n d} n|dzt|ksJ||dz} d }| xr| }|r| ||<a|j| |sv|j||dz|j| |||fScc}w)aParses the supplied arguments for keyword arguments. Given a list of arguments, finds occurrences of --name value, and uses 'name' as the keyword and 'value' as the value. Constructs and returns a dictionary of these keyword arguments, and returns a list of the remaining arguments. Only if fn_keywords is None, this only finds argument names used by the function, specified through fn_args. This returns the values of the args as strings. They are later processed by _ParseArgs, which converts them to the appropriate type. Args: args: A list of arguments. fn_spec: The inspectutils.FullArgSpec describing the given callable. Returns: kwargs: A dictionary mapping keywords to values. remaining_kwargs: A list of the unused kwargs from the original args. remaining_args: A list of the unused arguments from the original args. Raises: FireError: If a single-character flag is passed that could refer to multiple possible args. F=rrNrwnorrzThe argument 'zD' is ambiguous as it could refer to any of the following arguments: TTrueFalse) rr:rr_IsFlaglstriprrr startswithrVr3)r:rvrrxrt fn_keywordsr  skip_argumentrargumentcontains_equalsstripped_argumentrris_bool_syntaxkeywordrmatching_fn_args got_arguments rHrnrn0sz0 &. + LL7-- -' #^ 33-"4P&oeXmxxo"//#. &,,S!4 U KKS !c++Mc$i/K74 ?3Kg .!5#ab'W:L  s8q=+2DCc!fmCDD  A %$Q'' ! "Q &xj)::J9KM     g %    %ABK'%%qy3t9$$$UQY *)@..@m w)   ! !$uqy/ 2H%aP&d !> 11]Es ; G( G(c2t|xs t|S)a Determines if the argument is a flag argument. If it starts with a hyphen and isn't a negative number, it's a flag. Args: argument: A command line argument that may or may not be a flag. Returns: A boolean indicating whether the argument is a flag. )_IsSingleCharFlag_IsMultiCharFlagrs rHrrs 8 $ B(8(BBrJc^tjd|xstjd|S)z=Determines if the argument is a single char flag (e.g. '-a').z ^-[a-zA-Z]$z ^-[a-zA-Z]=)rematchr#s rHr!r!s# - * Obhh}h.OOrJcT|jdxstjd|S)zADetermines if the argument is a multi char flag (e.g. '--alpha').z--z ^-[a-zA-Z])rr%r&r#s rHr"r"s#   T " Fbhh|X&FFrJctj}|jtj}|r<|d}|d}|d}|d|cxkrt |kr nn||}n||vr||}n||}||S)aParses value, a string, into the appropriate type. The function used to parse value is determined by the remaining arguments. Args: value: The string value to be parsed, typically a command line argument. index: The index of the value in the function's argspec. arg: The name of the argument the value is being parsed for. metadata: Metadata about the function, typically from Fire decorators. Returns: value, parsed into the appropriate type for calling a function. default positionalnamedr)r DefaultParseValuerrFIRE_PARSE_FNSr) rrrrparse_fn parse_fnsr)r*r+s rHrrs % %(ll:445) "G<(J g E Q%9#j/9E"h sh  h %rJ)NNNN)FN)Fr)rN)+rZrr&rrr%rrrfirerrrrrrr r r fire.consoler rIr4rT ExceptionrV SystemExitr.rzr6r-rrr+rrrrrnrr!r"rr[rJrHr4s#J #[|! 9  !z!*B$$N'6 F**BJ1<EL#,#^7t87vu2p CP G rJ