o NEg@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZddlmZddlmZmZmZmZmZmZmZmZmZmZddlmZmZmZm Z dd l!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'dd l(m)Z)dd lm*Z*m+Z+m,Z,m-Z-dd l.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mZ>m?Z?m@Z@ddlAmBZBmCZCmDZDmEZEmFZFmGZGmHZHddl mIZImJZJmKZKeFeBjLkre jMNeOeGn6ddlAmPZPmQZQeQRZSeFeBjTkreQjUjVjWZXneFeBjYkrddlZZZddlAm[Z[eZj\]e[dZ^eZ_e^eZj`jaZbdZczddldmeZeWn efy)dZcYnwGdddZgGdddZhedgdZiGdd d ejjZjdS)!avVariant on standard library's cmd with extra features. To use, simply import cmd2.Cmd instead of cmd.Cmd; use precisely as though you were using the standard library's cmd, while enjoying the extra features. Searchable command history (commands: "history") Run commands from file, save to file, edit commands in file Multi-line commands Special-character shortcut commands (beyond cmd's "?" and "!") Settable environment parameters Parsing commands with `argparse` argument parsers (flags) Redirection to file or paste buffer (clipboard) with > or >> Easy transcript-based testing of applications (see examples/example.py) Bash-style ``select`` available Note that redirection with > and | will only work if `self.poutput()` is used in place of `print`. - Catherine Devlin, Jan 03 2008 - catherinedevlin.blogspot.com Git repository on GitHub at https://github.com/python-cmd2/cmd2 N)InteractiveConsole) namedtuple)redirect_stdout) AnyCallableDictIterableListMappingOptionalTupleTypeUnion)ansi constantspluginutils)DEFAULT_ARGUMENT_PARSERCompletionItem)can_clipget_paste_bufferwrite_to_paste_buffer) CommandSet) CLASS_ATTR_DEFAULT_HELP_CATEGORYCOMMAND_FUNC_PREFIXCOMPLETER_FUNC_PREFIXHELP_FUNC_PREFIX)as_subcommand_towith_argparser)Cmd2ShlexErrorCommandSetRegistrationErrorEmbeddedConsoleExitEmptyStatementRedirectionErrorSkipPostcommandHooks)History HistoryItem)MacroMacroArg StatementStatementParser shlex_split)RlType rl_get_pointrl_make_safe_prompt rl_set_promptrl_type rl_warning vt100_support)CompletionErrorSettableget_defining_class)rl_force_redisplayreadline) readline_librl_basic_quote_charactersT)embedFc@eZdZdZddZdS)_SavedReadlineSettingszQreadline settings that are backed up when switching between readline environmentscCsd|_d|_d|_dS)N) completerdelims basic_quotesselfrDc/var/www/eduai.edurigo.com/doc_train/edurigo_ai/Puru/venv/lib/python3.10/site-packages/cmd2/cmd2.py__init__s z_SavedReadlineSettings.__init__N__name__ __module__ __qualname____doc__rFrDrDrDrEr= r=c@r<) _SavedCmd2EnvzVcmd2 environment settings that are backed up when entering an interactive Python shellcCs$t|_d|_g|_d|_d|_dSN)r=readline_settingsreadline_modulehistory sys_stdout sys_stdinrBrDrDrErFs  z_SavedCmd2Env.__init__NrGrDrDrDrErMrLrMDisabledCommandcommand_function help_functioncompleter_functionc seZdZdZeZdZejZ ej Z ddddddddddddddd d e d e d e d e dedededeee dedeee deee deee e fdeeededdffddZdddeededeefddZd e deefd!d"Zdd#d$Zd%eddfd&d'Zdd(e d)efd*d+Zd,e d-efd.d/Zd,e d0efd1d2Zd%efd3d4Zd%efd5d6Zd%e edfddfd7d8Z!d%e edfddfd9d:Z"d;e#ddfde ddfd?d@Z%dAdBZ&e'de fdCdDZ(e(j)dEe ddfdFdDZ(defdGdHZ*e'de fdIdJZ+ddKdLdMe,dNe ddfdOdPZ-ddKddQdMe,dNe dReddfdSdTZ.ddKddQdMe,dNe dReddfdUdVZ/dKddQdMe,dNe dReddfdWdXZ0dKdLdMe,dNe ddfdYdZZ1dKdd[dMe,dNe d\eddfd]d^Z2dd_d`Z3dae dbe dce de4ee ee ffdddeZ5dfe dae dbe dce dgedhe dee fdidjZ6ddkdfe dae dbe dce dlee e eeffdme deefdee fdndoZ7ddkdfe dae dbe dce dpe8e e eeffdme deefdee fdqdrZ9ddsdfe dae dbe dce dteee gefdee f dudvZ:ddwdfe dae dbe dce dxedee f dydzZ;dfe dae dbe dce d{edee f d|d}Zde fddZ?de dee de ddfddZ@dee ddfddZAdfe dae dbe dce de ddf ddZBdfe de dee fddZCdddfe dae dbe dce deDjEdedeedee fddZFdefddZGdefddZHe'dee e ffddZIddZJdee fddZKdee fddZLdeeMfddZNdeeMfddZOdeeMfddZPdee fddZQdee fddZRde ddfddZSdeTdeTfddZUdedeTdefddZVddZWddZXdae de4e e e ffddZYdddddae dedededef ddZZdedeeTdefdd„Z[dddÜdee e\e fdededefddDŽZ]dae deTfddɄZ^dae deTfdd˄Z_deTdee fdd̈́Z`deTdejafddτZbdeTdejaddfdd҄Zcd(e deefddԄZdd(e de fddքZeddלde eTe fdedefddلZfdeTdeefddۄZgddܜde dede fddZhde de fddZidejfddZkdejfddZldddZmdZndZoepeneodZqeqjrdddZsdes_teueqdddeDjvddfddZwdZxdZyepexeydZzezj{dddddezj{d>ddezj{d(deQdezj{deDj|de:de}ddezex~ddeDjvddfddZdZdZepedZej{d d dd dej{d eDjd eNdde}ddeeddeDjvddfddZdZdZepedZej{dddddej{d eDjdeNdde}ddeeddeDjvddfddZdZdZepeedZejrdddZde_teuedddeDjvddfddZd Zd!Zd"ZepeedZej{dddd#dej{d>d$dej{d(d%eQdej{deDj|de:de}d&deeddeDjvddfd'd(Zd)Zd*ZepedZej{d d dd+dej{d eDjd,eOdde}d&deeddeDjvddfd-d.Zd/Zd0ZepedZej{dddd1dej{d eDjd2eOdde}d&deeddeDjvddfd3d4Zdfe dae dbe dce dee f d5d6Zdfe dae dbe dce d7ee ee fdee f d8d9Zepd:dZej{d;dedej{d?eDj|d@edeejdAddur6eejdAeuedeDjvddffdBdC ZddDeddfdEdFZdGdHZdIe dee dDeddfdJdKZepdLdZeuedMeDjvddfdNdOZepdPedZeuedMeDjvdefdQdRZepdSdZeuedMeDjvdefdTdUZ VddWe e ee ee4e,ee ffde de fdXdYZdfe dae dbe dce d7ee ee fdee f dZd[Zd\Zepedd]Zej{d;diFT) persistent_history_filepersistent_history_lengthstartup_scriptsilent_startup_script use_ipythonallow_cli_argstranscript_filesallow_redirectionmultiline_commands terminators shortcuts command_setsauto_load_commands completekeyr[r\r]r^r_r`rarbrcrdrerfrgreturnc s|szd|_Wn tyYnw|tj|||dd|_d|_| |_d|_d|_ d|_ t j |_ d|_d|_d|_d|_t|_|d|_d|_ddg|_||_||ddg|_t|_g|_d |_t|_d|_t | | |d |_!d|_"g|_#t$%|_&d|_'d|_(d|_)d |_*d |_+d |_,d|_-d |_.g|_/|rt0j12t0j13|}t0j14|rd5t$6|}|r|d5t0j77}|j/8|d|_9| rt:;}|jr||_9n|r|j/?|n| r| |_9t@jABdrd|_C|_Dnd|_Cd|_DtE|_Fd|_GtHI|_Jt|_Kd|_Lt jM|_Nd|_Od|_Pd |_Qd |_Rg|_Sg|_Td|_Ud|_Vg|_Wi|_X|rL|D]}|Y|qC|rS|Z|[D]}|j!\|\}}|slt]d5||qW|^|dS)aAn easy but powerful framework for writing line-oriented command interpreters. Extends Python's cmd package. :param completekey: readline name of a completion key, default to Tab :param stdin: alternate input file object, if not specified, sys.stdin is used :param stdout: alternate output file object, if not specified, sys.stdout is used :param persistent_history_file: file path to load a persistent cmd2 command history from :param persistent_history_length: max number of history items to write to the persistent history file :param startup_script: file path to a script to execute at startup :param silent_startup_script: if ``True``, then the startup script's output will be suppressed. Anything written to stderr will still display. :param use_ipython: should the "ipy" command be included for an embedded IPython shell :param allow_cli_args: if ``True``, then :meth:`cmd2.Cmd.__init__` will process command line arguments as either commands to be run or, if ``-t`` or ``--test`` are given, transcript files to run. This should be set to ``False`` if your application parses its own command line arguments. :param transcript_files: pass a list of transcript files to be run on initialization. This allows running transcript tests when ``allow_cli_args`` is ``False``. If ``allow_cli_args`` is ``True`` this parameter is ignored. :param allow_redirection: If ``False``, prevent output redirection and piping to shell commands. This parameter prevents redirection and piping, but does not alter parsing behavior. A user can still type redirection and piping tokens, and they will be parsed as such but they won't do anything. :param multiline_commands: list of commands allowed to accept multi-line input :param terminators: list of characters that terminate a command. These are mainly intended for terminating multiline commands, but will also terminate single-line commands. If not supplied, the default is a semicolon. If your app only contains single-line commands and you want terminators to be treated as literals by the parser, then set this to an empty list. :param shortcuts: dictionary containing shortcuts for commands. If not supplied, then defaults to constants.DEFAULT_SHORTCUTS. If you do not want any shortcuts, pass an empty dictionary. :param command_sets: Provide CommandSet instances to load during cmd2 initialization. This allows CommandSets with custom constructor parameters to be loaded. This also allows the a set of CommandSets to be provided when `auto_load_commands` is set to False :param auto_load_commands: If True, cmd2 will check for all subclasses of `CommandSet` that are currently loaded by Python and automatically instantiate and register all commands. If False, CommandSets must be manually installed with `register_command_set`. N)rhstdinstdoutF2z> eof_relative_run_scriptrQapp)rdrcrer>zKDocumented commands (use 'help -v' for verbose/'help ' for details):z No help on {}z/{} is not a recognized command, alias, or macroz run_script {}z> {}-tz--test store_truez1Test against transcript(s) in FILE (wildcards OK)actionhelpwinmorez less -RXFz less -SRXFr UncategorizedTInvalid command name {!r}: {})_do_ipyAttributeError_initialize_plugin_systemsuperrFdefault_to_shellquit_on_sigintrbalways_show_hintdebugechorYDEFAULT_EDITOReditorfeedback_to_outputquiettimingmax_completion_itemsdict settablesbuild_settablescontinuation_prompt self_in_pyhidden_commands_persistent_history_length_initialize_historyexclude_from_historymacros _py_historypy_bridge_name py_locals_in_pyr+statement_parser last_result _script_dirr ContextFlagsigint_protection_cur_pipe_proc_reader _redirecting_at_continuation_prompt_multiline_in_progress doc_header help_error default_errorbroken_pipe_warning_startup_commandsospathabspath expanduserexistsformat quote_stringdevnullappend_transcript_filesargparseArgumentParser add_argumentparse_known_argstestextendsysplatform startswithpager pager_chopr _can_clip exit_code threadingRLock terminal_lockdisabled_commandsdefault_categoryALPHABETICAL_SORT_KEYdefault_sort_keyallow_appended_spaceallow_closing_quotecompletion_hintcompletion_headercompletion_matchesdisplay_matchesmatches_delimitedmatches_sorted_installed_command_sets_cmd_to_command_setsregister_command_set_autoload_commandsget_all_commandsis_valid_command ValueError_register_subcommands)rCrhrjrkr[r\r]r^r_r`rarbrcrdrerfrg script_cmdparsercalloptscallargs command_setcur_cmdvaliderrmsg __class__rDrErFs7              z Cmd.__init__)subclass_matchcommandset_typercsfdd|jDS)a Find all CommandSets that match the provided CommandSet type. By default, locates a CommandSet that is an exact type match but may optionally return all CommandSets that are sub-classes of the provided type :param commandset_type: CommandSet sub-class type to search for :param subclass_match: If True, return all sub-classes of provided type, otherwise only search for exact match :return: Matching CommandSets cs*g|]}t|ksrt|r|qSrD)type isinstance).0cmdsetrrrDrE sz(Cmd.find_commandsets..)r)rCrrrDrrEfind_commandsetss zCmd.find_commandsets command_namecCs |j|S)z Finds the CommandSet that registered the command name :param command_name: command name to search :return: CommandSet that provided the command )rget)rCrrDrDrEfind_commandset_for_commands zCmd.find_commandset_for_commandcsBt}ddjDdttddffdd |dS)z!Load modular command definitions.cSg|]}t|qSrDrrrrDrDrErz*Cmd._autoload_commands..commandset_typesriNcs`|D]+}|}|r|qt|j}|vs-t|jdks-d|jvs-|}|qdS)NrrC)__subclasses__inspect signaturerFlen parametersr)r cmdset_type subclassesinit_sigrexisting_commandset_typesload_commandset_by_typerCrDrErs    z7Cmd._autoload_commands..load_commandset_by_type)rrrr r )rCall_commandset_defsrDrrErs zCmd._autoload_commandsrcsdd|jD}t|vrtdtjd|tjddd}ttd}g}zu|D]`\}}|t t d}| ||tj| |t |} t| d} | durf||| | | t|} t| d} | dur||| | | |j|<|rt|tjst||q2|j |WdSty|D]} t|| q|jvr|j|jvr؇fd d |jD|_w) z Installs a CommandSet, loading all commands defined in the CommandSet :param cmdset: CommandSet to load cSrrDrrrDrDrErrz,Cmd.register_command_set..z CommandSet z is already installedcS t|tot|do|jtSNrHrrhasattrrHrrmethrDrDrE%  z*Cmd.register_command_set.. predicateNcsi|] \}}|ur||qSrDrD)rkeyvalrrDrE Oz,Cmd.register_command_set..) rrr!rH on_registerr getmembersgetattrrrr_install_command_functionrr_install_completer_functionr_install_help_functionrrrCMD_ATTR_HELP_CATEGORYr categorizer on_registered Exception on_unregisterdelattrremovevaluesitemson_unregistered)rCrrmethodsrinstalled_attributes method_namemethodcommandcompleter_func_name cmd_completerhelp_func_namecmd_helpattribrDrrErsX                   zCmd.register_command_setrcommand_wrappercCst|}t||rtd|||j|\}}|s#td||||jvr4|d||j|=||jvrE|d||j|=t |||dS)Nz!Attribute already exists: {} ({})rxzADeleting alias '{}' because it shares its name with a new commandzADeleting macro '{}' because it shares its name with a new command) rrr!rrraliasespwarningrsetattr)rCrr"context cmd_func_namerrrDrDrEr Ss   zCmd._install_command_functioncmd_namercC0t|}t||rtd|t|||dSNzAttribute already exists: {})rrr!rr%)rCr(rrrDrDrEr k zCmd._install_completer_functionr cCr)r*)rrr!rr%)rCr(r rrDrDrEr rr+zCmd._install_help_functioncCs||jvrm|||||tj|ddd}|D]B}|dttd}||jvr4| |||j vr=|j |=t |t|t |t |rRt |t |t |t|r`t |t|q||j|dSdS)z| Uninstalls a CommandSet and unloads all associated commands :param cmdset: CommandSet to uninstall cSrrrrrDrDrErrz,Cmd.unregister_command_set..rrN)r_check_uninstallabler_unregister_subcommandsrr rrrenable_commandrrrrrrr)rCrrrr(rDrDrEunregister_command_setys.      zCmd.unregister_command_setcstjddd}|D]3}|dttd}||jvr#|j|j}n||}t|tj d}fdd|dur>|q dS)NcSrrrrrDrDrErrz*Cmd._check_uninstallable..rrcs`|jD]*}t|tjr-|jD]}t|tjd}|dur%|ur%t d|qdSqdS)NzACannot uninstall CommandSet when another CommandSet depends on it) _actionsrr_SubParsersActionchoicesrr rPARSER_ATTR_COMMANDSETr!)rrs subparserattached_cmdsetcheck_parser_uninstallablerrDrEr7s   z.check_parser_uninstallable) rr rrrrVcmd_funcr rCMD_ATTR_ARGPARSER)rCrrrr command_funccommand_parserrDr6rEr,s   zCmd._check_uninstallablecs&||us ||jvs tdtj|ddd}|D]\}}t|tj}t|tjt|tj}|j j |dd\}}|sDtd t || } | d} | d d } | |jvr^|j| j} n|| } | d urqtd | t |t| tjd } | d urtd | t |d tjdtt dtjffdd | | }|jD]o}t|tjr||t|tji}|g|d<|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|j|d<|j |d<|j!|d<|j"|d<d|d<|j#|fi|}tj$|i}|j%di|t&|tj'|nqqd S) z Register subcommands with their base command :param cmdset: CommandSet or cmd2.Cmd subclass containing subcommands z;Cannot register subcommands with an unregistered CommandSetcS.t|tot|tjot|tjot|tjSrNrrrrSUBCMD_ATTR_NAMESUBCMD_ATTR_COMMANDr9rrDrDrEr   z+Cmd._register_subcommands..rT) is_subcommandzSubcommand {} is not valid: {}rrN4Could not find command "{}" needed by subcommand: {}BCould not find argparser for command "{}" needed by subcommand: {}rs subcmd_namesricsj|s|S|d}|jD]!}t|tjr-|jD]\}}||kr*||Sqnq td)NrzCould not find sub-command "{}") popr0rrr1r2rr!r)rsrD cur_subcmd sub_action choice_namechoicefind_subcommandfull_command_namerDrErKs   z2Cmd._register_subcommands..find_subcommandparentsprogusage descriptionepilogformatter_class prefix_charsfromfile_prefix_charsargument_defaultconflict_handler allow_abbrevFadd_helprD)(rr!rr r rr>r?r9rrrstrsplitrrVr8rrr r0rr1 remove_parserSUBCMD_ATTR_ADD_PARSER_KWARGSrNrOrPrQrRrSrTrUrVrW add_parserNS_ATTR_SUBCMD_HANDLER set_defaultsr%r3)rCrrrrsubcommand_name subcmd_parsersubcommand_validrcommand_tokensrsubcommand_namesr:r; target_parserrsadd_parser_kwargsattached_parserdefaultsrDrJrErsl        $              zCmd._register_subcommandsc Cs||us ||jvs tdtj|ddd}|D]W\}}t|tj}t|tj}||jvr4|j|j }n| |}|durGtd |t |t|tj d}|dur\td |t ||jD]} t| tjrn| |nq_qdS)zz Unregister subcommands from their base command :param cmdset: CommandSet containing subcommands z=Cannot unregister subcommands with an unregistered CommandSetcSr<rNr=rrDrDrEr.r@z-Cmd._unregister_subcommands..rNrBrC)rr!rr r rr>r?rrVr8rrYr9r0rrr1r[) rCrrrrr`rr:r;rsrDrDrEr-"s8         zCmd._unregister_subcommandssettablecCs||j|j<dS)z Convenience method to add a settable parameter to ``self.settables`` :param settable: Settable object being added N)rname)rCrirDrDrE add_settablePszCmd.add_settablerjcCs*z|j|=WdStyt|dw)z Convenience method for removing a settable parameter from ``self.settables`` :param name: name of the settable being removed :raises: KeyError if the Settable matches this name  is not a settable parameterN)rKeyError)rCrjrDrDrEremove_settableXs   zCmd.remove_settablec Cs|tdtdtjtjtjtjtjtjgd|tdtd|tdtd|tdtd |td td |td td |tdt d|tdtd|tdtddS)z1Create the dictionary of user-settable parameters allow_stylezDAllow ANSI text style sequences in output (valid values: {}, {}, {}))r2rzBDisplay tab completion hint even when completion suggestions printrz Show full traceback on exceptionrzEcho command issued into outputrzProgram used by 'edit'rz)Include nonessentials in '|', '>' resultsrzBMaximum number of CompletionItems to display during tab completionrz!Don't print nonessential feedbackrzReport execution timesN) rkr5rYrrSTYLE_TERMINAL STYLE_ALWAYS STYLE_NEVERboolintrBrDrDrErds(   zCmd.build_settablescCstjS)zERead-only property needed to support do_set when it reads allow_style)rrorBrDrDrErozszCmd.allow_stylenew_valcCs>|}|tjtjtjfvr|t_dStdtjtjtj)zDSetter property needed to support do_set when it updates allow_stylez(must be {}, {}, or {} (case-insensitive)N) capitalizerrprqrrrorr)rCrurDrDrEros  cCs|jo |jo ttjkS)z*Return whether tab completion is supported) use_rawinputrhr1r-NONErBrDrDrE_completion_supportedzCmd._completion_supportedcCs t|jS)a8Read-only property to get the visible prompt with any ANSI style escape codes stripped. Used by transcript testing to make it easier and more reliable when users are doing things like coloring the prompt using ANSI color codes. :return: prompt stripped of any ANSI escape codes )r strip_stylepromptrBrDrDrEvisible_prompts zCmd.visible_prompt endmsgrcCsLzt|jd||WdSty%|jr"tj|jYdSYdSw)aPrint message to self.stdout and appends a newline by default Also handles BrokenPipeError exceptions for when a command's output has been piped to another process and that process terminates before the cmd2 command is finished executing. :param msg: message to print (anything convertible to a str with '{}'.format() is OK) :param end: string appended after the end of the message, default a newline {}{}N) rstyle_aware_writerkrBrokenPipeErrorrrstderrwriterCrrrDrDrEpoutputs  z Cmd.poutputr apply_stylercCs0|rt|}nd|}ttj||dS)aPrint message to sys.stderr :param msg: message to print (anything convertible to a str with '{}'.format() is OK) :param end: string appended after the end of the message, default a newline :param apply_style: If True, then ansi.style_error will be applied to the message text. Set to False in cases where the message text already has the desired style. Defaults to True. {}N)r style_errorrrrr)rCrrr final_msgrDrDrEperrors  z Cmd.perrorcCs"|rt|}|j||dddS)aWraps perror, but applies ansi.style_warning by default :param msg: message to print (anything convertible to a str with '{}'.format() is OK) :param end: string appended after the end of the message, default a newline :param apply_style: If True, then ansi.style_warning will be applied to the message text. Set to False in cases where the message text already has the desired style. Defaults to True. FrN)r style_warningr)rCrrrrDrDrEr$s z Cmd.pwarningcCs|jrtdkrddl}|t|tr dt|j |}nd|}|r,t |}|js=d|j vr=d}|t |7}|j||dd dS) aPrint Exception message to sys.stderr. If debug is true, print exception traceback if one exists. :param msg: message or Exception to print :param end: string appended after the end of the message, default a newline :param apply_style: If True, then ansi.style_error will be applied to the message text. Set to False in cases where the message text already has the desired style. Defaults to True. )NNNrNz2EXCEPTION of type '{}' occurred with message: '{}'rrzF To enable full traceback, run the following command: 'set debug true'Fr)rrexc_info traceback print_excrrrrrHrrrrr)rCrrrrrwarningrDrDrEpexcepts   z Cmd.pexceptcCs6|js|jr|j||ddS|j||dddSdS)aLFor printing nonessential feedback. Can be silenced with `quiet`. Inclusion in redirected output is controlled by `feedback_to_output`. :param msg: message to print (anything convertible to a str with '{}'.format() is OK) :param end: string appended after the end of the message, default a newline rFrN)rrrrrrDrDrE pfeedbacks z Cmd.pfeedback)rchoprc CsDt|}|dus |dkrdSz|ddl}d}|jr/|jr/tjds-tj ddur/d}|r|j s| s| stjtjkrKt|}||7}|j}|rW|j}|j|j|d|jd}||d d WdWdS1sywYWdS|j||d WdSty|jrtj|jYdSYdSw) avPrint output using a pager if it would go off screen and stdout isn't currently being redirected. Never uses a pager inside of a script (Python or text) or when output is being redirected or piped or when stdout or stdin are not a fully functional terminal. :param msg: message to print to current stdout (anything convertible to a str with '{}'.format() is OK) :param end: string appended after the end of the message, default a newline :param chop: True -> causes lines longer than the screen width to be chopped (truncated) rather than wrapped - truncated text is still accessible by scrolling with the right & left arrow keys - chopping is ideal for displaying wide tabular data as is done in utilities like pgcli False -> causes lines longer than the screen width to wrap to the next line - wrapping is ideal when you want to keep users from having to use horizontal scrolling WARNING: On Windows, the text always wraps regardless of what the chop argument is set to Nr>rFruTERMT)shellrjutf-8replacer)rY subprocessrjisattyrkrrrrenvironrr in_pyscript in_scriptrrolowerrrr{rrrPopenPIPE communicateencoderrrrr) rCrrrmsg_strrfunctional_terminalr pipe_procrDrDrEppageds4 & z Cmd.ppagedcCshd|_d|_d|_d|_g|_g|_d|_d|_tt j kr%t |j dStt jkr2|jt jj_dSdS)zr Resets tab completion settings Needs to be called each time readline runs tab completion Tr>FN)rrrrrrrrr1r-GNUr8#set_completion_display_matches_hook_display_matches_gnu_readline PYREADLINE_display_matches_pyreadlinerlmode_display_completionsrBrDrDrE_reset_completion_defaults,s  zCmd._reset_completion_defaultslinebegidxendidxc Cs ddl}d}|tj}|d|}|} zt|d|} |s)||kr)| dWn>tyg} z1t| dkrS|rS|d}|dd}|d|}||7}|d}n ggfWYd} ~ SWYd} ~ nd} ~ wwq|j| } dd| D} |r| d dd | d <| | fS) agUsed by tab completion functions to get all tokens through the one being completed. :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :return: A 2 item tuple where the items are **On Success** - tokens: list of unquoted tokens - this is generally the list needed for tab completion functions - raw_tokens: list of tokens with any quotes preserved = this can be used to know if a token was quoted or is missing a closing quote Both lists are guaranteed to have at least 1 item. The last item in both lists is the token being tab completed **On Failure** - Two empty lists rNr>TzNo closing quotationrcSsg|]}t|qSrD)r strip_quotes)r cur_tokenrDrDrErusz-Cmd.tokens_for_completion..) copyrQUOTESr,rrrYrsplit_on_punctuation) rCrrrrunclosed_quote quotes_to_trytmp_line tmp_endidxinitial_tokensex raw_tokenstokensrDrDrEtokens_for_completion@s8         zCmd.tokens_for_completiontext match_against delimitercCszt|||||}|r;d|_tj|}||} d} | r#t| d} |D]} | |} | | } | s4|} |j | q%|S)a Performs tab completion against a list but each match is split on a delimiter and only the portion of the match being tab completed is shown as the completion suggestions. This is useful if you match against strings that are hierarchical in nature and have a common delimiter. An easy way to illustrate this concept is path completion since paths are just directories/files delimited by a slash. If you are tab completing items in /home/user you don't get the following as suggestions: /home/user/file.txt /home/user/program.c /home/user/maps/ /home/user/cmd2.py Instead you are shown: file.txt program.c maps/ cmd2.py For a large set of data, this can be visually more pleasing and easier to search. Another example would be strings formatted with the following syntax: company::department::name In this case the delimiter would be :: and the user could easily narrow down what they are looking for if they were only shown suggestions in the category they are at in the string. :param text: the string prefix we are attempting to match (all matches must begin with it) :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :param match_against: the list being matched against :param delimiter: what delimits each portion of the matches (ex: paths are delimited by a slash) :return: a list of possible tab completions Trr) rbasic_completerrr commonprefixrZrrr)rCrrrrrrmatches common_prefix prefix_tokensdisplay_token_index cur_match match_tokens display_tokenrDrDrEdelimiter_completes"    zCmd.delimiter_complete)all_else flag_dictrc Cs||||\}}|s gSg} |} t|dkr#|d} | |vr#|| } t| tr3t||||| } | St| r>| ||||} | S)a Tab completes based on a particular flag preceding the token being completed. :param text: the string prefix we are attempting to match (all matches must begin with it) :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :param flag_dict: dictionary whose structure is the following: `keys` - flags (ex: -c, --create) that result in tab completion for the next argument in the command line `values` - there are two types of values: 1. iterable list of strings to match against (dictionaries, lists, etc.) 2. function that performs tab completion (ex: path_complete) :param all_else: an optional parameter for tab completing any token that isn't preceded by a flag in flag_dict :return: a list of possible tab completions rrrrrrrcallable) rCrrrrrrr_completions_matchesrflagrDrDrEflag_based_completes  zCmd.flag_based_complete index_dictc Csz||||\}}|s gSg} t|d} | |vr|| } n|} t| tr0t||||| } | St| r;| ||||} | S)aTab completes based on a fixed position in the input string. :param text: the string prefix we are attempting to match (all matches must begin with it) :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :param index_dict: dictionary whose structure is the following: `keys` - 0-based token indexes into command line that determine which tokens perform tab completion `values` - there are two types of values: 1. iterable list of strings to match against (dictionaries, lists, etc.) 2. function that performs tab completion (ex: path_complete) :param all_else: an optional parameter for tab completing any token that isn't at an index in index_dict :return: a list of possible tab completions rr) rCrrrrrrrrrindexrrDrDrEindex_based_completes   zCmd.index_based_complete path_filterrcs.dttffdd }d|t|ks#|t|kr%||tjjkr%dt}d}dds=tjtd} d}nMddg} | D] } | vrMgSqCd} d ry tjjd } | d krf|Stj | } d | tj ntj stjt| } d}d_ t | } d urfd d| D} t| d krtj| drd_d_| jjdd_t| D]+\}}jtj|tj|rr| |tjj7<j|tjj7<q|r|tjjkr|n|tjjfdd| D} rfdd| D} | S)aPerforms completion of local file system paths :param text: the string prefix we are attempting to match (all matches must begin with it) :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :param path_filter: optional filter function that determines if a path belongs in the results this function takes a path as its argument and returns True if the path should be kept in the results :return: a list of possible tab completions ricsd_d_g}tjdr+tj}tj|r)}r$|tjj 7}| ||Sddl }| D] }tj|j rSd|j}|rSrN|tjj 7}| |q3|S)NFrur~)rrrrrrrrisdirseprpwdgetpwallpw_dirpw_name)users expanded_pathuserrcur_pwcur_user)add_trailing_sep_if_dirrCrrDrEcomplete_users"s*          z)Cmd.path_complete..complete_usersFTr>*?rrrNcsg|]}|r|qSrDrD)rcrrDrErz%Cmd.path_complete..rrcg|] }|ddqSr>rrrcur_path) to_replacerDrErcsg|] }|dqS)rrr)expanded_tilde_pathorig_tilde_pathrDrErr)r rYrrrrgetcwdjoinrfindrdirnamerglobrrrsortrr enumeraterrbasename)rCrrrrrrcwd cwd_added search_str wildcardswildcard sep_indexrrrrD)rrrrrCrrrE path_completesd&(       zCmd.path_complete)complete_blankr cCsD|s|sgS|dstjj|vrt|S|j||||dddS)aPerforms completion of executables either in a user's path or a given path :param text: the string prefix we are attempting to match (all matches must begin with it) :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :param complete_blank: If True, then a blank will complete all shell commands in a user's path. If False, then no completion is performed. Defaults to False to match Bash shell behavior. :return: a list of possible tab completions rcSstj|p t|tjSrN)rrraccessX_OK)rrDrDrErrz(Cmd.shell_cmd_complete..r)rrrrrget_exes_in_pathr )rCrrrrr rDrDrEshell_cmd_completes   zCmd.shell_cmd_completecompfunccCs||||\}}|s gSt|dkrd}d} d} d} d} d} |D]I}|tjvrMd}|tjkr=| tjkr8gSd} d} n+| tjvsD| rHgSd} d} n|jrhd} d} | tjkr\d} n | sf| tjtjfvrhd} |} q!| ru|||||S| r| ||||S|rgS|||||S)aCalled by complete() as the first tab completion function for all commands It determines if it should tab complete for redirection (|, >, >>) or use the completer function for the current command :param text: the string prefix we are attempting to match (all matches must begin with it) :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :param compfunc: the completer function for the current command this will be called if we aren't completing for redirection :return: a list of possible tab completions rFNT) rrrREDIRECTION_TOKENSREDIRECTION_PIPErbREDIRECTION_OUTPUTREDIRECTION_APPENDrr )rCrrrrrrrhas_redirectionin_pipe in_file_redirdo_shell_completiondo_path_completion prior_tokenrrDrDrE_redirect_completesJ     zCmd._redirect_completematches_to_displaycsBttjkrdn ttjkrdn|dfSfdd|DtfS)a}Adds padding to the matches being displayed as tab completion suggestions. The default padding of readline/pyreadine is small and not visually appealing especially if matches have spaces. It appears very squished together. :param matches_to_display: the matches being padded :return: the padded matches and length of padding that was added z z rcsg|]}|qSrDrDrrpaddingrDrEr!rz/Cmd._pad_matches_to_display..)r1r-rrr)rrDrrE_pad_matches_to_display s  zCmd._pad_matches_to_displaycCsBd}|jr|jr|d|j7}|jr|s|d7}|d|j7}|S)zYBuild completion metadata string which can contain a hint and CompletionItem table headerr>r~)rrr)rCmetadatarDrDrE!_build_completion_metadata_string#s z%Cmd._build_completion_metadata_string substitutionrlongest_match_lengthc Csttjkrh|jr|j}d}|D] }t|}||kr|}qn|}||\}}||7}t|dd}dd|D} tj dt | d} || d<| | dd<d| d<t j |t| t | |tdSdS) ayPrints a match list using GNU readline's rl_display_match_list() This exists to print self.display_matches if it has data. Otherwise matches prints. :param substitution: the substitution written to the command line :param matches: the tab completion matches to display :param longest_match_length: longest printed length of the matches rrencodingcSsg|]}t|ddqS)rr$)bytesrrDrDrErSrz5Cmd._display_matches_gnu_readline..rrN)r1r-rrrstyle_aware_wcswidthrr&ctypesc_char_prrrkrr!r9rl_display_match_listr7) rCr"rr#rr cur_lengthpadding_lengthencoded_substitutionencoded_matches strings_arrayrDrDrEr3s.     z!Cmd._display_matches_gnu_readlinecCsNttjkr%|jr |j}n|}||\}}tjjj | t |dSdS)zPrints a match list using pyreadline's _display_completions() This exists to print self.display_matches if it has data. Otherwise matches prints. :param matches: the tab completion matches to display N) r1r-rrrr8rrconsolerr!orig_pyreadline_display)rCrrrrDrDrEris  zCmd._display_matches_pyreadlineshortcut_to_restorecs@d|j|}|j}||jvr|j|nd}|j} t|t|} | d| 7} t| t|krBt| t|} || 7}|| 7}| }||||\} } t| dkrUdSd| d}|r|dtj vr|d|d| | d}||kr||||}|}||j vr|j }nO|| vrt|tj|d}|dur||}t|tjd}|dur|durddl}|j|j|t|tj|d}n|j}n|jr|t|vr|j }n|j}|||||||_|jrt|j|_t|j|_|jsddl}||j|_sbd}tj !|j}|j"r3tj !|j}d|vs0|r2t#d d |jDr2d }n|rCt#d d |jDrCd }|rat#d d |jDrTdndfdd|jD|_nrpfdd|jD|_r~fdd|jD|_t|jdkr|j$rr|jd7<dSdSdSdSdS)a3 Helper function for complete() that performs command-specific tab completion :param text: the string prefix we are attempting to match (all matches must begin with it) :param line: the current input line with leading whitespace removed :param begidx: the beginning index of the prefix text :param endidx: the ending index of the prefix text :param shortcut_to_restore: if not blank, then this shortcut was removed from text and needs to be prepended to all the matches r>N rrr) argparserpreserve_quotescmd_setFcs|]}d|vVqdSr3NrDrmatchrDrDrE z.Cmd._completion_for_command..Tcsr7r8rDr9rDrDrEr; r<csr7)"NrDr9rDrDrEr;r<'r=cg|]}|qSrDrDr9)rrDrErrz/Cmd._completion_for_command..crrrr9)text_to_removerDrErrcr?rDrDr9)r2rDrErr)%rparse_command_onlyrrcommand_and_argsrrstriprrrrfindrr rr rr8r9 functoolspartial_complete_argparse_commandCMD_ATTR_PRESERVE_QUOTEScompletedefaultr}rr rrremove_duplicatesrrrrrranyr)rCrrrrr2 statementrr6 expanded_line rstripped_lendiffrrraw_completion_token actual_begidxrfuncr4rEr add_quoterdisplay_prefixrD)r2r@rrE_completion_for_commands         6zCmd._completion_for_commandstatec Cs8z|dkr||jr(|j}|t}t|t}t|t}n"t}|}t|t|}t t|d}t t|d}d} |dkrp|j j D]\} } | | ro| } |t| d}|t| 7}nqT|dkr~| ||||| n|} t||||| |_t|jdkr|t|kr|jr|jdd7<|js|jj|jd|jj|jdd|_z|j|WWStyYWdSwty} z#t| }|r| jrt|}ttjd|dt WYd} ~ dSd} ~ wt!y}z|"|#|t WYd}~dSd}~ww) uOverride of cmd2's complete method which returns the next possible completion for 'text' This completer function is called by readline as complete(text, state), for state in 0, 1, 2, …, until it returns a non-string value. It should return the next possible completion starting with text. Since readline suppresses any exception raised in completer functions, they can be difficult to debug. Therefore this function wraps the actual tab completion logic and prints to stderr any exception that occurs before returning control to readline. :param text: the current word that user is typing :param state: non-negative integer :return: the next possible completion for text or None rr>Nrr3rTr~)$rrrlstripr8get_line_bufferr get_begidx get_endidxmaxrrerrU/_get_commands_aliases_and_macros_for_completionrrrrrrrr IndexErrorr4rYrrrrrrkr7rrr)rCrrVlstripped_previousrrr orig_line num_strippedr2shortcutrrrerr_strerDrDrEcomplete"sj         z Cmd.completer6r4r5r6c CsJddlm}|||} ||||\} } |r| n| } | j| |||||dS)z)Completion function for argparse commandsrArgparseCompleterre)argparse_completerrgrcomplete_command) rCrrrrr4r5r6rgr?rrtokens_to_parserDrDrErGs   zCmd._complete_argparse_commandcCs |jduS)z'Return whether a text script is runningN)_current_script_dirrBrDrDrErs z Cmd.in_scriptcC|jS)z$Return whether a pyscript is running)rrBrDrDrErszCmd.in_pyscriptcCs|jjS)zFRead-only property to access the aliases stored in the StatementParser)rr#rBrDrDrEr#sz Cmd.aliasescCst|S)zZReturn an alphabetized list of names comprising the attributes of the cmd2 class instance.)dirrBrDrDrE get_namessz Cmd.get_namescfddDS)zReturn a list of all commandsc8g|]}|tjrtt|r|ttjdqSrN)rrrrr rrrjrBrDrEr   z(Cmd.get_all_commands..rnrBrDrBrErrzzCmd.get_all_commandscro)z?Return a list of commands that have not been hidden or disabledc$g|]}|jvr|jvr|qSrDrr)rrrBrDrErz,Cmd.get_visible_commands..)rrBrDrBrEget_visible_commandsrzzCmd.get_visible_commandscfddjDS)z@Return list of current alias names and values as CompletionItemscsg|] }t|j|qSrD)rr#rcur_keyrBrDrErsz3Cmd._get_alias_completion_items..)r#rBrDrBrE_get_alias_completion_itemszCmd._get_alias_completion_itemscrx)z@Return list of current macro names and values as CompletionItemscg|] }t|j|jqSrD)rrvalueryrBrDrErrz3Cmd._get_macro_completion_items..)rrBrDrBrE_get_macro_completion_itemsr|zCmd._get_macro_completion_itemscrx)zIReturn list of current settable names and descriptions as CompletionItemscr}rD)rrrPryrBrDrErrz6Cmd._get_settable_completion_items..)rrBrDrBrE_get_settable_completion_itemsr|z"Cmd._get_settable_completion_itemscCs0t|}t|j}t|j}t||B|BS)zIReturn a list of visible commands, aliases, and macros for tab completion)setrwr#rlist)rCvisible_commands alias_names macro_namesrDrDrEr\s   z3Cmd._get_commands_aliases_and_macros_for_completioncs(fddD}fdd|DS)zReturn a list of help topicscrprN)rrrrr rrqrBrDrErrrz'Cmd.get_help_topics..crtrDru)rtopicrBrDrErrvrs)rC all_topicsrDrBrEget_help_topicsszCmd.get_help_topicssignumcCs&|jdur |j|jstddS)zSignal handler for SIGINTs which typically come from Ctrl-C events. If you need custom SIGINT behavior, then override this function. :param signum: signal number :param frame: required param for signal handlers NzGot a keyboard interrupt)r send_sigintrKeyboardInterrupt)rCrframerDrDrEsigint_handlers  zCmd.sigint_handlerrLcC|S)aVHook method executed just before the command is executed by :meth:`~cmd2.Cmd.onecmd` and after adding it to history. :param statement: subclass of str which also contains the parsed input :return: a potentially modified version of the input Statement object See :meth:`~cmd2.Cmd.register_postparsing_hook` and :meth:`~cmd2.Cmd.register_precmd_hook` for more robust ways to run hooks before the command is executed. See :ref:`features/hooks:Postparsing Hooks` and :ref:`features/hooks:Precommand Hooks` for more information. rD)rCrLrDrDrEprecmds z Cmd.precmdstopcCr)a5Hook method executed just after a command is executed by :meth:`~cmd2.Cmd.onecmd`. :param stop: return `True` to request the command loop terminate :param statement: subclass of str which also contains the parsed input See :meth:`~cmd2.Cmd.register_postcmd_hook` and :meth:`~cmd2.Cmd.register_cmdfinalization_hook` for more robust ways to run hooks after the command is executed. See :ref:`features/hooks:Postcommand Hooks` and :ref:`features/hooks:Command Finalization Hooks` for more information. rD)rCrrLrDrDrEpostcmds z Cmd.postcmdcCdS)a6Hook method executed once when the :meth:`~.cmd2.Cmd.cmdloop()` method is called. See :meth:`~cmd2.Cmd.register_preloop_hook` for a more robust way to run hooks before the command loop begins. See :ref:`features/hooks:Application Lifecycle Hooks` for more information. NrDrBrDrDrEpreloopz Cmd.preloopcCr)aBHook method executed once when the :meth:`~.cmd2.Cmd.cmdloop()` method is about to return. See :meth:`~cmd2.Cmd.register_postloop_hook` for a more robust way to run hooks after the command loop completes. See :ref:`features/hooks:Application Lifecycle Hooks` for more information. NrDrBrDrDrEpostlooprz Cmd.postloopcCs|j|}|j|j|jfS)arParse the line into a command name and a string containing the arguments. NOTE: This is an override of a parent class method. It is only used by other parent class methods. Different from the parent class method, this ignores self.identchars. :param line: line read by readline :return: tuple containing (command, args, line) )rrArargsrB)rCrrLrDrDrE parselines z Cmd.parseline)add_to_historyraise_keyboard_interruptpy_bridge_callrrrc Csddl}d}d}zz||}td|}|jD] } | |}|jr$nq|j}|j}|r/td} z|j|r| |WYd}~dSWYd}~qd}~wwdS)a> Used when commands are being run in an automated fashion like text scripts or history replays. The prompt and command line for each command will be printed if echo is True. :param cmds: commands to run :param add_to_history: If True, then add these commands to history. Defaults to True. :param stop_on_keyboard_interrupt: stop command loop if Ctrl-C is pressed instead of just moving to the next command. Defaults to True. :return: True if running of commands should stop r)rrTNF) rr'rawrrrr|rrr)rCrrrrrcrDrDrEruncmds_plus_hookss(    zCmd.runcmds_plus_hooksc Cs  z|j|}|jr|jrWnn|jsWniWnty)|j|}|js'YnwzNz"d|_|d|_||j }|dkrEd}| |d |j|}Wn&t ys}z|j rZ|| d|jd}WYd}~Wd|_nd}~wwWd|_nd|_wq|jst|S) aVKeep accepting lines of input until the command is complete. There is some pretty hacky code here to handle some quirks of self._read_command_line(). It returns a literal 'eof' if the input pipe runs out. We can't refactor it because we need to retain backwards compatibility with the standard library version of cmd. :param line: the line being parsed :return: the completed Statement :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation) :raises: EmptyStatement when the resulting Statement is blank Tr~rmr^Cr>NF)rparsemultiline_command terminatorr rArr_read_command_linerrrrr~rr#)rCrrLnextlinerrDrDrE_complete_statementsJ             .zCmd._complete_statementc Csg}d} ||}|dur|j}|j|jvr0|j|vr0||j||}|dur/tnnq||jkrNt|j ||j|j |j |j |j |j|j|jd }|S)aq Parse the user's input line and convert it to a Statement, ensuring that all macros are also resolved :param line: the line being parsed :return: parsed command line as a Statement :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation) :raises: EmptyStatement when the resulting Statement is blank NT) rrarg_listrrsuffixpipe_tooutput output_to)rrrrkeysr_resolve_macror#r*rrrrrrrr)rCr used_macrosr_rLrDrDrErs6      zCmd._input_line_to_statementc Cs |j|jvrtd|j|j|j}t|j|jkr+|d|j|jdS|j }t |jdddd}|D]4}|j rNd|j d }d |j d }nd |j d }|j t|j }|j|d d }|d||d }q:|j|jdD]}|d|7}qw||jS)z Resolve a macro and return the resulting string :param statement: the parsed statement from the command line :return: the resolved macro or None on error z{} is not a macroz.The macro '{}' expects at least {} argument(s)NcSrlrN) start_index)marDrDrEr9 sz$Cmd._resolve_macro..T)rreversez{{z}}{}r)maxsplitrr3)rrrrmrrrminimum_arg_countrr~sorted is_escaped number_strargvrtrsplit post_command) rCrLmacroresolvedreverse_arg_listargr replacementpartsrDrDrEr s0  zCmd._resolve_macroc Cs*ddl}ddl}t|jtj|j|j}d}|jsn|j rt \}}| |d}| |d} t } tjdkr=|j| d<nd| d<|j|j f|t|jtjrQ|jn|jttjtjr]|jntjdd | } z| d Wn |jywYnw| jdur|| td | jd|_t| |jtj}| t_|_nl|jr ddl} |js|j std |jr|jt!j"krd nd} z t t#|j| dd} Wnt$y}ztd|d}~wwd|_| t_|_n"| j%dd} d|_| t_|_|jt!j"kr |j&t'|j(||_|j|_|S)a*Set up a command's output redirection for >, >>, and |. :param statement: a parsed statement from the user :return: A bool telling if an error occurred and a utils.RedirectionSavedState object :raises: RedirectionError if an error occurs trying to pipe or redirect rNrwwin32 creationflagsTstart_new_session)rjrkrrg?z9Pipe process exited with code {} before command could runzRCannot redirect to paste buffer; missing 'pyperclip' and/or pyperclip dependenciesar)r bufferingzFailed to redirect because - {}zw+)r))iorrRedirectionSavedStaterkrrrrbrrpipeopenrrCREATE_NEW_PROCESS_GROUPrrStdSimrrwaitTimeoutExpired returncodecloser$r redirecting ProcReaderrtempfilerrrrrOSError TemporaryFilerrflush)rCrLrrrcmd_pipe_proc_readerread_fdwrite_fd subproc_stdin new_stdoutkwargsrrrrrDrDrErM s~              zCmd._redirect_outputsaved_redir_statecCs|jr9|jr|js|jdt|jz|jWn ty&Ynw|j |_|j t _|j dur9|j |j|_ |j|_dS)zHandles restoring state after output redirection :param statement: Statement object which contains the parsed input from the user :param saved_redir_state: contains information needed to restore state data rN)rrrrkseekrreadrrsaved_self_stdoutsaved_sys_stdoutrrrsaved_pipe_proc_readersaved_redirectingr)rCrLrrDrDrEr s      zCmd._restore_outputcCs||}|r t||SdS)z Get the function for a command :param command: the name of the command :Example: >>> helpfunc = self.cmd_func('help') helpfunc now contains a reference to the ``do_help`` method N)_cmd_func_namer )rCr func_namerDrDrEr8 s  z Cmd.cmd_funccCs"tj|}tt||dr|SdS)zGet the method name associated with a given command. :param command: command to look up method name which implements it :return: method name which implements the given command Nr>)rrrr )rCrtargetrDrDrEr s zCmd._cmd_func_namercCspt|ts ||}||j}|r+|j|jvr&|j|jvr&|r&|j|||}n| |}|dur6d}|S)a This executes the actual do_* method for a command. If the command provided doesn't exist, then it executes default() instead. :param statement: intended to be a Statement instance parsed command from the input stream, alternative acceptance of a str is present only for backward compatibility with cmd :param add_to_history: If True, then add this command to history. Defaults to True. :return: a flag indicating whether the interpretation of commands should stop NF) rr*rr8rrrrQrdefault)rCrLrrRrrDrDrEr s      z Cmd.onecmdcCsH|jrd|jvr|j|||jS|j|j}|j |dddS)zExecuted when the command given isn't a recognized command implemented by a do_* method. :param statement: Statement object with parsed input rFrN) r}rrQrdo_shellrBrrrr)rCrLerr_msgrDrDrEr s    z Cmd.defaultallow_completionr|rcsddfdd}fdd}jrtjrwz:t|}j |s*|Wdn1s4wYt|}Wj |sG|Wdn1sQwYnhj|sg|WdwWdw1sqwYwt}jrtj d ||n7jrj |dd j j }t|d krd }nj }t|rjr d ||nd }|d S)a Read input from appropriate stdin value. Also allows you to disable tab completion while input is being read. :param prompt: prompt to display to user :param allow_completion: if True, then tab completion of commands is enabled. This generally should be set to False unless reading the command line. Defaults to False. :return: the line read from stdin with all trailing new lines removed :raises: any exceptions raised by input() and stdin.readline() FNcs2rsttddddSdSdS)z(Turn off completion while entering inputc_sdSrNrDrrrDrDrEr. z.disable_completion..TN)ryr8 get_completer set_completerrDcompletion_disabledorig_completerrCrDrEdisable_completion' s z*Cmd.read_input..disable_completioncs&rrtddSdSdS)z3Restore tab completion when finished entering inputFN)ryr8r rDr rDrEenable_completion1 s  z)Cmd.read_input..enable_completion{}{} r>rrrmrz )rwrrjrr/rinputrrkrrrrr8rrC)rCr|rrr safe_promptrrDr rE read_input sX           zCmd.read_inputcCsnz0zz|jWn tyYnw|j|ddWW|jSty0YW|jdSw|jw)a Read command line from appropriate stdin :param prompt: prompt to display to user :return: command line text of 'eof' if an EOFError was caught :raises: whatever exceptions are raised by input() except for EOFError Trrm)rrelease RuntimeErrorracquireEOFError)rCr|rDrDrErf s    zCmd._read_command_linecCst}|rPttjkrtttjj |_ dt_ t |_ t |jd}|dtj7}|dtj7}|d|jj7}t |_t |t |jd|S)zx Set up readline with cmd2-specific settings :return: Class containing saved readline settings Nz r>z : complete)r=ryr1r-rr(castr:c_void_pr~rAr8r r?r rdrrrREDIRECTION_CHARSrrdget_completer_delimsr@set_completer_delimsparse_and_bindrh)rCrOcompleter_delimsrDrDrE_set_up_cmd2_readline| s     zCmd._set_up_cmd2_readlinerOcCs`|r,t|jt|jttjkr t d|j t _ dSttj kr.ttjj_dSdSdS)zu Restore saved readline settings :param readline_settings: the readline settings to restore N)ryr8r r?rr@r1r-rrrAr:r~rr1rrr)rCrOrDrDrE_restore_readline s       zCmd._restore_readlinecCsBd}zz|j |}Wdn1swY||j}|j|sUz||j}WntyM}z|jr<|| dd}WYd}~nd}~ww| |}|r'W|j|durk| |WddSWddS1svwYdS|j|dur| |WdwWdw1swYw)zRepeatedly issue a prompt, accept input, parse an initial prefix off the received input, and dispatch to action methods, passing them the remainder of the line as argument. This serves the same role as cmd.cmdloop(). Nrr>) rrrrclearrr|rr~rrr )rCsaved_readline_settingsrrrrDrDrE_cmdloop s>      *  z Cmd._cmdloopz[Manage aliases An alias is a command that enables replacement of a word by another string.zSee also: macro)rPrQ subcommand SUBCOMMAND)destmetavar)r5rcC|j}||dS)zManage aliasesN cmd2_handlerrrCrhandlerrDrDrEdo_alias   z Cmd.do_aliasCreate or overwrite an aliasa{Notes: If you want to use redirection, pipes, or terminators in the value of the alias, then quote them. Since aliases are resolved during parsing, tab completion will function as it would for the actual command the alias resolves to. Examples: alias create ls !ls -lF alias create show_log !cat "log file.txt" alias create save_results print_results ">" out.txt z-sz--silentrqz@do not print message confirming alias was created or overwrittenrrzname of this alias)rtzwhat the alias resolves to)rtchoices_method command_argszarguments to pass to command)nargsrtcompleter_methodaliascreatecCs|j|j\}}|s|d|dS|j|vr#|ddS|j|jvr0|ddStj}| |jj t |j ||j}|j rQ|dd|j 7}|jsh|j|jvr\dnd}|d|j|||j|j<dS) r/zInvalid alias name: {}Nz,Alias cannot have the same name as a commandz*Alias cannot have the same name as a macror3 overwrittencreatedz Alias '{}' {})rrrjrrrrrrrrdrunquote_specific_tokensr1rrsilentr#r)rCrrrtokens_to_unquoter~resultrDrDrE _alias_create s(   zCmd._alias_createzdelete aliasesz8Delete specified aliases or all aliases if --all is used)rPz-az--allzdelete all aliasesnameszalias(es) to deleteValue)r2rtr0descriptive_headerdeletecC||jr|j|ddS|js|ddSt|jD]}||jvr3|j|=|d|q|d|qdS)zDelete aliaseszAll aliases deletedz/Either --all or alias name(s) must be specifiedzAlias '{}' deletedzAlias '{}' does not existN) allr#r!rr=rrrJrrCrcur_namerDrDrE _alias_delete1   zCmd._alias_deletez list aliaseszList specified aliases in a reusable form that can be saved to a startup script to preserve aliases across sessions Without arguments, all aliases will be listed.z-wz --with_silentz~include --silent flag with listed aliases Use this option when saving to a startup script that should silently create aliases.zalias(es) to listrc Csd}|jr |d7}tj}||jj|jrt|j}nt |j |j d}g}|D];}||j vr6| |q)t |j |}|d}|dd}t|||} |rZ| dd|7} |d||| q)|D] }|d |qgdS) z3List some or all aliases as 'alias create' commandsz alias create --silentrrrNr3{} {} {}zAlias '{}' not found) with_silentrrrrrdr=rrJrr#rrr,quote_specific_tokensrrrr rCr create_cmdtokens_to_quoteto_list not_foundrjrrrrDrDrE _alias_listP s0    zCmd._alias_listzXManage macros A macro is similar to an alias, but it can contain argument placeholders.zSee also: aliascCr()z Manage macrosNr)r+rDrDrEdo_macro r.z Cmd.do_macrozcreate or overwrite a macroCreate or overwrite a macroaA macro is similar to an alias, but it can contain argument placeholders. Arguments are expressed when creating a macro using {#} notation where {1} means the first argument. The following creates a macro called my_macro that expects two arguments: macro create my_macro make_dinner --meat {1} --veggie {2} When the macro is called, the provided arguments are resolved and the assembled command is run. For example: my_macro beef broccoli ---> make_dinner --meat beef --veggie broccoli Notes: To use the literal string {1} in your command, escape it this way: {{1}}. Extra arguments passed to a macro are appended to resolved command. An argument number can be repeated in a macro. In the following example the first argument will populate both {1} instances. macro create ft file_taxes -p {1} -q {2} -r {1} To quote an argument in the resolved command, quote it during creation. macro create backup !cp "{1}" "{1}.orig" If you want to use redirection, pipes, or terminators in the value of the macro, then quote them. macro create show_results print_results -type {1} "|" less Because macros do not resolve until after hitting Enter, tab completion will only complete paths while typing a macro.z@do not print message confirming macro was created or overwrittenzname of this macrozwhat the macro resolves torcCs|j|j\}}|s|d|dS|j|vr#|ddS|j|jvr0|ddStj}| |jj t |j ||j}|j rQ|dd|j 7}g}ttj|}d}t} z8|} ttj| d} t| } | dkr|d WdS| | | |kr| }|t| | d d Wn tyYnwq`t| |kr|d |dSttj|} z| } ttj| d} |t| | dd Wn tyYnwq|j s|j|j!vrd nd}|"d|j|t#|j|||d|j!|j<dS)rRzInvalid macro name: {}Nz,Macro cannot have the same name as a commandz+Macro cannot have the same name as an aliasr3rTrz'Argument numbers must be greater than 0F)rrrzINot all numbers between 1 and {} are present in the argument placeholdersr6r7z Macro '{}' {})rjr~rr)$rrrjrrrr#rrrrdrr8r1rrrefinditerr)macro_normal_arg_patternr__next__findall digit_patterngrouprtaddrstart StopIterationrmacro_escaped_arg_patternr9rrr()rCrrrr:r~rnormal_matches max_arg_numarg_numsr cur_num_strcur_numescaped_matchesr;rDrDrE _macro_create sp         zCmd._macro_createz delete macrosz6Delete specified macros or all macros if --all is usedzdelete all macroszmacro(s) to deletecCrA)z Delete macroszAll macros deletedz/Either --all or macro name(s) must be specifiedzMacro '{}' deletedzMacro '{}' does not existN) rBrr!rr=rrrJrrCrDrDrE _macro_delete rFzCmd._macro_deletez list macroszList specified macros in a reusable form that can be saved to a startup script to preserve macros across sessions Without arguments, all macros will be listed.z|include --silent flag with listed macros Use this option when saving to a startup script that should silently create macros.zmacro(s) to listc Csd}|jr |d7}tj}||jj|jrt|j}nt |j |j d}g}|D]<}||j vr6| |q)t |j |j}|d}|dd}t|||} |r[| dd|7} |d||| q)|D] }|d |qhdS) z2List some or all macros as 'macro create' commandsz macro createrGrrrNr3rHzMacro '{}' not found)rIrrrrrdr=rrJrrrrr,r~rJrrrrrKrDrDrE _macro_list3 s0    zCmd._macro_listcCs6t|}t|}t||B}t|||||S)z&Completes the command argument of help)rrrwrrr)rCrrrrtopicsr strs_to_matchrDrDrEcomplete_help_commandW s   zCmd.complete_help_command arg_tokensc Csv|dd}|s gS||}t|tjd}|dus|dur gS|g|d} ddlm} | ||} | | ||||S)z*Completes the subcommands argument of helprrN subcommandsrrf)r8r rr9rhrgcomplete_subcommand_help) rCrrrrrjrrRr4rrgr?rDrDrEcomplete_help_subcommands` s    zCmd.complete_help_subcommandsGList available commands or provide detailed help for a specific commandz-vz --verbosez6print a list of all commands with descriptions of eachzcommand to retrieve help forrkz"subcommand(s) to retrieve help for complete_helpc s|jr|jr||jdS||j}t|tj|jd}t|tjd}|durK|durKddlm }|||}|jg|j }|j | |dddS|durXt |jdS|durk|jdurk| t|dS|j|j}|j|dddS)rnNrrfr>rFr)rverbose _help_menur8r rrr9rhrgrkr format_helpr|do_helprKpydocgetdocrrr) rCrrR help_funcr4rgr?rrrrDrErs s    z Cmd.do_helprpcCs|\}}}}t|dkr"|dt|j||j||n5|dt|j|jdt|jddt| |j dD] }|||||qC||j ||| |j |dd| |j|dddS) z7Show a list of commands which help can be displayed forrrz rrPN)_build_command_inforrrrY doc_leader _print_topicsrrrrr print_topics misc_header undoc_header)rCrp cmds_catscmds_doc cmds_undoc help_topicscategoryrDrDrErq s zCmd._help_menuc Cst||jd}t||jd}g}g}i}|D]D}||}d}||vr4||t|tjs4d}t|tj rNt |tj } | | g||  |q|j sS|rY| |q| |q||||fS)NrFT)rrrrwr8rrrr9rr  setdefaultrrK) rCrrrrrrrR has_help_funcrrDrDrEry s(          zCmd._build_command_infoheaderc Csddl}|r|s|||dddS|jdt|d}|D] }t|}||kr.|}q!|d7}|dkr9d}|jrI|jdjd |jdd | }|D]}| |} t | t j s||vrt|t j|} |} t| |j} z | |_| W| |_n| |_wWdn1swY| } n| j} | sd g}n'g}d }| D]}|}|d r|rnq|r||d }q|rnq|D]}|jdj|||dd }qqO|jddSdS)zXCustomized version of print_topics that can switch between verbose or traditional outputrNrwrx{} z{:{ruler}<{width}} r>)rulerwidthF:Tz{: <{col_width}}{doc} ) col_widthdocr~)rr|rkrrrYrr'rrr8rrr9r rStringIOrgetvaluerK splitlinesstriprr)rCrrrprwidestrrrgr8rvr; stdout_origr doc_block found_firstdoc_line stripped_linerDrDrEr{ sp        zCmd._print_topicsList available shortcutsrcs@tjjfddd}ddd|D}d|dS) rcs|dS)Nr)r)xrBrDrEr* sz"Cmd.do_shortcuts..rr~css$|] }d|d|dVqdS)z{}: {}rrN)r)rscrDrDrEr;+ s"z#Cmd.do_shortcuts..z Shortcuts for other commands: {}N)rrrerrr)rCrsorted_shortcutsr;rDrBrE do_shortcuts& szCmd.do_shortcutsCalled when -D is pressedcCr)rTrDrCrrDrDrEdo_eof0 z Cmd.do_eofExit this applicationcCr)rTrDrrDrDrEdo_quit8 rz Cmd.do_quit Your choice? optsc Cs|}t|trtt||}g}|D]0}t|tr%|||fqz ||d|dfWqtyF||d|dfYqwt|D]\}\}}|d|d|fqK z| |} Wn!t ytd} |Ynt y} z|d| d} ~ ww| sq]t t jkrt} | dkrt| dzt| } | dkrt|| ddWSttfy|d| t|Ynwq^) aPresents a numbered menu to the user. Modeled after the bash shell's SELECT. Returns the item chosen. Argument ``opts`` can be: | a single string -> will be split into one-word options | a list of strings -> will be offered as options | a list of tuples -> interpreted as (value, text), so that the return value can differ from the text advertised to the user rrz %2d. %sTr>rNz:{!r} isn't a valid choice. Pick a number between 1 and {}:)rrYrziprZrr]rrrrrr1r-rxr8get_current_history_lengthremove_history_itemrtrrr) rCrr| local_opts fulloptionsoptidxrrresponserhlenrIrDrDrEselect> sT        z Cmd.selectc Cs|dd}z|j|}Wn tyt|dwttjgd}d} |j| | |j|j|j |j |j |j dddl m} | ||} ||||\} } | | ||||S) z#Completes the value argument of setparamrrlrMr~)r'rtr2choices_functionr0rXr3rrf)rrmr4rrYset_parser_parentrrPr2rr0rXr3rhrgrri)rCrrrrrjrrisettable_parserarg_namergr?rrrDrDrEcomplete_set_valuet s&      zCmd.complete_set_valuezSet a settable parameter or show current settings of parameters Call without arguments for a list of all settable parameters with their values. Call with just param to view that parameter's value.)rPrXz.include description of parameters when viewingrzparameter to set or view Descriptionrr~znew value for settable)r2rtr3suppress_tab_hintc Cs|js |ddS|jrz|j|j}Wnty(|d|jYdSw|jrt|j|_zt ||j}t ||j| |jt ||j}Wnt yk}zd|j|}||WYd}~dSd}~ww| d|j||||kr|jr||j||dS|jg}nt|j}d}t} |D]} d| t || | | <t|t| | }qt| |jdD]!} | | } |jr| d tj| |d |j| jq| | qdS) z?Set a settable parameter or show current settings of parametersz There are no settable parametersNzAParameter '{}' not supported (type 'set' for list of parameters).zError setting {}: {}z{} - was: {!r} now: {!r}rz{}: {!r}rz{} # {})r)rr$rrmrrr~rrr r%val_typerr onchange_cbrrrr[rr'rrrp align_leftrP) rCrri orig_value new_valuercrto_showmax_lenresultsr result_strrDrDrEdo_set sR       z Cmd.do_set(Execute a command as if at the OS promptzthe command to run)rtr3cCsddl}|jg|j}t|d|}|j9|j|t|j tj r&|j n|j tt j tj r2|j nt j dd}t||j t j }||j|_WddS1sTwYdS)rrNr3T)rkrr)rrr1rexpand_user_in_tokensrrrrrkrrrrrrrr)rCrrrexpanded_commandr proc_readerrDrDrEr s   "z Cmd.do_shellc CsDgd}|D]}ztj|=WqtyYqwtjt_tjt_dS)a Resets the dynamic objects in the sys module that the py and ipy consoles fight over. When a Python console starts it adopts certain display settings if they've already been set. If an ipy console has previously been run, then py uses its settings and ends up looking like an ipy console in terms of prompt and exception text. This method forces the Python console to create its own display settings since they won't exist. IPython does not have this problem since it always overwrites the display settings when it is run. Therefore this method only needs to be called before creating a Python console. )ps1ps2ps3N)r__dict__rm__displayhook__ displayhook__excepthook__ excepthook) attributescur_attrrDrDrE_reset_py_display s    zCmd._reset_py_displayinterpcCsJt}ttjkrtdtdD] }|jt |qt |j D]}t |q$| rttjkrZtttjj|j_tt_dtjvrZdtjvrRtjd|_tjdtjd<t|j_ttttjkrptdn ttjkrzt tj!j"_#t$|j_%|&d|&d|&d|'tj(|_)|j(t_(tj*|_+|j*t_*|S)zy Set up interactive Python shell environment :return: Class containing saved up cmd2 environment r gnureadliner8Nz!from rlcompleter import Completerzimport readlinez4readline.set_completer(Completer(locals()).complete)),rMr1r-rxranger8rrQrget_history_item clear_historyr add_historyryrr(rr:rr~rOrAorig_rl_basic_quotesrmodulesrPrr@rorig_rl_delimsrrr1rrrr r?runcoderrkrRrjrS)rCrcmd2_enviitemrDrDrE_set_up_py_shell_envsF                 zCmd._set_up_py_shell_envrcCs|jt_|jt_ttjkrj|j t dt dD] }|j t |qt |jD]}t |q.|rlt |jjt |jjttjkrn|jjt_dtjvrp|jdurbtjd=dS|jtjd<dSdSdSdSdS)z Restore cmd2 environment after exiting an interactive Python shell :param cmd2_env: the environment settings to restore rrNr8)rRrrkrSrjr1r-rxrr!rr8rrrrrQrryr rOr?rr@rrAr:r~rrP)rCrrrrDrDrE_restore_cmd2_envUs,          zCmd._restore_cmd2_envaInvoke Python command or shell Note that, when invoking a command directly from the command line, this shell has limited ability to parse Python statements into tokens. In particular, there may be problems with whitespace and quotes depending on their placement. If you see strange parsing behavior, it's best to just open the Python shell by providing no arguments to py and run more complex statements there.zcommand to run)r2rt remainderzremainder of commandpyscriptrcCshdd}ddlm}||}d}|r|ddSzwd|_d}t|j}|||j<||d <||d <|jr;||d <|durt j |} zt |  } | }Wdn1sYwYWn;ty} z/|d | | WYd} ~ W|j|dur|t_ d |_WddS1swYdSd} ~ wwd|d<| |d<ttj }tj dt j t j | nd|d<|jr|j}|jr|dd|j7}d|_t|d} |rz| |WntyYnwd} d|j}d}zTz)|j || }Wdn 1s wY| jdtj tj!| |dWn ty(YnwW|j|dur8|"|Wdn 1sCwYn&|j|dur^|"|WdwWdw1siwYwW|j|dur||t_ d |_Wd|j#S1swY|j#S|j|dur|t_ d |_Wdw1swYw)a Enter an interactive Python shell :param args: Namespace of args on the command line :param pyscript: optional path to a pyscript file to run. This is intended only to be used by run_pyscript after it sets up sys.argv for the script. If populated, this takes precedence over all other arguments. (Defaults to None) :return: True if running of commands should stop cSst)zNFunction callable from the interactive Python console to exit that environment)r"rDrDrDrEpy_quitszCmd.do_py..py_quitrPyBridgeN=Recursively entering interactive Python shells is not allowedTr>quitexitrCz"Error reading script file '{}': {}F__main__rH__file__r __console__r3)localszFType "help", "copyright", "credits" or "license" for more information.z}End with `Ctrl-D` (Unix) / `Ctrl-Z` (Windows), `quit()`, `exit()`. Non-Python commands can be issued with: {}("your command")zPython {} on {} {} {} )banner)$ py_bridgerrrrrrrrrrrrrrrrrrrinsertrrrrrcmd_echorr BaseExceptionrinteractversionrrr)rCrrrrrsaved_sys_pathpy_code_to_run localvarsexpanded_filenamefrrcprt instructionssaved_cmd2_envrDrDrEdo_pys        >"                z Cmd.do_pyz+Run a Python script file inside the console script_pathzpath to the script filescript_argumentszarguments to pass to scriptcCstj|j|_|jds#|d|j|dd}|dkr#dStj }z|jg|j t_ |j d|jd}W|t_ |S|t_ w) zw Run a Python script file inside the console :return: True if running of commands should stop .pyz"'{}' does not have a .py extensionYes Noz.Continue to try to run it as a Python script? YesNr>r) rrrrendswithr$rrrrrr)rCr selection orig_args py_returnrDrDrEdo_run_pyscripts  zCmd.do_run_pyscriptz"Enter an interactive IPython shellcCsdddlm}dtd|fdd}|r|ddSzd |_||}||||jWd |_Sd |_w) zz Enter an interactive IPython shell :return: True if running of commands should stop rrcmd2_apprcSs>td|j|jrtd~~tddtjdddS)z Embed an IPython shell in an environment that is restricted to only the variables in this function :param cmd2_app: instance of the cmd2 app :param py_bridge: a PyBridge z{} = py_bridgezself = cmd2_appz}Entering an embedded IPython shell. Type quit or -d to exit. Run Python code from external files with: run filename.py zLeaving IPython, back to {}r)banner1exit_msgN)execrrrr;rr)rrrDrDrEload_ipy5s zCmd.do_ipy..load_ipyrNTF)rrrYrrrr)rCrrr  new_py_bridgerDrDrEry+s   z Cmd.do_ipyz;View, run, edit, save, or clear previously entered commandsz-rz--runzrun selected history itemsz-ez--editz(edit and then run selected history itemsz-oz --output_fileFILEz,output commands to a script file, implies -s)r'rtr3rpz --transcriptTRANSCRIPT_FILEzoutput commands in script format, i.e. without command numbersz-xz --expandedz\output fully parsed commands with any aliases and macros expanded, instead of typed commandszSdisplay history and include expanded commands if they differ from the typed commandzEdisplay all commands, including ones persisted from previous sessionszempty all history items a one history item by number a..b, a:b, a:, ..b items by indices (inclusive) string items containing string /regex/ items matching regular expressionrc CsL|jr'|js|js|js|js|js|js|jr'|d||j dS|js-|jrK|js<|js<|js<|js<|jrK|d||j dS|jr|j |j rzt |j Wn%tygYnty}z|d|j |WYd}~dSd}~wwttjkrtdS||}|jr|js|d|ddS||S|jr ddl}|jdd d \}}t |d $}|D]}|jj r|!d |jq|!d |j"qWdn1swYz|#||$t%&|Wt |dSt |w|jrzGt't j()|jd '}|D]} | jj r.|!d | jq|!d | j"qWdn 1sDwYt*|d krRdnd} Wntys} z|d|j| WYd} ~ dSd} ~ ww|+dt*|| |jdS|jr|,||jdS|D]} || j-|j|j|jdqdS)z View, run, edit, save, or clear previously entered commands :return: True if running of commands should stop z)-v can not be used with any other optionsNz4-s and -x can not be used with -c, -r, -e, -o, or -tz$Error removing history file '{}': {}z9Cowardly refusing to run all previously entered commands.zEIf this is what you want to do, specify '1:' as the range of history.rz.txtT)rrrrrsr>zError saving {!r} - {}z{} command{} saved to {})scriptexpandedrp).rpr!edit output_filerun transcriptrrrhistory_parser format_usagerQr[rrFileNotFoundErrorrrrr1r-rxr8r _get_historyrrrrmkstempfdopenrLrrr _run_editor do_run_scriptrrrrrrr_generate_transcriptpr) rCrrrQrfdfnamefobjrrpluralrchirDrDrE do_history|s            " zCmd.do_historycCs|jrU|j}d}zt|d}Wn tyYnwd|vs"d|vr,|j||j}|S|r7|j|g}|S|drK|drK|j ||j}|S|j ||j}|S|jd|j}|S)znIf an argument was supplied, then retrieve partial contents of the history; otherwise retrieve entire history.FTz..r/) rrtrrQspanrBrrr regex_search str_search)rCrr arg_is_intrQrDrDrErs,  zCmd._get_historyc Cst|_|s ||_dStjtj|}tj|r'd}|| |dStj |}z tj |ddWnt yT}zd ||}| |WYd}~dSd}~wwt}zt|d }t|}Wdn1snwYWn/ttttttttjfyYnt y}zd}| | ||WYd}~dSd}~ww||_|j||_ttjkrd}|D]}|jD] } | |krt | | }qqddl!} | "|j#dS) aInitialize history using history related attributes This function can determine whether history is saved in the prior text-based format (one line of input is stored as one line in the file), or the new-as- of-version 0.9.13 pickle based format. History created by versions <= 0.9.12 is in readline format, i.e. plain text files. Initializing history does not effect history files on disk, versions >= 0.9.13 always write history in the pickle format. Nz+Persistent history file '{}' is a directoryT)exist_okz9Error creating persistent history file directory '{}': {}rbz-Can not read persistent history file '{}': {}r)$r&rQr[rrrrrrrrmakedirsrrrpickleloadrzrr ImportErrorr]rmrUnpicklingError start_sessionr1r-rxrrr8ratexitregister_persist_history) rC hist_filer hist_file_dirrrQr%lastrrr6rDrDrErs`            zCmd._initialize_historyc Cs|jsdS|j|jz"t|jd}t|j|WdWdS1s'wYWdStyM}zd}|| |j|WYd}~dSd}~ww)z%Write history out to the history fileNwbz.Can not write persistent history file '{}': {}) r[rQtruncaterrr1dumprrr)rCr%rrrDrDrEr83s&"zCmd._persist_historyrQtranscript_filecCstjtj|}tj|}tj|rt|tjs'|d |dSd}z|j |j }|j }d|_ Wdn1sAwYd}|D]m} d} d} t | trX| j} | D]} | rl| d |j| 7} d} q\| d |j| 7} q\|| 7}t|j |_ z |j| dd} Wnty}z ||d} WYd}~nd}~ww|d 7}||j d d 7}| rnqJW|j ||_ ||_ Wdn1swYn|j ||_ ||_ Wdw1swYw|t|krd |}||zt|d  }||Wdn 1swYWnty6}z|d |WYd}~dSd}~ww|d kr?d}nd}d}|| |||dS)z;Generate a transcript file from a given history of commandsz6{!r} is not a directory or you don't have write accessNrFr>Tr)rrr)z\/zACommand {} triggered a stop and ended transcript generation earlyrzFailed to save transcript: {}zcommands and their outputszcommand and its outputz#{} {} saved to transcript file {!r}) rrrrrrr W_OKrrrrrkrr'rrr|rrrrrrrrr$rrrrr)rCrQr?transcript_pathtranscript_dir commands_run saved_echo saved_stdoutr history_itemfirstrrrrcrfoutrr&rrDrDrEr!@s          zCmd._generate_transcriptzRun a text editor and optionally open a file with it The editor used is determined by a settable parameter. To set it: set editor (program-name) file_pathz)optional path to a file to open in editorcCs||jdS)z4Run a text editor and optionally open a file with itN)rrI)rCrrDrDrEdo_editsz Cmd.do_editcCsN|jstdttj|j}|r |dttj|7}||dS)z Run a text editor and optionally open a file with it :param file_path: optional path of the file to edit :raises: EnvironmentError if self.editor is not set zGPlease use 'set editor' to specify your text editing program of choice.r3N)rEnvironmentErrorrrrrrr)rCrIrrDrDrErs zCmd._run_editorcCs|jr|jdSdS)zMAccessor to get the current script directory from the _script_dir LIFO queue.rN)rrBrDrDrErks zCmd._current_script_dira7Run commands in script file that is encoded as either ASCII or UTF-8 text Script should contain one command per line, just like the command would be typed in the console. If the -t/--transcript flag is used, this command instead records the output of the script commands to a transcript for testing purposes. z4record the output of the script as a transcript filecCsptjtj|j}tj|s|d|dStj|s+|d|dStj |dkr5dSt |sD|d|dS| dr]| d||dd }|d kr]dSzt|d d }|}Wdn1suwYWnty}z|d ||WYd}~dSd}~wwt|j}zq|jtj||jr||tj|jn,||W|j|t|jkr|jWdSWdS1swYSW|j|t|jkr|jWddSWddS1swYdS|j|t|jkr'|jWdwWdw1s2wYw)zRun commands in script file that is encoded as either ASCII or UTF-8 text. :return: True if running of commands should stop z)'{}' does not exist or cannot be accessedNz'{}' is not a filerz/'{}' is not an ASCII or UTF-8 encoded text filerz '{}' appears to be a Python filerz,Continue to try to run it as a text script? rrr$z&Problem accessing script from '{}': {})rrrrrrrrisfilegetsizer is_text_filerr$rrrrrrrrrrrr!rrrE)rCrrrrscript_commandsrorig_script_dir_countrDrDrEr sf          ,   zCmd.do_run_scriptz If this is called from within an already-running script, the filename will be interpreted relative to the already-running script's directory.zKNotes: This command is intended to only be used within text file scripts.z a file path pointing to a scriptcCs*|j}tj|jp d|}|t|S)z Run commands in script file that is encoded as either ASCII or UTF-8 text :return: True if running of commands should stop r>)rIrrrrkr rr)rCrrI relative_pathrDrDrEdo__relative_run_scriptszCmd.do__relative_run_scripttranscript_pathscsddl}ddl}ddl}ddlm}Gfddd|}tj|tjd}|s0 dd _ dSd t t tjdd }t|} t|dkrId nd } tjtjddddddtj||jtdtdtjdtjd| | dd|j_tjdgt_|} ttj} |j| d} |}| | }||}|!rt"tj| #d| | |}t$tj|dd}|dS| #}|%d}||d%d}||} ||dd _ dS)a#Runs transcript tests for provided file(s). This is called when either -t is provided on the command line or the transcript_files argument is provided during construction of the cmd2.Cmd instance. :param transcript_paths: list of transcript test file paths rNr) Cmd2TestCasecseZdZZdS)z0Cmd._run_transcript_tests..TestMyAppCaseN)rHrIrJcmdapprDrBrDrE TestMyAppCase/srV)r z%No test files found - nothing to testr.r>rz cmd2 transcript test =) fill_charT)boldz.platform {} -- Python {}, cmd2-{}, readline-{}zcwd: {}z cmd2 app: {}zcollected {} transcript{})streamz- {0} transcript{1} passed in {2:.3f} seconds zAssertionError:zFile )&timeunittestcmd2rrTrfiles_from_glob_patternsrR_OKrrrmaprYr version_inforrrstyle align_centerrr __version__r1rrr testfilesrrTextTestRunnerr wasSuccessfulrr style_successr)rCrSr]r^r_rTrVtranscripts_expandedverinfonum_transcriptsr&testcaser\runner start_time test_resultsexecution_time finish_msg error_str end_of_trace file_offsetr[rDrBrE_run_transcript_tests"sN        zCmd._run_transcript_tests alert_msg new_promptcCstr|jsdS|jjddrud}|r|d7}d}|dur.||jkr.||_|js.t|jd}|rnddl}|jr:|jn|j}t j | j |t t|d}ttjkr^tj|tjn ttjkrkt jjj|t|jdStd) a Display an important message to the user while they are at a command line prompt. To the user it appears as if an alert message is printed above the prompt and their current input text and cursor location is left alone. Raises a `RuntimeError` if called while another thread holds `terminal_lock`. IMPORTANT: This function will not print an alert unless it can acquire self.terminal_lock to ensure a prompt is onscreen. Therefore it is best to acquire the lock before calling this function to guarantee the alert prints and to avoid raising a RuntimeError. :param alert_msg: the message to display to the user :param new_prompt: if you also want to change the prompt that is displayed, then include it here see async_update_prompt() docstring for guidance on updating a prompt NFblockingr~Tr)terminal_columnsr|r cursor_offsetrx"another thread holds terminal_lock)r3rwrrr|rr0shutilrrasync_alert_strget_terminal_sizecolumnsr8rXr.r1r-rrrrrrrrr0r7rr)rCrxryupdate_terminalrcurrent_prompt terminal_strrDrDrE async_alert^s6       zCmd.async_alertcCs|d|dS)a Update the command line prompt while the user is still typing at it. This is good for alerting the user to system changes dynamically in between commands. For instance you could alter the color of the prompt to indicate a system status or increase a counter to report an event. If you do alter the actual text of the prompt, it is best to keep the prompt the same width as what's on screen. Otherwise the user's input text will be shifted and the update will not be seamless. Raises a `RuntimeError` if called while another thread holds `terminal_lock`. IMPORTANT: This function will not update the prompt unless it can acquire self.terminal_lock to ensure a prompt is onscreen. Therefore it is best to acquire the lock before calling this function to guarantee the prompt changes and to avoid raising a RuntimeError. If user is at a continuation prompt while entering a multiline command, the onscreen prompt will not change. However self.prompt will still be updated and display immediately after the multiline line command completes. :param new_prompt: what to change the prompt to r>N)r)rCryrDrDrEasync_update_promptszCmd.async_update_promptrcCstsdS|jjddr.)rErr8rzrrrrrTr rF_report_disabled_command_usager COMMAND_NAMEr%r)rCrrrErVrrnew_funcrDrDrEdisable_commands$         zCmd.disable_commandcCs>|}|D]}||}t|tjd|kr|||qdS)aDisable an entire category of commands. :param category: the category to disable :param message_to_print: what to print when anything in this category is run or help is called on it while disabled. The variable COMMAND_NAME can be used as a placeholder for the name of the command being disabled. ex: message_to_print = "{} is currently disabled".format(COMMAND_NAME) N)rr8r rrr)rCrr all_commandsr(rRrDrDrEdisable_categorys   zCmd.disable_categorycOs|j|dddS)z Report when a disabled command has been run or had help called on it :param args: not used :param message_to_print: the message reporting that the command is disabled :param kwargs: not used FrN)r)rCr_args_kwargsrDrDrEr.s z"Cmd._report_disabled_command_usageintrocCsttur tdddl}||j}||j|j|j |j D]}|q&| |j durA| dd|j Dn|durH||_|jdurS||j||jD]}|qZ||j||j||jS)aThis is an outer wrapper around _cmdloop() which deals with extra features provided by cmd2. _cmdloop() provides the main loop equivalent to cmd.cmdloop(). This is a wrapper around that which deals with the following extra features provided by cmd2: - transcript testing - intro banner - exit code :param intro: if provided this overrides self.intro and serves as the intro banner printed once at start z&cmdloop must be run in the main threadrNcSsg|]}tj|qSrD)rrr)rtfrDrDrErXrzCmd.cmdloop..)rcurrent_thread main_threadrsignal getsignalSIGINTrrr_preloop_hooksrrrwrrr#_postloop_hooksrrr)rCrroriginal_sigint_handlerrRrDrDrEcmdloop9s,         z Cmd.cmdloopcCs(g|_g|_g|_g|_g|_g|_dS)zInitialize the plugin systemN)rrrrrrrBrDrDrEr{xs  zCmd._initialize_plugin_systemrRcountcCs4t|}t|j}||krtd|j||dS)z5Ensure a function has the given number of parameters.z+{} has {} positional arguments, expected {}N)rrrr TypeErrorrrH)clsrRrrnparamrDrDrE_validate_callable_param_counts  z"Cmd._validate_callable_param_countcCs4||dt|}|jdurtd|jdS)z@Check parameter and return types for preloop and postloop hooks.rNz.{} must declare return a return type of 'None')rrrreturn_annotationrrrH)rrRrrDrDrE_validate_prepostloop_callables   z"Cmd._validate_prepostloop_callablecC|||j|dS)zFRegister a function to be called at the beginning of the command loop.N)rrrrCrRrDrDrEregister_preloop_hook zCmd.register_preloop_hookcCr)z@Register a function to be called at the end of the command loop.N)rrrrrDrDrEregister_postloop_hookrzCmd.register_postloop_hookcCsh||dt|}t|jd\}}|jtjkr$t d |j |j tjkr2t d |j dS)z6Check parameter and return types for postparsing hooksrrzK{} must have one parameter declared with type 'cmd2.plugin.PostparsingData'zE{} must declare return a return type of 'cmd2.plugin.PostparsingData'N) rrrrrr annotationrrrrrHrrrRrrrrDrDrE_validate_postparsing_callables    z"Cmd._validate_postparsing_callablecCr)zXRegister a function to be called after parsing user input but before running the commandN)rrrrrDrDrEregister_postparsing_hookrzCmd.register_postparsing_hook data_typecCst|}||dt|jd}|j|}|j|kr)td|j |j||j |j kr8td|j ||j |krHtd|j |j |dS)z@Check parameter and return types for pre and post command hooks.rrz6argument 1 of {} has incompatible type {}, expected {}z4{} does not have a declared return type, expected {}z/{} has incompatible return type {}, expected {}N) rrrrrrrrrrHrempty)rrRrr paramnamerrDrDrE_validate_prepostcmd_hooks,      zCmd._validate_prepostcmd_hookcC||tj|j|dS)z9Register a hook to be called before the command function.N)rrrrrrrDrDrEregister_precmd_hookzCmd.register_precmd_hookcCr)z8Register a hook to be called after the command function.N)rrrrrrrDrDrEregister_postcmd_hookrzCmd.register_postcmd_hookcCsp||dt|}t|jd\}}|jtjkr&t d |j tj|j tjkr6t d |j tjdS)z@Check parameter and return types for command finalization hooks.rrz0{} must have one parameter declared with type {}z*{} must declare return a return type of {}N) rrrrrrrrrrrrHrrrDrDrE"_validate_cmdfinalization_callables      z&Cmd._validate_cmdfinalization_callablecCr)zdRegister a hook to be called after a command is completed, whether it completes successfully or not.N)rrrrrDrDrEregister_cmdfinalization_hooks z!Cmd.register_cmdfinalization_hookcmd_support_funccmd_selfcCst|}|durDt|trDt||r|}|Sd}g}|jD]}t||kr)|}n t||r3||q|durBt|dkrB|d}|S|S)a Attempt to resolve a candidate instance to pass as 'self' for an unbound class method that was used when defining command's argparse object. Since we restrict registration to only a single CommandSet instance of each type, using type is a reasonably safe way to resolve the correct object instance :param cmd_support_func: command support function. This could be a completer or namespace provider :param cmd_self: The `self` associated with the command or sub-command :return: Nrr)r6 issubclassrrrrrr)rCrr func_class func_selfcandidate_setsinstalled_cmd_setrDrDrE_resolve_func_selfs$      zCmd._resolve_func_self)rZNN)riN)r>)F)rrN)rHrIrJrKr find_editorrINTERNAL_COMMAND_EPILOG norm_foldr natural_keysNATURAL_SORT_KEYrYrtrsr r rrrrFr rrrrrr r r r/r,rrr-r5rkrnrpropertyrosetterryr}rrrr$rrrrr rrrr rr rr staticmethodrr!rrrUrdrrrGrrr#rnrrwrr{rrr\rrr*rrrrrrrr'rrrrrrrr8rrrrrr=rr r#alias_description alias_epilogr alias_parseradd_subparsersalias_subparsersrequiredr Namespacer-alias_create_descriptionalias_create_epilogalias_create_parserr REMAINDERrrr<alias_delete_helpalias_delete_descriptionalias_delete_parser ZERO_OR_MORErEalias_list_helpalias_list_descriptionalias_list_parserrPmacro_description macro_epilog macro_parsermacro_subparsersrQmacro_create_helpmacro_create_descriptionmacro_create_epilogmacro_create_parserrdmacro_delete_helpmacro_delete_descriptionmacro_delete_parserremacro_list_helpmacro_list_descriptionmacro_list_parserrfrirm help_parserOPTIONALr cmdrYrrsrqryr{shortcuts_parserr eof_parserr quit_parserrrrset_descriptionr set_parserr shell_parserrrrrMrrpy_description py_parserrrun_pyscript_parserripython_availableipython_parserryhistory_descriptionradd_mutually_exclusive_grouphistory_action_groupadd_argument_grouphistory_format_grouphistory_arg_helpr(rrr8r!edit_description edit_parserrJrrkrun_script_descriptionrun_script_parserr relative_run_script_descriptionrelative_run_script_epilogrelative_run_script_parserrRrwrrrr.rrrrrr{ classmethodrrrrrrrrrrrrrrrrobjectr __classcell__rDrDrrErYs     $( ;$g.   &&" " =*? ?  ,  .  &Q$ 6 #a      p ?.-e$ L# *   "  (   #   Q  &# # &L*6 8 A&  0v " ,  S  I* V   : &<<  ' ?  $" "(& &&   rY)krKrrrrrr1rtrSrrcoder collectionsr contextlibrtypingrrrrr r r r r rr>rrrrargparse_customrr clipboardrrrcommand_definitionrrrrr decoratorsrr exceptionsr r!r"r#r$r%rQr&r'parsingr(r)r*r+r,rl_utilsr-r.r/r0r1r2r3r4r5r6rxrrrr7r8rrrrrrr1rr(r9r)in_dllr:rrr~rrIPythonr;r3r=rMrTrYrDrDrDrEs^   0   $