o i@sddlZddlZddlZddlZddlZddlmZmZmZm Z m Z ddl m Z ddl m Z ddlmZddlmZmZddlmZddlmZdd lmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEddlFmGZGddlHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRejSdkrn e eT ddlUZUWdn1swYerddlVmWZWddlXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_m`Z`dd lambZbed!ed"efd#Zced$Zdd%Zed&deBeeBd'efed"fdBfd(d)ZgGd*d+d+ehZid,d-Zjd.d/Zkd0d1ZldPd5d6Zmd7eneoefd4d3d'dfd8d9Zpd:eod'eofd;d<Zq =dQd2ed3d'eneod>ffd?d@ZrdRdAdBZsdCdeoBe=Bd'e=dBfdDdEZte%GdFd3d3Zud'evdBfdGdHZwGdIdJdJeoeZxed'exfdKdLZyedMexd'dfdNdOZzdS)SN)Callable CoroutineIterableIteratorSequence)suppress)copy)Enum) lru_cachepartial)chain)Path) ModuleType) TYPE_CHECKING AnnotatedAnyLiteralOptionalTypeVarUnioncastoverload)Factorydefinefield)resolve_annotated)AppStack)ArgumentCollection)create_bound_argumentsis_option_likenormalize_tokens) CommandSpec)Env)CommandCollisionError CycloptsErrorUnknownCommandErrorUnknownOptionErrorUnusedCliTokensErrorValidationError)Group sort_groups)groups_from_app) CycloptsPanel) Parametervalidate_command) Dispatcher)Token)UNSET!create_error_console_from_consoledefault_name_transformhelp_formatter_converteroptional_to_tuple_convertersort_key_converterto_list_converterto_tuple_converter) Console) DocFormat) HelpPanel) HelpFormatter) ResultActionResultActionSingle)_run_maybe_async_commandT.)boundVmarkdownvaluereturncCs$|durdSt|}|std|S)zConvert result_action value, ensuring non-empty sequences. Intended to be used in an ``attrs.Field`` for result_action. Raises ValueError if an empty iterable is provided. Nz)result_action cannot be an empty sequence)r8 ValueError)rGresultrKS/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/cyclopts/core.py_result_action_converterUs rMc@s eZdZdS)#_CannotDeriveCallingModuleNameErrorN)__name__ __module__ __qualname__rKrKrKrLrNfsrNcCsHtD]}t|j}|durq|jdd}|dkrq|St)z1Get the calling package name from the call-stack.N.rcyclopts)inspectstack getmoduleframerOsplitrN)elemmoduleroot_module_namerKrKrL_get_root_module_namejs  r\cCst|tr td|S)N%Cannot register a sub-App to default.) isinstanceApp TypeErrorxrKrKrL_validate_default_commandxs rccCs"t|jrt|jr|jS|jSN)callableversionrTiscoroutinefunction_version_print_async version_print)apprKrKrL_get_version_command~srkrjr_ parent_appcCsj|jdur t|j|_|jdurt|j|_|jdur!t|j|_|jdur1|jdur3|j|_dSdSdS)zApply parent app's group defaults to app if not already set. Parameters ---------- app : App The app to apply defaults to. parent_app : App The parent app to inherit defaults from. N)_group_commandsr_group_parameters_group_argumentsrf)rjrlrKrKrL_apply_parent_defaults_to_apps      rpkwargscCsJd|vr t|j|d<d|vrt|j|d<d|vr#t|j|d<dSdS)zApply parent app's groups to kwargs dict if not already specified. Parameters ---------- kwargs : dict Keyword arguments dict to modify. parent_app : App The parent app to inherit groups from. group_commandsgroup_parametersgroup_argumentsN)rrmrnro)rqrlrKrKrL_apply_parent_groups_to_kwargss ruscCs|ddddS)amNormalize a string for fuzzy command matching. Removes hyphens, underscores, and converts to lowercase (e.g., 'mycommand' matches 'my-command'). .. warning:: This fuzzy matching is primarily for backward compatibility with the introduction of ``_pascal_to_snake`` in ``default_name_transform``. It should **probably be removed in v5** once users have migrated their camelCase command names. Parameters ---------- s : str String to normalize. Returns ------- str Normalized string with hyphens/underscores removed and lowercased. -_)replacelower)rvrKrKrL_normalize_for_matchingsr|TApp | CommandSpeccCs|duriSt|j}|jD]}|D] }||vr||||<qq|r/|jr/|t|jdd|r@|jr@t|jdd}|||S)afReturn a mapping of command names to Apps or CommandSpecs. CommandSpec instances are NOT resolved here - they are resolved lazily only when the command is actually executed, enabling true lazy loading. Parameters ---------- app : App | None The app to get commands from. recurse_meta : bool If True, include commands from the app's meta. recurse_parent_meta : bool If True, include commands from parent meta apps. Returns ------- dict[str, App | CommandSpec] Mapping of command names to :class:`App` or :class:`CommandSpec` instances. NFrecurse_parent_meta recurse_meta)dict _commands_flattened_subapps_metaupdate_combined_meta_command_mapping _meta_parent)rjrrcommand_mappingsubappcmd_namemeta_parent_commandsrKrKrLrs      rccsH|g}|}|j}r|jr|||j}r|jst|EdHdS)z{Typically the result looks like [app] or [meta_app, app]. Iterates from deepest to shallowest meta-app (and app). N)rdefault_commandappendreversed)rj meta_listmetarKrKrL _walk_metass r input_valuecCs0|durdSt|trt|St|tr|Strd)r^strr)r`)rrKrKrL_group_converters  rc@s eZdZUeddedZdeBeedfBed<edddZ edBed<edd Z edBed <ede d d Z deBeedfBed <ede d d ZedefdBed<edd dZedBed<edded dZdeedeedfegefBeeedeedfegefBed<edd dZdeBedefBedeeeeffBed<edge dd dZeeeBed<ed d dZeed<edd ddZeded<edd ddZeded<ed d!ge d"d dZeeeBed#<edd dZ e!d$dBed%<edd dZ"edBed&<edd dZ#edBed'<edd dZ$e!d$dBed(<ede d d Z%e&eBee&eBdfBed)<ed*de'd d+Z(e&eBdBed,<ed-de'd d+Z)e&eBdBed.<ed/de'd d+Z*e&eBdBed0<ede+d d Z,eedefed1<edd2d d3Z-eegefdBed4<edd5e.d dZ/eed6<edd dZ0edBed7<edd dZ1edBed8<edd dZ2edBed9<edd dZ3edBed:<ed d dZ4eed;<edd dZ5e!d<dBed=<ede6d d Z7e8de!d>d?fed@<ede9d d Z:e;ee=edDfedE<edBedCZ?ededF<edBddGZ@ededH<edBddGZAededI<edBddBdJZBedBedK< edBeCdBdJZDeEdBeFeCBedL< edBddGZGededM<edBddGZHededN<edBeIeJd dOdGZKeJedP<dQdRZLdSeefdTdUZMeNdVdWZOeOjPdXdWZOeNdYdZZQeQjPd[dZZQeNd\eedffd]d^ZReNd_d`ZSeSjPdad`ZSeNdbdcZTeTjPdddcZTeNdedfZUeUjPdgdfZUeNdhdiZVeVjPdjdiZVeNd\efdkdlZWeWjPdmdlZWeNdndoZXeXjPdpdoZXeNdqdrZYeYjPdsdrZYeNd\e=edffdtduZZeNddvdwZ[e[jPdedfdxdwZ[eNddydzZ\e\jPdedfd{dzZ\eNd\eEdBfd|d}Z]dded\efddZ^dededd\dfddZ_ dde`ededBdfd\dfddZa dde`ededBdfd\dfddZbeNddZcd\e=edffddZdded\dfddZeddddZfdefddZgded\efddZhd\eiefddZjeNdddZk dd dddeBeeBd\eeedfedeeffddZldemdd\edfddZndeddeed\eefddZoep ddddeqddeBeeBd deBeeBderd\eqf ddZsep  dddddddeBeeBd deBeeBderd\eeqgeqff ddZsep ddddeddeBeeBd deBeeBderd\df ddZs  ddddeqdBeBddeBeeBd deBeeBderd\eqeeqgeqfBdBf ddZsepdddeqd1edefdBd\eqfddZtep dddddd1edefdBd\eeqgeqffddZt ddddeqdBd1edefdBd\eqeeqgeqfBfddZtddBddedBded\efddZu dddddddeBeeBdeddedd7edBd\eedefevjweee=eefff ddZx ddBdddeBeeBded\eedefevjweee=eefeffddZy dddddddddddeBeeBdeddedd8edBd9edBd&edBd:edBd7edBd\eeevjwe=eefffddZzd\efddÄZ{ dddddddddddĜ ddeBeeBdeddedd8edBd9edBd&edBd:edBd7edBd=e!d<dBdAe;dBd\efddƄZ| dddddddddddĜ ddeBeeBdeddedd8edBd9edBd&edBd:edBd7edBd=e!d<dBdAe;dBd\efddȄZ} dddɜde`deBeeBedBdʍfde`ededBdfd\dfdd̄Z~ddeBeeBd\eeeddffddЄZ B Bddddedededed\ef ddڄZdddۜdedBde!ddBd\efddZddd dde!ddBdedBded\efddZ ddeeeBded\dfddZ    B ddeddeBeeBdedBddd9edAe;dBd\dfddZddede;d\efddZdddZddZdS(r_Nname)defaultalias converter._namehelp)rr_help)rusageT)rrkw_onlyrr)rrdefault_parameterconfig)rrrr_configrfz --version version_flags)rrrr_version_flagsshowconsole)rrrr<_console error_console_error_consolez--helpz-h help_flags _help_flags)rFmd plaintextrestructuredtextrstrich help_format help_on_error help_epilogueversion_formatgrouprt)rrrrrorsrnrrrm validatorname_transform)rrr_name_transformsort_key _sort_keyend_of_options_delimiter print_error exit_on_errorverbosesuppress_keyboard_interruptasynciotriobackend)rplainr?help_formatter result_actionF)initfactoryr}rr)rrrr)rrrepr_instantiating_module_name_instantiating_module_cache_fallback_console_fallback_error_console) takes_self app_stackc CsN|j|_|j|_ztd}|jd|_WdSt t fy&d|_YdSw)NrO) rrrrsys _getframe f_globalsgetr IndexErrorAttributeError)selfrWrKrKrL__attrs_post_init__s  zApp.__attrs_post_init__commandsc Cs*|D]}z||=WqtyYqwdS)zSafely delete commands. Will **not** raise an exception if command(s) do not exist. Parameters ---------- commands: Iterable[str, ...] Strings of commands to delete. N)KeyError)rrcommandrKrKrL_delete_commandss   zApp._delete_commandscC|jSrd)rrrKrKrLrzApp.version_flagscC<||j||_|jr|j|j|jgg|jdddSdS)NzDisplay application version.rrrrfr)rrrrirfrrGrKrKrLr  cCrrd)rrrKrKrLrrzApp.help_flagscCr)NzDisplay this message and exit.r)rrr help_printrfrrKrKrLrrrHcCs|jr |j|jS|jdur#ttjdj}|dkrt}|f|jSz|jj}Wnt y7|jj j}Ynw| |f|jS)z?Application name(s). Dynamically derived if not previously set.Nrz __main__.py) rrrr rargvrr\rOrfuncr)rr func_namerKrKrLrs     zApp.namecC|jdur tS|jSrd)ror)create_default_argumentsrrKrKrLrt  zApp.group_argumentscC ||_dSrd)rorrKrKrLrt cCrrd)rnr)create_default_parametersrrKrKrLrsrzApp.group_parameterscCrrd)rnrrKrKrLrsrcCrrd)rmr)create_default_commandsrrKrKrLrrrzApp.group_commandscCrrd)rmrrKrKrLrr%rcCs |jdS)Nr)rresolverrKrKrLr)s z App.configcCrrd)rrrKrKrLr-rcCs|jdur|jS|jdur|jdurdS|jjSdtjvr4ddlm}t |j|r/|jj j }n |jj }n|jj }|dur>dS|S)Nrx functoolsrr ) rrrrrrmodulesrr r^r__doc__)rr docrKrKrLr1s        zApp.helpcCrrd)rrrKrKrLrLrcCs|jr|jStSrd)rr3rrKrKrLrPszApp.name_transformcCrrd)rrrKrKrLrTrcCs|jturdS|jSrd)rr1rrKrKrLrXsz App.sort_keycCst||_dSrd)r6rrrKrKrLr\scCs4i}|D]}||jvs||jvrq||||<q|S)zpCommands that are not help or version commands. This includes commands from flattened subapps. )rr)routrbrKrKrL_registered_commands`s zApp._registered_commandscCs<|jd}|dur |S|jdurddlm}||_|jS)Nrrr;)rrr rich.consoler<)rrJr<rKrKrLrms   z App.consolecCrrd)rrrrKrKrLr}rcCs4|jd}|dur |S|jdurt|j|_|jS)Nr)rrrr2r)rrJrKrKrLrs   zApp.error_consolecCrrd)rrrKrKrLrrcCs8|jtur|jrtj|j|_nd|_ttdB|jS)z2Lazily resolve the module name to a module object.N)rr1rrrrrrrrKrKrL_instantiating_modules zApp._instantiating_module0.0.0rc Csddlm}ddlm}|jdur:|jj}|dd}z||WS|y*Ynwz|jjWSty9Ynwzt}Wn t yJ|YSwz||WS|yYYnwz t |}|jWSt tfyoY|Sw)aGet the version string with multiple fallback strategies. First tries to derive from the instantiating module, then tries to get it from the calling code's module, and finally falls back to a default. Parameters ---------- default : str Default version to use if no version can be determined. Returns ------- str Version string. r)PackageNotFoundError)rfNrR) importlib.metadatarrfrrOrX __version__rr\rN importlib import_module ImportError)rrrimportlib_metadata_versionfull_module_namer[rZrKrKrL_get_fallback_version_strings@            z App._get_fallback_version_string version_rawcCsRddlm}|jd}|dur|jjdtd}|j||d}|p#|j|dS)zFormat and print the version string. Parameters ---------- version_raw : str Raw version string to format and print. console : ~rich.console.Console Console to print to. r InlineTextrNrfallbackformat) cyclopts.helprrr_DEFAULT_FORMAT from_formatrprint)rrrrrversion_formattedrKrKrL_format_and_print_versions zApp._format_and_print_versionparsecCsX|jdur t|jrt|jrtdtt|}n|j}n|}|||dS)aPrint the application version. Parameters ---------- console: ~rich.console.Console Console to print version string to. If not provided, follows the resolution order defined in :attr:`App.console`. NzJasync version handler detected. Use App.run_async within an async context.) rfrerTrgrIrrrrrrrrKrKrLris  zApp.version_printcsb|jdur%t|jr!t|jr|IdH}ntt|}n|j}n|}|||dS)a&Async version of version_print for handling async version callables. Parameters ---------- console: ~rich.console.Console Console to print version string to. If not provided, follows the resolution order defined in :attr:`App.console`. N)rfrerTrgrrrrrrKrKrLrhs  zApp._version_print_asyncccs|D]}||VqdSrdrK)rkrKrKrLsubappss z App.subappscsFfddjD}jD]}|D] }||vr||||<qq|S)aGet all commands as resolved App instances. This function resolves any lazy-loaded commands (CommandSpec) into App instances. Note: This will import modules for all lazy-loaded commands, which may impact performance and memory usage. Consider accessing commands individually via ``app["command_name"]`` if you don't need all commands at once. Returns ------- dict[str, App] Mapping of command names to resolved :class:`App` instances. Examples -------- .. code-block:: python from cyclopts import App app = App() app.command("myapp.commands:create") app.command("myapp.commands:delete") # Resolve all lazy commands commands = app.resolved_commands() assert "create" in commands assert isinstance(commands["create"], App) cs*i|]\}}|t|tr|n|qSrK)r^r!r).0rcmdrrKrL 9sz)App.resolved_commands..)ritemsr)rresolvedrrrKrrLresolved_commandss   zApp.resolved_commandskeycCs"||}t|tr||S|S)aNGet the subapp from a command string. All commands get registered to Cyclopts as subapps. The actual function handler is at ``app[key].default_command``. If the command was registered via lazy loading (import path string), it will be imported and resolved on first access. Example usage: .. code-block:: python from cyclopts import App app = App() app.command(App(name="foo")) @app["foo"].command def bar(): print("Running bar.") app() ) _get_itemr^r!r)rrrrKrKrL __getitem__Es   zApp.__getitem__c Cs|r!|jr!tt|jj|ddWdS1swY|jr@tt|jj|ddWdS1s;wY||jvrJ|j|S|jD]}tt|j|ddWdS1sgwYqMt|)z;Internal getter that returns App or unresolved CommandSpec.TrNF)rrrrrrrr)rrrrrKrKrLres         &z App._get_itemcCs |j|=dSrd)r)rrrKrKrL __delitem__ys zApp.__delitem__rcCs@||jvrdS|jr||jvrdS|jD] }||vrdSqdS)NTF)rrr)rrrrKrKrL __contains__|s   zApp.__contains__ccszt|j}|EdHt|}|jr$|jD]}||vr#|V||q|jD]}|D]}||vr9|V||q+q'dS)aIterate over command & meta command names. Example usage: .. code-block:: python from cyclopts import App app = App() @app.command def foo(): pass @app.command def bar(): pass # help and version flags are treated as commands. assert list(app) == ["--help", "-h", "--version", "foo", "bar"] N)listrsetraddr)rrrrrKrKrL__iter__s$      z App.__iter__cCsJ|jdur"t||j|jt|jt|jt|j|jd|_||j_ |jS)N)rrrrrtrsr) rtyperrrrmrornrrrrKrKrLrs zApp.metainclude_parent_metatokens)r_.c sbt|}g}|}g|}fdd}|||t|d}|}|r|d}d} ||vr5||} n0t|fdd|D} t| dkrO|| d} nt| dkretd |d d t| d | dur}r|||} t| t|kr|| }q$n+t | t r|} | | }n| }|||t|d}|||dd}|s&t |t |fS) aExtract out the command tokens from a command. You are probably actually looking for :meth:`parse_args`. Parameters ---------- tokens: None | str | Iterable[str] Either a string, or a list of strings to launch a command. Defaults to ``sys.argv[1:]`` include_parent_meta: bool Controls whether parent meta apps are included in the execution path. When True (default): - Parent meta apps (i.e. the "normal" app ) are added to the apps list. - Meta app options are consumed while parsing commands. - Used for getting the inheritance hierarchy. When False: - Meta app options are treated as regular arguments. - Used for getting the execution hierarchy. This parameter is primarily for internal use. Returns ------- tuple[str, ...] Strings that are interpreted as a valid command chain. tuple[App, ...] The execution path - apps that will be invoked in order. list[str] The remaining non-command tokens. csNsdSg}|}|j}dur|||j}dus|ddddS)zIf ``app`` is a meta-app, also add it's "normal" app. We assume that ``app._meta`` will always invoke the ``app``. N)rrextend)rj meta_parents meta_parent)appsr&rKrLadd_parent_metass z,App.parse_commands..add_parent_metasr~rNcsg|] }t|kr|qSrK)r|)rr)normalized_tokenrKrL sz&App.parse_commands..zAmbiguous command 'z'. Could match: , rR) r rrr|lenrIjoinsorted_consume_leading_meta_optionsr^r!rtuple) rr'r& command_chainrj unused_tokensr-rtoken app_or_specmatches remainingrlrK)r,r&r.rLparse_commandssR&              4zApp.parse_commandsexecution_pathcCs~g}|r=|d}t|D] }||vr||q |jjr=|jjdD]}|jr<|j|vr<||jjv}|s<||jq"|S)aGet all apps that contribute to parameter resolution for the given execution path. This includes parent meta apps and the meta app of the final command app. Parameters ---------- execution_path : Sequence[App] The execution path returned from parse_commands. Returns ------- list[App] All apps that contribute configuration and parameters, ordered by priority. r()rrrrUrrvalues)rr>r,last_apprjis_meta_commandrKrKrL_get_resolution_context4s   zApp._get_resolution_contextr,c Cs|r|s|Sddlm}|||jjddd}Wdn1s$wYdd|D}|d jrC|d jjrC||d j|}|D]}z|}||||d d }WqGty`YqGw|S) aConsume meta app options from the beginning of the token stream. This is used to skip over meta app parameters when looking for commands. Limitation: positional parameters for the meta app are NOT skipped. This is because we do not know which meta-parameters are for the meta-app itself vs which it will pass along to the normal app. Parameters ---------- apps: list[App] Current app stack including parent meta apps. tokens: list[str] Tokens to try parsing, starting from current position. Returns ------- list[str] The remaining unused tokens after consuming any leading meta options. r)_parse_kw_and_flagsr--rNcSs g|] }|jdur|jr|qSrd)rr)rrjrKrKrLr/{s z5App._consume_leading_meta_options..r(T)rstop_at_first_unknown) cyclopts.bindrCrrrrrassemble_argument_collection Exception) rr,r'rCrmeta_apps_to_tryr8meta_appargument_collectionrKrKrLr5Ys.   z!App._consume_leading_meta_options)robjrqcKdSrdrKrrLrrrqrKrKrLrz App.commandcKrMrdrKrNrKrKrLrrOcKrMrdrKrNrKrKrLrrOc Ks0|durt|jf||d|S|dkr0t|tstd|r#tdt|||j||St|t r~|durH| d\}}}| |f}nt |}|durSd}nt |}t ||r_|dnd|d }||D]}||vrvtd |d ||j|<qhdSt|tr|} | jdur|durtd |rtd t| |n/|d|j|d|jd|vr|jdur|j|d<t||t|di|} | |t| j| jD]} d| | _q| jdur|j | _ |dur| j}nt |}|durd}nt |}||D]}||vrtd |d | |j|<q|S)aEDecorator to register a function as a CLI command. Example usage: .. code-block:: from cyclopts import App app = App() @app.command def foo(): print("foo!") @app.command(name="buzz") def bar(): print("bar!") # Lazy loading via import path app.command("myapp.commands:create_user", name="create") app() .. code-block:: console $ my-script foo foo! $ my-script buzz bar! $ my-script create # Imports and runs myapp.commands:create_user Parameters ---------- obj: Callable | App | str | None Function, :class:`App`, or import path string to be registered as a command. For lazy loading, provide a string in format "module.path:function_or_app_name". name: None | str | Iterable[str] Name(s) to register the command to. If not provided, defaults to: * If registering an :class:`App`, then the app's name. * If registering a **function**, then the function's name after applying :attr:`name_transform`. * If registering via **import path**, then the attribute name after applying :attr:`name_transform`. Special value ``"*"`` flattens all sub-App commands into this app (App instances only). See :ref:`Flattening SubCommands` for details. `**kwargs` Any argument that :class:`App` can take. N)rr*zYFlattening (name="*") is only supported for App instances, not functions or import paths.zLCannot supply additional configuration when flattening a sub-App (name="*").:rKr) import_pathr app_kwargsz Command "z" already registered.z#Sub-app MUST have a name specified.zDCannot supplied additional configuration when registering a sub-App.rrrfF)r rr^r_r`rIrprrr rpartitionrr8r!r#rr setdefaultrrrfrur$rr rrr) rrLrrrqryrspecnrjflagrKrKrLrsn<               rcCrMrdrKrrLrrKrKrLrXz App.defaultcCrMrdrKrZrKrKrLrer[cCs`|dur t|j|dSt|trtd|jdur"td|jdt|||_|r.||_|S)aDecorator to register a function as the default action handler. Example usage: .. code-block:: python from cyclopts import App app = App() @app.default def main(): print("Hello world!") app() .. code-block:: console $ my-script Hello world! NrYr]z"Default command previously set to rR) r rr^r_r`rr#r.rrZrKrKrLrms  )rparse_docstringr\cCs8|jdur tdtj|jt|jj||j|j |dS)aAssemble the argument collection for this app. Parameters ---------- default_parameter: Parameter | None Default parameter with highest priority. parse_docstring: bool Parse the docstring of :attr:`default_command`. Set to :obj:`True` if we need help strings, otherwise set to :obj:`False` for performance reasons. Returns ------- ArgumentCollection All arguments for this app. NzCannot assemble argument collection: no default command is registered. Use @app.default to register a default command, or access a specific subcommand's argument collection via app['command_name'].assemble_argument_collection().)rtrsr\) rrIr_from_callabler-combinerrrorn)rrr\rKrKrLrGs z App.assemble_argument_collection)rrrc CsZ|||d}|jg|d||\}}}} } Wdn1s"wY|||| fS)a&Interpret arguments into a registered function, :class:`~inspect.BoundArguments`, and any remaining unknown tokens. Parameters ---------- tokens: None | str | Iterable[str] Either a string, or a list of strings to launch a command. Defaults to ``sys.argv[1:]`` console: ~rich.console.Console Console to print help and runtime Cyclopts errors. If not provided, follows the resolution order defined in :attr:`App.console`. error_console: ~rich.console.Console Console to print error messages. If not provided, follows the resolution order defined in :attr:`App.error_console`. end_of_options_delimiter: str | None All tokens after this delimiter will be force-interpreted as positional arguments. If None, inherits from :attr:`App.end_of_options_delimiter`, eventually defaulting to POSIX-standard ``"--"``. Set to an empty string to disable. Returns ------- command: Callable Bare function to execute. bound: inspect.BoundArguments Bound arguments for ``command``. unused_tokens: list[str] Any remaining CLI tokens that didn't get parsed for ``command``. ignored: dict[str, Any] A mapping of python-variable-name to annotated type of any parameter with annotation ``parse=False``. :obj:`~typing.Annotated` will be resolved. Intended to simplify :ref:`meta apps `. )rrr overridesN)r_parse_known_args) rr'rrrr`rrDr8ignoredryrKrKrLparse_known_argss, zApp.parse_known_argsraise_on_unused_tokensrec sPdur ttt|}|jdd\}}}|jdd\}}|dtt8r\dt|dj|djvr\|dd}ddr\dt|dj|djvs>Wdn1sfwY|d~i}| |j dpd} t fdd | D} |j j d d d } t j| } zN| durtjjfd dDdd<fdd|D|dd<|j } |j}r|j } |j}st| jjd} g}t}ntfdd jDrt} |j}rt|} |j}st| jjd} g}t}njrj} t| }dd|jddD}tj||| | d\} }zjD] }|di| jq?Wn tttfyl}zt |j!rb|j!dndd|d}~wwzj j"D]}|jD] }|di| jqwqrWn;tttfy}zt |j!r|j!dnd|d|d}~ww|rt#|d|j } t| jjd} g}t}|r|r|D]}t$|r|%dd}t&t'|dd|dqt(| |d Wn%t)y}zj|_*|_+r|_,|jdur j-|_d}~wwWdn 1swY| | |||fS)!NTr%Fr(rrKc3s|] }t|VqdSrdrrrb) command_appr7rKrL sz(App._parse_known_args..rrDrcg|]}|vr|qSrKrKrtflags_to_removerKrLr/*z)App._parse_known_args..crjrKrKrkrmrKrLr/+rorc3s|]}|vVqdSrdrK)rrX)r'rKrLri3scSsi|] }|jjt|jjqSrK) field_inforr annotation)rargumentrKrKrLr@sz)App._parse_known_args..r)rrrx)exception_messagerj)rtr)r8)r'r=cli)keywordsource)r9rK)targetr8)._log_framework_warning_detect_test_frameworkr r=rrr!rrrrr6_get_help_flag_indexrrrT signaturebindrranyrkrr.rG filter_byrr argumentsAssertionErrorrIr`r(argscommand_groupsr%rrXr&r0r'r$ryrjr7r)rr'rer+ryapps_for_contextexecution_appsr8rbrrhelp_flag_indexrrDrKre command_groupr9rK)rhr7rnr'rLras                       _zApp._parse_known_args)rrrrrrrc Cs\|dur ttt|}dd|||||||dD} |jg| d|z|j|dd\} } } } } Wnety}zY|jd}|jd }|jd }|jd }|durZ|nd |_||_ |j dusgJ|durn|rwnn|j ||j d |dur~|rn |j t ||dur|rn tdd}~wwWdn1swY| | | fS)a Interpret arguments into a function and :class:`~inspect.BoundArguments`. Raises ------ UnusedCliTokensError If any tokens remain after parsing. Parameters ---------- tokens: None | str | Iterable[str] Either a string, or a list of strings to launch a command. Defaults to ``sys.argv[1:]``. console: ~rich.console.Console Console to print help and runtime Cyclopts errors. If not provided, follows the resolution order defined in :attr:`App.console`. error_console: ~rich.console.Console Console to print error messages. If not provided, follows the resolution order defined in :attr:`App.error_console`. print_error: bool | None Print a rich-formatted error on error. If :obj:`None`, inherits from :attr:`App.print_error`, eventually defaulting to :obj:`True`. exit_on_error: bool | None If there is an error parsing the CLI tokens invoke ``sys.exit(1)``. Otherwise, continue to raise the exception. If :obj:`None`, inherits from :attr:`App.exit_on_error`, eventually defaulting to :obj:`True`. help_on_error: bool | None Prints the help-page before printing an error. If :obj:`None`, inherits from :attr:`App.help_on_error`, eventually defaulting to :obj:`False`. verbose: bool | None Populate exception strings with more information intended for developers. If :obj:`None`, inherits from :attr:`App.verbose`, eventually defaulting to :obj:`False`. end_of_options_delimiter: str | None All tokens after this delimiter will be force-interpreted as positional arguments. If :obj:`None`, inherits from :attr:`App.end_of_options_delimiter`, eventually defaulting to POSIX-standard ``"--"``. Set to an empty string to disable. Returns ------- command: Callable Function associated with command action. bound: inspect.BoundArguments Parsed and converted ``args`` and ``kwargs`` to be used when calling ``command``. ignored: dict[str, Any] A mapping of python-variable-name to type-hint of any parameter with annotation ``parse=False``. :obj:`~typing.Annotated` will be resolved. Intended to simplify :ref:`meta apps `. NcSi|] \}}|dur||qSrdrKrrvrKrKrLrs   z"App.parse_args..)rrrrrrrr_TrdrrrrFrpr0)rzr{r rrrar$rrroot_input_tokensrrr r,rexit)rr'rrrrrrrr`rrDryrbrrKrKrL parse_argszsP=       zApp.parse_argscCs,t|jjdkp|jduot|jjjdkS)zHCheck if this is a nested call (meta app pattern or same-app recursion).r0N)r2roverrides_stackrrrKrKrL_is_nested_callszApp._is_nested_call) rrrrrrrrrc  Cs|dur ttt|}dd||||||| | dD} |r)| dd||| H|j|||d\} } }tt d|jj d d d }zt | | |}| |WWdSt yn|jrktd nYnwWddS1szwYdS) ax Interprets and executes a command. Parameters ---------- tokens : None | str | Iterable[str] Either a string, or a list of strings to launch a command. Defaults to ``sys.argv[1:]``. console: ~rich.console.Console Console to print help and runtime Cyclopts errors. If not provided, follows the resolution order defined in :attr:`App.console`. error_console: ~rich.console.Console Console to print error messages. If not provided, follows the resolution order defined in :attr:`App.error_console`. print_error: bool | None Print a rich-formatted error on error. If :obj:`None`, inherits from :attr:`App.print_error`, eventually defaulting to :obj:`True`. exit_on_error: bool | None If there is an error parsing the CLI tokens invoke ``sys.exit(1)``. Otherwise, continue to raise the exception. If :obj:`None`, inherits from :attr:`App.exit_on_error`, eventually defaulting to :obj:`True`. help_on_error: bool | None Prints the help-page before printing an error. If :obj:`None`, inherits from :attr:`App.help_on_error`, eventually defaulting to :obj:`False`. verbose: bool | None Populate exception strings with more information intended for developers. If :obj:`None`, inherits from :attr:`App.verbose`, eventually defaulting to :obj:`False`. end_of_options_delimiter: str | None All tokens after this delimiter will be force-interpreted as positional arguments. If :obj:`None`, inherits from :attr:`App.end_of_options_delimiter`, eventually defaulting to POSIX-standard ``"--"``. Set to an empty string to disable. backend: Literal["asyncio", "trio"] | None Override the async backend to use (if an async command is invoked). If :obj:`None`, inherits from :attr:`App.backend`, eventually defaulting to "asyncio". If passing backend="trio", ensure trio is installed via the extra: `cyclopts[trio]`. result_action: ResultAction | None Controls how command return values are handled. Can be a predefined literal string or a custom callable that takes the result and returns a processed value. If :obj:`None`, inherits from :attr:`App.result_action`, eventually defaulting to "print_non_int_return_int_as_exit_code". See :attr:`App.result_action` for available modes. Returns ------- return_value: Any The value the command function returns. NcSrrdrKrrKrKrLr+   z App.__call__..rrrrrrrrr return_valuerrrrrr)rzr{r rrrUrrrrrrB_handle_result_actionKeyboardInterruptrrr)rr'rrrrrrrrrr`rrDryresolved_backendrJrKrKrL__call__sH;        "z App.__call__c  s|dur ttt|}dd||||||| | dD} |r*| dd||| P|j|||d\} } }z(t | rO| | j i| j IdH}n | | j i| j }| |WWdSt yw|jrttdnYnwWddS1swYdS) a Async equivalent of :meth:`__call__` for use within existing event loops. This method should be used when you're already in an async context (e.g., Jupyter notebooks, existing async applications) and need to execute a Cyclopts command without creating a new event loop. Parameters ---------- tokens : None | str | Iterable[str] Either a string, or a list of strings to launch a command. Defaults to ``sys.argv[1:]``. console: ~rich.console.Console Console to print help and runtime Cyclopts errors. If not provided, follows the resolution order defined in :attr:`App.console`. error_console: ~rich.console.Console Console to print error messages. If not provided, follows the resolution order defined in :attr:`App.error_console`. print_error: bool | None Print a rich-formatted error on error. If :obj:`None`, inherits from :attr:`App.print_error`, eventually defaulting to :obj:`True`. exit_on_error: bool | None If there is an error parsing the CLI tokens invoke ``sys.exit(1)``. Otherwise, continue to raise the exception. If :obj:`None`, inherits from :attr:`App.exit_on_error`, eventually defaulting to :obj:`True`. help_on_error: bool | None Prints the help-page before printing an error. If :obj:`None`, inherits from :attr:`App.help_on_error`, eventually defaulting to :obj:`False`. verbose: bool | None Populate exception strings with more information intended for developers. If :obj:`None`, inherits from :attr:`App.verbose`, eventually defaulting to :obj:`False`. end_of_options_delimiter: str | None All tokens after this delimiter will be force-interpreted as positional arguments. If :obj:`None`, inherits from :attr:`App.end_of_options_delimiter`, eventually defaulting to POSIX-standard ``"--"``. Set to an empty string to disable. backend: Literal["asyncio", "trio"] | None Override the async backend to use (if an async command is invoked). If :obj:`None`, inherits from :attr:`App.backend`, eventually defaulting to "asyncio". If passing backend="trio", ensure trio is installed via the extra: `cyclopts[trio]`. result_action: ResultAction | None Controls how command return values are handled. Can be a predefined literal string or a custom callable that takes the result and returns a processed value. If :obj:`None`, inherits from :attr:`App.result_action`, eventually defaulting to "print_non_int_return_int_as_exit_code". See :attr:`App.result_action` for available modes. Returns ------- return_value: Any The value the command function returns. Examples -------- .. code-block:: python import asyncio from cyclopts import App app = App() @app.command async def my_async_command(): await asyncio.sleep(1) return "Done!" # In an async context (e.g., Jupyter notebook or existing async app): async def main(): result = await app.run_async(["my-async-command"]) print(result) # Prints: Done! asyncio.run(main()) NcSrrdrKrrKrKrLrrz!App.run_async..rrrrr)rzr{r rrrUrrrTrgrrqrrrrr)rr'rrrrrrrrrr`rrDryrJrKrKrL run_asyncNsLW        "z App.run_asyncrp)rcCsddlm}m}ddlm}t|}||\}}}|d} d|i} |j|| d| j}| j dur8|||} n | j rA| j d} nd} | jj d t d } || | } | || }| jj d |d }t |d rm|||j| n| rt|| t |d r|||j| n| r|| |D]\}}|r|jnd}|dur|}td|}|||j|q| j d}rddlm}||j|| d}||WddSWddS1swYdS)aPrint the help page. Parameters ---------- tokens: None | str | Iterable[str] Tokens to interpret for traversing the application command structure. If not provided, defaults to ``sys.argv``. console: ~rich.console.Console Console to print help and runtime Cyclopts errors. If not provided, follows the resolution order defined in :attr:`App.console`. r) format_doc format_usage)DefaultFormatterr(rr_N rrr render_usagerender_descriptionr?rrr)r rrcyclopts.help.formattersrr r=rrrrr _assemble_help_panelshasattrroptionsr rrrrr )rr'rrrrr7r,ry executing_appr`rr descriptionhelp_panels_with_groupsdefault_formatterrpanel formatterrrepiloguerKrKrLrsN              ("zApp.help_printr)r>c# Csddlm}ddlm}ddlm}m}m}m}||\} } } | d} | j d|t }i} t | D]V}t |D]O\}}|js@q8z | |j\} }Wnty`||jdd}||f| |j<Ynw|jr}|j|j|d d }|jrz||j|||_n||_|j|||d q8q2|| }|D]}|jsq|jd d }|j d pd}tdd|D}|D](}|D]#}|| |}t|jjtsJt|jtg|jj|Rd|_qq|j D]I}|jsq|j!|d}|sq| "|jd\} }||||}|rd|_#|j|j|_|jr|jr||j||j|_n|j|_||f| |j<qqdd| $D}dd| $D}g}t%||\} }!t&| |!ddD]\}}"|"'|"j#dkrZ|"(|)||"fqH|S)Nr)r))NewLine)r>rcreate_parameter_help_panelformat_command_entriesr(rr)titler T)r force_empty_endr)r\rrKcss$|] }t|tr|jr|VqdSrd)r^r"rrgrKrKrLriSs"z,App._assemble_help_panels..)env_var)rNN parametercSg|]}|dqS)rrKrgrKrKrLr/uz-App._assemble_help_panels..cSr)r0rKrgrKrKrLr/vrF)strict)*rr)rr r>rrrr=rrr rr+rrrrr rentriesr)rBrrGr6_convert_argumentr^rrr-r^groupsrrr r?r*zip_remove_duplicates_sortr)#rr'r RichGrouprr>rrrr7r>ryrhpanelsrrapps_with_names command_panel group_helpapps_for_paramsrKconfigs env_configsrs env_configrgroup_argument_collectionexisting_panel new_panelr help_panelsr sorted_groups sorted_panels help_panelrKrKrLrs            zApp._assemble_help_panelsrFr0 output_formatr= recursiveinclude_hidden heading_levelflatten_commandsc Csddlm}m}m}ddlm} ||}|dkr#||||||d} | S|dkr2| |||||d} | S|dkr@||||||dd } | S) aGenerate documentation for this CLI application. Parameters ---------- output_format : DocFormat Output format for the documentation. Accepts "markdown"/"md", "html"/"htm", or "rst"/"rest"/"restructuredtext". Default is "markdown". recursive : bool If True, generate documentation for all subcommands recursively. Default is True. include_hidden : bool If True, include hidden commands/parameters in documentation. Default is False. heading_level : int Starting heading level for the main application title. Default is 1 (single # for markdown, = for RST). flatten_commands : bool If True, generate all commands at the same heading level instead of nested. Default is False. Returns ------- str The generated documentation. Raises ------ ValueError If an unsupported output format is specified. Examples -------- >>> app = App(name="myapp", help="My CLI Application") >>> docs = app.generate_docs() # Generate markdown as string >>> html_docs = app.generate_docs(output_format="html") # Generate HTML >>> rst_docs = app.generate_docs(output_format="rst") # Generate RST >>> # To write to file, caller can do: >>> # Path("docs/cli.md").write_text(docs) r)generate_markdown_docsgenerate_rst_docsnormalize_format)generate_html_docsrF)rrrrhtmlrF)rrrr no_root_title) cyclopts.docsrrrcyclopts.docs.htmlr) rrrrrrrrrrrrKrKrL generate_docss>/  zApp.generate_docs) prog_nameshellrr)zshbashfishcCs|dur|js tdt|jtr|jdn|j}|dur&ddlm}|}|dkr5ddlm}|||S|dkrDddlm}|||S|dkrSddl m}|||Std |) aGenerate shell completion script for this application. Parameters ---------- prog_name : str | None Program name for completion. If None, uses first name from app.name. shell : Literal["zsh", "bash", "fish"] | None Shell type. If None, automatically detects current shell. Supported shells: "zsh", "bash", "fish". Returns ------- str Complete shell completion script. Examples -------- Auto-detect shell and generate completion: >>> app = App(name="myapp") >>> script = app.generate_completion() >>> Path("_myapp").write_text(script) Explicitly specify shell type: >>> script = app.generate_completion(shell="zsh") Raises ------ ValueError If app has no name or shell type is unsupported. ShellDetectionError If shell is None and auto-detection fails. Nz2App must have a name to generate completion scriptr detect_shellr)generate_completion_scriptrrzUnsupported shell: ) rrIr^r6cyclopts.completionrcyclopts.completion.zshrcyclopts.completion.bashcyclopts.completion.fish)rrrrrrKrKrLgenerate_completions"(       zApp.generate_completion)routputadd_to_startuprrcCsddlm}|dur |}ddlm}m}|j|d}|dur'|||jd}|jjddd| ||rC|dvrC|||jd||S) aOInstall shell completion script to appropriate location. Generates and writes the completion script to a shell-specific location. Parameters ---------- shell : Literal["zsh", "bash", "fish"] | None Shell type for completion. If not specified, attempts to auto-detect current shell. output : Path | None Output path for the completion script. If not specified, uses shell-specific default: - zsh: ~/.zsh/completions/_ - bash: ~/.local/share/bash-completion/completions/ - fish: ~/.config/fish/completions/.fish add_to_startup : bool If True (default), adds source line to shell RC file to ensure completion is loaded. Set to False if completions are already configured to auto-load. Returns ------- Path Path where the completion script was installed. Examples -------- Auto-detect shell and install: >>> app = App(name="myapp") >>> path = app.install_completion() Install for specific shell: >>> path = app.install_completion(shell="zsh") Install to custom path: >>> path = app.install_completion(output=Path("/custom/path")) Install without modifying RC files: >>> path = app.install_completion(shell="bash", add_to_startup=False) Raises ------ ShellDetectionError If shell is None and auto-detection fails. ValueError If shell type is unsupported. rrN)add_to_rc_fileget_default_completion_path)rT)parentsexist_ok)rr) cyclopts.completion.detectrcyclopts.completion.installrrrrparentmkdir write_text)rrrrrrrscript_contentrKrKrLinstall_completion s 7   zApp.install_completion--install-completioncKs2ddlm}||j|}|j|fd|i|dS)aRegister a command for installing shell completion. This is a convenience method that creates a command which calls :meth:`install_completion`. For more control over the command implementation, users can manually define their own command. Parameters ---------- name : str | Iterable[str] Command name(s) for the install completion command. Defaults to "--install-completion". add_to_startup : bool If True (default), adds source line to shell RC file to ensure completion is loaded. Set to False if completions are already configured to auto-load. **kwargs Additional keyword arguments to pass to :meth:`command`. Can be used to customize the command registration (e.g., `help`, `group`, `help_flags`, `version_flags`). Examples -------- Register install-completion command: >>> app = App(name="myapp") >>> app.register_install_completion_command() >>> app() # Now responds to: myapp --install-completion Use a custom command name: >>> app.register_install_completion_command(name="--setup-completion") Customize help text: >>> app.register_install_completion_command(help="Install shell completion for myapp.") Customize command registration: >>> app.register_install_completion_command(group="Setup", help_flags=[]) Install without modifying RC files: >>> app.register_install_completion_command(add_to_startup=False) See Also -------- install_completion : The underlying method that performs the installation. r)!create_install_completion_commandrN)rrrr)rrrrqr command_fnrKrKrL#register_install_completion_commandc s 4 z'App.register_install_completion_command$ promptquit dispatcherzConsole | NonecKsPtjdkr tdntd|durddg}t|tr|g}dd}|dur(|}i} |dur2|| d <|dur:|| d < zt|} Wn tyKYdSwt| } | sSq:| d |vr[dSz4|| | $|j | f||d |\} } }|| | |}|j |ddWdn1swYWnt yYnt ytt Ynwq;)aCreate a blocking, interactive shell. All registered commands can be executed in the shell. Parameters ---------- prompt: str Shell prompt. Defaults to ``"$ "``. quit: str | Iterable[str] String or list of strings that will cause the shell to exit and this method to return. Defaults to ``["q", "quit"]``. dispatcher: Dispatcher | None Optional function that subsequently invokes the command. The ``dispatcher`` function must have signature: .. code-block:: python def dispatcher(command: Callable, bound: inspect.BoundArguments, ignored: dict[str, Any]) -> Any: return command(*bound.args, **bound.kwargs) The above is the default dispatcher implementation. console: Console | None Rich Console to use for output. If :obj:`None`, uses :attr:`App.console`. exit_on_error: bool Whether to call ``sys.exit`` on parsing errors. Defaults to :obj:`False`. result_action: ResultAction | None How to handle command return values in the interactive shell. Defaults to ``"print_non_int_return_int_as_exit_code"`` which prints non-int results and returns int/bool as exit codes without calling sys.exit. If :obj:`None`, inherits from :attr:`App.result_action`. `**kwargs` Get passed along to :meth:`parse_args`. posixz(Interactive shell. Press Ctrl-D to exit.z:Interactive shell. Press Ctrl-Z followed by Enter to exit.NqrcSs||ji|jSrd)rrq)rrDryrKrKrLdefault_dispatcher sz1App.interactive_shell..default_dispatcherrrTr)rr%print_non_int_return_int_as_exit_coder)osrr r^rinputEOFErrorr rrrr$rH traceback format_exc)rrrrrrrrqrr` user_inputr'rrDrbrJrKrKrLinteractive_shell sZ +        zApp.interactive_shellprint_non_int_sys_exitrJrcs6ddlm}ttjjd|d}|||fddS)aHandle command result based on result_action. Parameters ---------- result : Any The command's return value. fallback : ResultAction The fallback result_action if none is configured. Defaults to "print_non_int_sys_exit". Returns ------- Any Processed result based on action (may call sys.exit() and not return). r)handle_result_actionrrcs j|Srd)rr rarrKrL s z+App._handle_result_action..)cyclopts._result_actionr rr@rr)rrJrr actionrKrrLr s zApp._handle_result_actionrjcCs|j|jdS)aCopy over all commands from another :class:`App`. Commands from the meta app will **not** be copied over. Parameters ---------- app: cyclopts.App All commands from this application will be copied over. N)rr)rrjrKrKrLr s z App.updatecCsxi}|jD]}|js qt||j}t|t|jks||jkr$|||j<qddd|D}t|j d|dS)zOnly shows non-default values.r1css"|] \}}|d|VqdS)ruNrKrrKrKrLri' s zApp.__repr__..()) __attrs_attrs__rgetattrrr$rrr3rrO)r non_defaultsarr}rKrKrL__repr__ s   z App.__repr__)rHr<)rrd)T)rHr})rHr_r)rFTFr0F)rT)rNNNFN)r rjr_)rOrPrQrr5rrr6__annotations__rrr8rrcrrrrr-rr rrrfrrrboolrrrrrrrrrrr)rrornrmr7rrr6rrrrrrrr4rrrMrr@rArrrrrrr1rrr$rrrrrrrpropertyrsetterrrrtrsrrrrrrrrrrrrrrirhrrrrrrrr#rr=rrBr5rrCobjectrrrGrTBoundArgumentsrcrarrrrrrintrrr rrr/rrrrrKrKrKrLr_s &"  4*" "                        5   (  )  v"%A              0 %$ 7&     k     e      H l W  D  N  ; \  c Csd}|rtt ||}Wdn1swY|D]-}tt||}|dus3||kr= Wd|SWdn1sGwYqd}|Srd)rrIindex)r'rrdelimiter_index help_flagrrKrKrLr|+ s"    r|c@seZdZdZdZdS) TestFrameworkrxpytestN)rOrPrQUNKNOWNPYTESTrKrKrKrLr < sr cCs&dtjvrtjddurtjStjS)zDetects if we are currently being ran in a test framework. Returns ------- TestFramework Name of the testing framework. Returns an empty string if not testing framework discovered. r!PYTEST_VERSIONN)rrrenvironrr r#r"rKrKrKrLr{A s r{ frameworkc Cs|tjkrdSddl}tD]l}|j}|j}t|}|dus$|dur%q|j dd}|dkr2qd|j vr8q|j d}i|j |j }g} | D] \} } | |urX| | qKt| dkrbd} n| d} d|jd | d } |jt| d d dSdS) aLog a warning message for a given testing framework. Intended to catch developers invoking their app during unit-tests without providing commands and erroneously reading from :obj:`sys.argv`. TO ONLY BE CALLED WITHIN A CYCLOPTS.APP METHOD. NrrRrSrr0rjzGCyclopts application invoked without tokens under unit-test framework "z". Did you mean "z([])"?r9) stacklevel)r r"warningsrTrUrWf_backrVrOrXf_localsrrrr2rGwarn UserWarning) r&r(rYrWr)calling_modulecalling_module_namecalled_cyclopts_app_instancecandidate_variablesmatched_app_variablesvar_name var_instancemessagerKrKrLrzT s8       rz)rjr_rlr_rHN)TTr){rrTrrrcollections.abcrrrrr contextlibrrenumr rr r itertoolsr pathlibr typesrtypingrrrrrrrrrattrsrrrcyclopts.annotationsrcyclopts.app_stackrcyclopts.argumentrrFrrr cyclopts.command_specr!cyclopts.config._envr"cyclopts.exceptionsr#r$r%r&r'r(cyclopts.groupr)r*cyclopts.group_extractorsr+cyclopts.panelr,cyclopts.parameterr-r.cyclopts.protocolsr/cyclopts.tokenr0cyclopts.utilsr1r2r3r4r5r6r7r8 version_inforreadlinerr<cyclopts.docs.typesr=r r>cyclopts.help.protocolsr?r r@rA cyclopts._runrBrCrEr r6rMrHrNr\rcrkrprrrur|rrrr_rr|r r{rzrKrKrKrLs      ,          (        *   (  9