369 lines
44 KiB
Plaintext
369 lines
44 KiB
Plaintext
|
+
|
|||
|
|
t<10>i!<21> <00> <00>& <00> ^ RI t ^ RIt^ RIt^ RIt^ RIt^ RIt^ RIHt ^ RIH t H
|
|||
|
|
t
|
|||
|
|
H t H t H
t
HtHtHt ^RIHtHtHtHt ^RIHtHt ^RIHtHtH t ^RI H t H t H t H!t! ^RI"H#t# ^R I$H%t%H&t&H't' ] ' d ^R
|
|||
|
|
I(H)t) ^R IH*t* ^R I$H+t+ ! R
R4 t,R# )<0F> N)<01>
import_module)<08>
TYPE_CHECKING<4E>Any<6E>Dict<63>List<73>Optional<61>Sequence<63>Tuple<6C>Type)<04>
|
|||
|
|
Collection<EFBFBD>Config<69>Executor<6F>FilesystemLoader)<02>complete<74>print_completion_script)<03>Parser<65>
ParserContext<78>Argument)<04>UnexpectedExit<69>CollectionNotFound<6E>
|
|||
|
|
ParseError<EFBFBD>Exit)<01>pty_size)<03>debug<75>enable_logging<6E>helpline)<01>Loader)<01> ParseResult)<01>Lexiconc <00> a <00> ] tR t^ t o RtV 3R lR ltV 3R lR lt^tR], t^t R] , t
|
|||
|
|
^t RJV 3R lR llt V 3R
|
|||
|
|
lR lt
RKV 3R lR
lltRLV 3R lR lltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR lt]V 3R lR l4 t]V 3R lR l4 t]V 3R lR! l4 t]V 3R" lR# l4 t]V 3R$ lR% l4 t]V 3R& lR' l4 t V 3R( lR) lt V 3R* lR+ lt V 3R, lR- lt V 3R. lR/ lt V 3R0 lR1 lt!V 3R2 lR3 lt"V 3R4 lR5 lt#V 3R6 lR7 lt$V 3R8 lR9 lt%V 3R: lR; lt&V 3R< lR= lt'RMV 3R> lR? llt(V 3R@ lRA lt)RNV 3RB lRC llt*RNV 3RD lRE llt+V 3RF lRG lt,V 3RH lt-RIt.V t/R# )O<>ProgramaU
|
|||
|
|
Manages top-level CLI invocation, typically via ``setup.py`` entrypoints.
|
|||
|
|
|
|||
|
|
Designed for distributing Invoke task collections as standalone programs,
|
|||
|
|
but also used internally to implement the ``invoke`` program itself.
|
|||
|
|
|
|||
|
|
.. seealso::
|
|||
|
|
:ref:`reusing-as-a-binary` for a tutorial/walkthrough of this
|
|||
|
|
functionality.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
c <00>. <<01> V ^8<> d QhRS[ R, /# <00><03> <00>returnr <00>r )<02>format<61>
__classdict__s "<22><>5/tmp/pip-target-zhdecbcm/lib/python/invoke/program.py<70> __annotate__<5F>Program.__annotate__0 s <00><> <00> f
|
|||
|
|
<EFBFBD> f
|
|||
|
|
<EFBFBD>4<EFBFBD>
|
|||
|
|
<EFBFBD>+<2B> f
|
|||
|
|
<EFBFBD> c <0C>2 <00> \ R\ RR7 \ R \ RRR7 \ R RR7 \ R \ RRR7 \ R \ RR R7 \ R \ RR
|
|||
|
|
R7 \ R!R R R
7 \ R"RR7 \ R#R RR
7 \ R$\ ^ RR7 \ R%RRR7 \ R&\ RRR7 \ R'\ RRR7 \ R(\ RRR7 \ R)\ RRR7 \ R*\ RRR7 \ R+\ RRR7 .# ),zL
|
|||
|
|
Return default core `.Argument` objects, as a list.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
z7Specify a global command execution timeout, in seconds.)<03>names<65>kind<6E>helpFz:Print tab-completion candidates for given parse remainder.<2E>r. r/ <00>defaultr0 z"Runtime configuration file to use.<2E>r. r0 zEnable debug output.z!Echo commands instead of running.z&Echo executed commands before running.Tz$Show core or per-task help and exit.)r. <00>optionalr0 z*Set default value of run()'s 'hide' kwarg.z8List available tasks, optionally limited to a namespace.z3When listing tasks, only show the first INT levels.zbChange the display format used when listing tasks. Should be one of: flat (default), nested, json.<2E>flat)r. r0 r2 <00> zIPrint the tab-completion script for your preferred shell (bash|zsh|fish).zCPrompt user at start of session for the sudo.password config value.z(Use a pty when executing shell commands.zShow version and exit.z3Warn, instead of failing, when shell commands fail.z Enable creation of .pyc files.)<02>command-timeout<75>T)r )<02>config<69>f)r <00>d)<02>dry<72>R)<02>echo<68>e)r0 <00>h)<01>hide)<02>list<73>l)<02>
|
|||
|
|
list-depth<74>D)<02> list-format<61>F)<01>print-completion-script)<01>prompt-for-sudo-password)<02>pty<74>p)<02>version<6F>V)<02> warn-only<6C>w)<01> write-pyc)r <00>int<6E>bool<6F>str<74><01>selfs &r) <00> core_args<67>Program.core_args0 sm <00> <00>
<15>.<2E><18>N<>
<0E>
|
|||
|
|
<15>#<23><19> <1D>Q<>
<0E>
<15>%<25>9<>
<0E>
<15>$<24><19> <1D>+<2B>
<0E>
<15>"<22><19> <1D>8<>
<0E>
<15>#<23><19> <1D>=<3D>
<0E>
<15>#<23> <1D>;<3B>
<0E>
|
|||
|
|
<15> <1F>A<>
<0E>
<15>#<23> <1D>O<>
<0E>
|
|||
|
|
<15>)<29><18><19>J<>
<0E>
<15>*<2A>y<> <1E>
<0E>
|
|||
|
|
<15>2<><18><1A>`<60>
<0E>
<15>3<><19> <1D>Z<>
<0E>
<15>"<22><19> <1D>?<3F>
<0E>
<15>&<26><19> <1D>-<2D>
<0E>
<15>(<28><19> <1D>J<>
<0E>
<15>$<24><19> <1D>5<>
<0E>s_
|
|||
|
|
<EFBFBD> _
|
|||
|
|
r, c <00>. <<01> V ^8<> d QhRS[ R, /# r# r& )r' r( s "<22>r) r* r+ <00> s <00><> <00>
|
|||
|
|
<EFBFBD>
|
|||
|
|
<EFBFBD>4<EFBFBD>
|
|||
|
|
<EFBFBD>+<2B>
|
|||
|
|
r, c <0C>Z <00> \ RRR7 \ R\ RRR7 \ R RR7 .# )
|
|||
|
|
a%
|
|||
|
|
Return default task-related `.Argument` objects, as a list.
|
|||
|
|
|
|||
|
|
These are only added to the core args in "task runner" mode (the
|
|||
|
|
default for ``invoke`` itself) - they are omitted when the constructor
|
|||
|
|
is given a non-empty ``namespace`` argument ("bundled namespace" mode).
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
z Specify collection name to load.r3 FzDisable task deduplication.r1 z4Change root directory used for finding task modules.)<02>
|
|||
|
|
collection<EFBFBD>c)<01> no-dedupe)<02> search-root<6F>r)r rR rT s &r) <00> task_args<67>Program.task_args<67> sB <00> <00>
<15>)<29>7<>
<0E>
<15>$<24><19> <1D>2<>
<0E>
<15>*<2A>K<>
<0E>
|
|||
|
|
<EFBFBD>
|
|||
|
|
r, <00> Nc <00> <<01> V ^8<> d QhRS[ S[, RS[ R, RS[ S[, RS[ S[, RS[ S[R, , RS[ S[R , , R
|
|||
|
|
S[ S[R , , R S[ S[S[, , R
R/ # )r$ rL <00> namespacer <00>name<6D>binary<72> loader_classr <00>executor_classr <00> config_classr
<00> binary_namesr% N)r rS r r )r' r( s "<22>r) r* r+ <00> s<> <00><> <00> _3<> _3<><19>#<23> <1D>_3<> <1C>L<EFBFBD>)<29>_3<> <17>s<EFBFBD>m<EFBFBD> _3<>
|
|||
|
|
<19><13>
<0A> _3<> <1F>t<EFBFBD>H<EFBFBD>~<7E>.<2E>
_3<> !<21><14>j<EFBFBD>!1<>2<>_3<> <1F>t<EFBFBD>H<EFBFBD>~<7E>.<2E>_3<> <1F>t<EFBFBD>C<EFBFBD>y<EFBFBD>)<29>_3<>
|
|||
|
|
<0E>_3r, c <0C><> <00> Vf RMTV n W n W0n W@n W<>n . V n T;' g \ V n T;' g \ V n T;' g \ V n R# )a<>
|
|||
|
|
|
|||
|
|
Create a new, parameterized `.Program` instance.
|
|||
|
|
|
|||
|
|
:param str version:
|
|||
|
|
The program's version, e.g. ``"0.1.0"``. Defaults to ``"unknown"``.
|
|||
|
|
|
|||
|
|
:param namespace:
|
|||
|
|
A `.Collection` to use as this program's subcommands.
|
|||
|
|
|
|||
|
|
If ``None`` (the default), the program will behave like ``invoke``,
|
|||
|
|
seeking a nearby task namespace with a `.Loader` and exposing
|
|||
|
|
arguments such as :option:`--list` and :option:`--collection` for
|
|||
|
|
inspecting or selecting specific namespaces.
|
|||
|
|
|
|||
|
|
If given a `.Collection` object, will use it as if it had been
|
|||
|
|
handed to :option:`--collection`. Will also update the parser to
|
|||
|
|
remove references to tasks and task-related options, and display
|
|||
|
|
the subcommands in ``--help`` output. The result will be a program
|
|||
|
|
that has a static set of subcommands.
|
|||
|
|
|
|||
|
|
:param str name:
|
|||
|
|
The program's name, as displayed in ``--version`` output.
|
|||
|
|
|
|||
|
|
If ``None`` (default), is a capitalized version of the first word
|
|||
|
|
in the ``argv`` handed to `.run`. For example, when invoked from a
|
|||
|
|
binstub installed as ``foobar``, it will default to ``Foobar``.
|
|||
|
|
|
|||
|
|
:param str binary:
|
|||
|
|
Descriptive lowercase binary name string used in help text.
|
|||
|
|
|
|||
|
|
For example, Invoke's own internal value for this is ``inv[oke]``,
|
|||
|
|
denoting that it is installed as both ``inv`` and ``invoke``. As
|
|||
|
|
this is purely text intended for help display, it may be in any
|
|||
|
|
format you wish, though it should match whatever you've put into
|
|||
|
|
your ``setup.py``'s ``console_scripts`` entry.
|
|||
|
|
|
|||
|
|
If ``None`` (default), uses the first word in ``argv`` verbatim (as
|
|||
|
|
with ``name`` above, except not capitalized).
|
|||
|
|
|
|||
|
|
:param binary_names:
|
|||
|
|
List of binary name strings, for use in completion scripts.
|
|||
|
|
|
|||
|
|
This list ensures that the shell completion scripts generated by
|
|||
|
|
:option:`--print-completion-script` instruct the shell to use
|
|||
|
|
that completion for all of this program's installed names.
|
|||
|
|
|
|||
|
|
For example, Invoke's internal default for this is ``["inv",
|
|||
|
|
"invoke"]``.
|
|||
|
|
|
|||
|
|
If ``None`` (the default), the first word in ``argv`` (in the
|
|||
|
|
invocation of :option:`--print-completion-script`) is used in a
|
|||
|
|
single-item list.
|
|||
|
|
|
|||
|
|
:param loader_class:
|
|||
|
|
The `.Loader` subclass to use when loading task collections.
|
|||
|
|
|
|||
|
|
Defaults to `.FilesystemLoader`.
|
|||
|
|
|
|||
|
|
:param executor_class:
|
|||
|
|
The `.Executor` subclass to use when executing tasks.
|
|||
|
|
|
|||
|
|
Defaults to `.Executor`; may also be overridden at runtime by the
|
|||
|
|
:ref:`configuration system <default-values>` and its
|
|||
|
|
``tasks.executor_class`` setting (anytime that setting is not
|
|||
|
|
``None``).
|
|||
|
|
|
|||
|
|
:param config_class:
|
|||
|
|
The `.Config` subclass to use for the base config object.
|
|||
|
|
|
|||
|
|
Defaults to `.Config`.
|
|||
|
|
|
|||
|
|
.. versionchanged:: 1.2
|
|||
|
|
Added the ``binary_names`` argument.
|
|||
|
|
N<EFBFBD>unknown) rL rc <00>_name<6D>_binary<72>
_binary_names<65>argvr rf r rg r
rh ) rU rL rc rd re rf rg rh ri s &&&&&&&&&r) <00>__init__<5F>Program.__init__<5F> sa <00> <00>j %,<2C>O<EFBFBD>y<EFBFBD><17><04> <0C>"<22><0E><19>
|
|||
|
|
<EFBFBD> <1E> <0C> )<29><1A><16><04> <09> (<28> <<3C> <<3C>,<<3C><04><19> ,<2C> 8<> 8<><08><04><1B> (<28> 2<> 2<>F<EFBFBD><04>r, c <00> <<01> V ^8<> d QhRR/# <00>r$ r% N<> )r' r( s "<22>r) r* r+ s <00><> <00>
*<2A>
*<2A>t<EFBFBD>
*r, c <0C>0 <00> V P 4 V n R# )ak
|
|||
|
|
Instantiate a `.Config` (or subclass, depending) for use in task exec.
|
|||
|
|
|
|||
|
|
This Config is fully usable but will lack runtime-derived data like
|
|||
|
|
project & runtime config files, CLI arg overrides, etc. That data is
|
|||
|
|
added later in `update_config`. See `.Config` docstring for lifecycle
|
|||
|
|
details.
|
|||
|
|
|
|||
|
|
:returns: ``None``; sets ``self.config`` instead.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
N)rh r9 rT s &r) <00>
create_config<69>Program.create_config s <00> <00> <1B>'<27>'<27>)<29><04> r, c <00>$ <<01> V ^8<> d QhRS[ RR/# )r$ <00>merger% N)rR )r' r( s "<22>r) r* r+ . s <00><> <00> 3 <20> 3 <20>4<EFBFBD> 3 <20>4<EFBFBD> 3 r, c <0C><> <00> / pV P R, P ' d RVR& V P P P ' d RVR& V P P P ' d$ V P P P VR& V P P P ' d RVR& V P P
|
|||
|
|
P ' d RVR& / pRV P 9 d) V P R, P ' d R VR
|
|||
|
|
& / pV P R , P pV' d WTR & / pV P R
, P ' d Rp\ P ! V4 VR& \ W#WdR7 pV P P VR R7 V P P P p V f! \ P P RR4 p V P P V 4 V P P R R7 V' d V P P 4 R# R# )a3
|
|||
|
|
Update the previously instantiated `.Config` with parsed data.
|
|||
|
|
|
|||
|
|
For example, this is how ``--echo`` is able to override the default
|
|||
|
|
config value for ``run.echo``.
|
|||
|
|
|
|||
|
|
:param bool merge:
|
|||
|
|
Whether to merge at the end, or defer. Primarily useful for
|
|||
|
|
subclassers. Default: ``True``.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
rN T<>warnrJ rA r> r< r\ F<>deduper7 <00>commandrI z&Desired 'sudo.password' config value: <20>password)<04>run<75>tasks<6B>sudo<64>timeouts)ry N<>INVOKE_RUNTIME_CONFIG)<10>args<67>valuerJ rA r> r< <00>getpass<73>dictr9 <00>load_overrides<65>os<6F>environ<6F>get<65>set_runtime_path<74> load_runtimery )
|
|||
|
|
rU ry r r<> r<> r} r<> <00>prompt<70> overrides<65> runtime_paths
|
|||
|
|
&& r) <00>
update_config<69>Program.update_config. s<> <00> <00>& <11><03> <0F>9<EFBFBD>9<EFBFBD>[<5B> !<21> '<27> '<27> '<27> <1E>C<EFBFBD><06>K<EFBFBD> <0F>9<EFBFBD>9<EFBFBD>=<3D>=<3D> <1E> <1E> <1E> <1D>C<EFBFBD><05>J<EFBFBD> <0F>9<EFBFBD>9<EFBFBD>><3E>><3E> <1F> <1F> <1F> <1E>)<29>)<29>.<2E>.<2E>.<2E>.<2E>C<EFBFBD><06>K<EFBFBD> <0F>9<EFBFBD>9<EFBFBD>><3E>><3E> <1F> <1F> <1F> <1E>C<EFBFBD><06>K<EFBFBD> <0F>9<EFBFBD>9<EFBFBD>=<3D>=<3D> <1E> <1E> <1E> <1D>C<EFBFBD><05>J<EFBFBD><12><05> <16>$<24>)<29>)<29> #<23><04> <09> <09>+<2B>(><3E>(D<>(D<>(D<> #<23>E<EFBFBD>(<28>O<EFBFBD><15><08><16>)<29>)<29> -<2D>.<2E>4<>4<><07> <12>")<29>Y<EFBFBD> <1F> <12><04> <0F>9<EFBFBD>9<EFBFBD>/<2F> 0<> 6<> 6<> 6<>=<3D>F<EFBFBD> &<26><EFBFBD><EFBFBD>v<EFBFBD> 6<>D<EFBFBD><1A> <1C><18>S<EFBFBD>D<EFBFBD>L<> <09> <0C> <0B> <0B>"<22>"<22>9<EFBFBD>E<EFBFBD>"<22>:<3A><1B>y<EFBFBD>y<EFBFBD>'<27>'<27>-<2D>-<2D> <0C> <17> <1F> <1D>:<3A>:<3A>><3E>><3E>*A<>4<EFBFBD>H<>L<EFBFBD> <0C> <0B> <0B>$<24>$<24>\<5C>2<> <0C> <0B> <0B> <20> <20>u<EFBFBD> <20>-<2D> <10> <10>K<EFBFBD>K<EFBFBD> <1D> <1D> <1F> r, c <00>J <<01> V ^8<> d QhRS[ S[S[, , RS[RR/# )r$ ro <00>exitr% N)r r rS rR )r' r( s "<22>r) r* r+ c s0 <00><> <00> C<18> C<18><08><14>c<EFBFBD><19>+<2B> C<18>$<24> C<18>$<24> Cr, c <0C>t <00> V P 4 V P V4 V P 4 V P 4 V P 4 V P 4 V P
4 R# \ \ \ 3 Ed<> p\ RP T4 4 \ T\ 4 ' d \ T\ P R7 \ T\ 4 ' d8 TP ' d& \ TP \ P R7 \ T\ 4 ' d9 TP" P$ ' d \ T\ P RR7 T' d<> \ T\ 4 ' d TP" P& pM;\ T\ 4 ' d TP( pM\ T\ 4 ' d ^p\ P* ! X4 Rp?R# \ R4 Rp?R# Rp?i\, d \ P* ! ^4 R# i ; i)aP
|
|||
|
|
Execute main CLI logic, based on ``argv``.
|
|||
|
|
|
|||
|
|
:param argv:
|
|||
|
|
The arguments to execute against. May be ``None``, a list of
|
|||
|
|
strings, or a string. See `.normalize_argv` for details.
|
|||
|
|
|
|||
|
|
:param bool exit:
|
|||
|
|
When ``False`` (default: ``True``), will ignore `.ParseError`,
|
|||
|
|
`.Exit` and `.Failure` exceptions, which otherwise trigger calls to
|
|||
|
|
`sys.exit`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
This is mostly a concession to testing. If you're setting this
|
|||
|
|
to ``False`` in a production setting, you should probably be
|
|||
|
|
using `.Executor` and friends directly instead!
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
z-Received a possibly-skippable exception: {!r})<01>filer6 )r<> <00>endz3Invoked as run(..., exit=False), ignoring exceptionN)rv <00>
|
|||
|
|
parse_core<EFBFBD>parse_collection<6F> parse_tasks<6B>
parse_cleanupr<70> <00>executer r r r r' <00>
|
|||
|
|
isinstance<EFBFBD>print<6E>sys<79>stderr<72>message<67>resultrA <00>exited<65>coder<65> <00>KeyboardInterrupt)rU ro r<> r? r<> s &&& r) r <00> Program.runc sj <00> <00>(/ <18>
<11> <1E> <1E> <20>
<11>O<EFBFBD>O<EFBFBD>D<EFBFBD> !<21> <10> !<21> !<21> #<23> <10> <1C> <1C> <1E> <10> <1E> <1E> <20>
<11> <1E> <1E> <20>
<11>L<EFBFBD>L<EFBFBD>N<EFBFBD><4E> <1E><04>j<EFBFBD>1<> M<01> <11>A<>H<>H<><11>K<> L<> <1A>!<21>Z<EFBFBD>(<28>(<28><15>a<EFBFBD>c<EFBFBD>j<EFBFBD>j<EFBFBD>)<29><19>!<21>T<EFBFBD>"<22>"<22>q<EFBFBD>y<EFBFBD>y<EFBFBD>y<EFBFBD><15>a<EFBFBD>i<EFBFBD>i<EFBFBD>c<EFBFBD>j<EFBFBD>j<EFBFBD>1<><19>!<21>^<5E>,<2C>,<2C><11><18><18> <1D> <1D> <1D><15>a<EFBFBD>c<EFBFBD>j<EFBFBD>j<EFBFBD>b<EFBFBD>1<><13> <1D>a<EFBFBD> <1E>0<>0<> <1C>8<EFBFBD>8<EFBFBD>?<3F>?<3F>D<EFBFBD> <1F><01>4<EFBFBD>(<28>(<28> <1C>6<EFBFBD>6<EFBFBD>D<EFBFBD> <1F><01>:<3A>.<2E>.<2E> <1C>D<EFBFBD><13><08><08><14><0E><0E><15>K<>L<>L<><4C> <20> <18> <0F>H<EFBFBD>H<EFBFBD>Q<EFBFBD>K<EFBFBD> <18>s? <00>A1A5 <00>5H7<03> A2H<03>?AH<03>#H<03>:A>H<03>> H<03> H7<03> H7<03>6H7c <00>D <<01> V ^8<> d QhRS[ S[S[, , RR/# <00>r$ ro r% N<>r r rS )r' r( s "<22>r) r* r+ <00> s$ <00><> <00> <17> <17>x<EFBFBD><04>S<EFBFBD> <09> 2<> <17>t<EFBFBD> r, c <08><> <00> \ R P V4 4 V P V4 V P 4 \ R4 V P R, P
|
|||
|
|
' * \ n V P P P
|
|||
|
|
' d \ 4 V P P P
|
|||
|
|
' d" \ R4 V P 4 \ hV P R, P
|
|||
|
|
' d9 \ V P R, P
|
|||
|
|
V P R7 \ hR# )z argv given to Program.run: {!r}zFinished parsing core argsrP z)Saw --version, printing version & exitingrH )<02>shellr. N)r r' <00>normalize_argv<67>parse_core_argsr<73> r<> r<> <00>dont_write_bytecoder rL <00>
print_versionr r ri <00>rU ro s &&r) r<> <00>Program.parse_core<72> s<> <00> <00>
<0A>/<2F>6<>6<>t<EFBFBD><<3C>=<3D> <0C><1B><1B>D<EFBFBD>!<21>
<0A> <1C> <1C> <1E>
<0A>*<2A>+<2B> '+<2B>i<EFBFBD>i<EFBFBD> <0B>&<<3C>&B<>&B<>"B<><03> <1F> <10>9<EFBFBD>9<EFBFBD>?<3F>?<3F> <20> <20> <20> <1A> <1C> <10>9<EFBFBD>9<EFBFBD> <1C> <1C> "<22> "<22> "<22> <11>=<3D> ><3E> <10> <1E> <1E> <20><16>J<EFBFBD> <10>9<EFBFBD>9<EFBFBD>.<2E> /<2F> 5<> 5<> 5<> #<23><1A>i<EFBFBD>i<EFBFBD> 9<>:<3A>@<40>@<40><1A>'<27>'<27>
<0E> <17>J<EFBFBD> 6r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ <00> s <00><> <00> 1<> 1<>$<24> 1r, c <0C>h <00> V P e \ R4 V P V n M`\ R4 V P P P
|
|||
|
|
RJ d" \ R4 V P
4 \ hV P 4 RV n RV n
|
|||
|
|
RV n V P V n R# )zH
|
|||
|
|
Load a tasks collection & project-level config.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
Nz;Program was given default namespace, not loading collectionz;No default namespace provided, trying to load one from diskTz8No bundled namespace & bare --help given; printing help.r5 )
rc r rZ r<> r0 r<> <00>
|
|||
|
|
print_helpr <00>load_collection<6F> list_root<6F>
|
|||
|
|
list_depth<EFBFBD> list_format<61>scoped_collectionrT s &r) r<> <00>Program.parse_collection<6F> s<> <00> <00> <10>><3E>><3E> %<25> <11>M<>
<0E> #<23>n<EFBFBD>n<EFBFBD>D<EFBFBD>O<EFBFBD> <11>M<>
<0E> <14>y<EFBFBD>y<EFBFBD>~<7E>~<7E>#<23>#<23>t<EFBFBD>+<2B><15>N<><12> <15><0F><0F>!<21><1A>
|
|||
|
|
<EFBFBD> <10> <20> <20> "<22> )-<2D><04><0E>)-<2D><04><0F>!<21><04><18>!%<25> <1F> <1F><04> r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ <00> s <00><> <00> <"<22> <"<22>t<EFBFBD> <"r, c <0C><> <00> V P P P pVRJ d" \ R4 V P 4 \
|
|||
|
|
hV' dY WP P 9 d% Rp\ V4 V P V4 \
|
|||
|
|
h\ RP V4 4 hV P P P pV P R, P V n V P R, P V n
V' dU \ V\ 4 ' d) W0n V P" P% V4 pW@n V P+ 4 \
|
|||
|
|
hV P P, P ' dG \- V P. V P0 V P2 V P" V P5 4 R7 V P6 ' g1 V P" P8 ' g V P; 4 R # R # R # \( d Rp\ TP T4 4 hi ; i)
|
|||
|
|
zW
|
|||
|
|
Post-parsing, pre-execution steps such as --help, --list, etc.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
Tz(Saw bare --help, printing help & exitingz7Saw --help <taskname>, printing per-task help & exitingzNo idea what '{}' is!rF rD z Sub-collection '{}' not found!)r. <00>core<72>initial_contextrZ <00>parserN) r<> r0 r<> r r<> r r<> <00>contexts<74>print_task_helpr r' rB r<> r<> r<> rS r<> rZ <00>subcollection_from_pathr<68> <00>KeyError<6F>
|
|||
|
|
list_tasksr ri r<> r<> <00> _make_parserr<72> r2 <00>no_tasks_given)rU <00>halp<6C>msgr<67> <00>subs & r) r<> <00>Program.parse_cleanup<75> s<> <00> <00> <14>y<EFBFBD>y<EFBFBD>~<7E>~<7E>#<23>#<23><04> <10>4<EFBFBD><<3C> <11><<3C> =<3D> <10>O<EFBFBD>O<EFBFBD> <1D><16>J<EFBFBD> <10><13>{<7B>{<7B>+<2B>+<2B>+<2B>O<><03><15>c<EFBFBD>
|
|||
|
|
<EFBFBD><14>$<24>$<24>T<EFBFBD>*<2A><1A>
|
|||
|
|
<EFBFBD> !<21>!8<>!?<3F>!?<3F><04>!E<>F<>F<> <19>I<EFBFBD>I<EFBFBD>N<EFBFBD>N<EFBFBD>(<28>(<28> <09> <1F>9<EFBFBD>9<EFBFBD>]<5D>3<>9<>9<><04><18> <1E>)<29>)<29>L<EFBFBD>1<>7<>7<><04><0F> <14><19>)<29>S<EFBFBD>)<29>)<29>!*<2A><0E>6<> <1E>/<2F>/<2F>A<>A<>)<29>L<>C<EFBFBD>-0<>*<2A>
<11>O<EFBFBD>O<EFBFBD> <1D><16>J<EFBFBD> <10>9<EFBFBD>9<EFBFBD> <1D> <1D> #<23> #<23> #<23> <14><1A>'<27>'<27><19>Y<EFBFBD>Y<EFBFBD> $<24> 4<> 4<> <1F>?<3F>?<3F> <1C>(<28>(<28>*<2A>
<0E> <14>z<EFBFBD>z<EFBFBD>z<EFBFBD>$<24>/<2F>/<2F>"9<>"9<>"9<> <10> <1F> <1F> !<21> #:<3A>z<EFBFBD><7A>- <20> 6<>:<3A>C<EFBFBD> <1E>s<EFBFBD>z<EFBFBD>z<EFBFBD>)<29> 4<>5<>5<>6<>s <00>1!H <00>(I c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ ( s <00><> <00> <13> <13><04> r, c <08>D <00> \ R 4 V P 4 \ h)zVNo tasks specified for execution and no default task; printing global help as fallback)r r<> r rT s &r) r<> <00>Program.no_tasks_given( s <00> <00>
<0A> d<>
|
|||
|
|
<EFBFBD>
<0A><0F><0F><19><12>
|
|||
|
|
r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ / s <00><> <00> &<26> &<26><14> &r, c <0C>> <00> V P pV P P P pVe+ VP R4 w r4p\ V4 p\ We4 pV! V P V P V P 4 pVP ! V P ! R# )a~
|
|||
|
|
Hand off data & tasks-to-execute specification to an `.Executor`.
|
|||
|
|
|
|||
|
|
.. note::
|
|||
|
|
Client code just wanting a different `.Executor` subclass can just
|
|||
|
|
set ``executor_class`` in `.__init__`, or override
|
|||
|
|
``tasks.executor_class`` anywhere in the :ref:`config system
|
|||
|
|
<default-values>` (which may allow you to avoid using a custom
|
|||
|
|
Program entirely).
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
N<EFBFBD>.) rg r9 r<> <00>
|
|||
|
|
rpartitionr <00>getattrrZ r<> r<> )rU <00>klass<73> config_path<74> module_path<74>_<>
|
|||
|
|
class_name<EFBFBD>module<6C>executors & r) r<> <00>Program.execute/ s<> <00> <00> <15>#<23>#<23><05><1A>k<EFBFBD>k<EFBFBD>'<27>'<27>6<>6<> <0B> <16> "<22>)4<>)?<3F>)?<3F><03>)D<> &<26>K<EFBFBD>J<EFBFBD> #<23>;<3B>/<2F>F<EFBFBD><1B>F<EFBFBD>/<2F>E<EFBFBD><18><14> <1F> <1F>$<24>+<2B>+<2B>t<EFBFBD>y<EFBFBD>y<EFBFBD>A<><08><10><18><18>$<24>*<2A>*<2A>%r, c <00>D <<01> V ^8<> d QhRS[ S[S[, , RR/# r<> r<> )r' r( s "<22>r) r* r+ I s$ <00><> <00> <19> <19>8<EFBFBD>D<EFBFBD><13>I<EFBFBD>#6<> <19>4<EFBFBD> r, c <0C><> <00> Vf, \ P p\ RP V4 4 M@\ V\
|
|||
|
|
4 ' d+ VP
4 p\ RP V4 4 Wn R# )aa
|
|||
|
|
Massages ``argv`` into a useful list of strings.
|
|||
|
|
|
|||
|
|
**If None** (the default), uses `sys.argv`.
|
|||
|
|
|
|||
|
|
**If a non-string iterable**, uses that in place of `sys.argv`.
|
|||
|
|
|
|||
|
|
**If a string**, performs a `str.split` and then executes with the
|
|||
|
|
result. (This is mostly a convenience; when in doubt, use a list.)
|
|||
|
|
|
|||
|
|
Sets ``self.argv`` to the result.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
Nz#argv was None; using sys.argv: {!r}z%argv was string-like; splitting: {!r})r<> ro r r' r<> rS <00>splitr<74> s &&r) r<> <00>Program.normalize_argvI sW <00> <00> <10><<3C><16>8<EFBFBD>8<EFBFBD>D<EFBFBD> <11>7<>><3E>><3E>t<EFBFBD>D<> E<>
<17><04>c<EFBFBD>
"<22>
"<22><17>:<3A>:<3A><<3C>D<EFBFBD> <11>9<>@<40>@<40><14>F<> G<><18> r, c <00> <<01> V ^8<> d QhRS[ /# <00>r$ r% <00>rS )r' r( s "<22>r) r* r+ a s <00><> <00> 6<> 6<>c<EFBFBD> 6r, c <0C>^ <00> V P ;' g V P P 4 # )zQ
|
|||
|
|
Derive program's human-readable name based on `.binary`.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
)rl re <00>
|
|||
|
|
capitalizerT s &r) rd <00> Program.name` s# <00> <00> <14>z<EFBFBD>z<EFBFBD>5<>5<>T<EFBFBD>[<5B>[<5B> 3<> 3<> 5<>5r, c <00> <<01> V ^8<> d QhRS[ /# r<> r<> )r' r( s "<22>r) r* r+ j s <00><> <00>
|
|||
|
|
C<01>
|
|||
|
|
C<01>3<EFBFBD>
|
|||
|
|
Cr, c <0C><> <00> V P ' d1 \ P P V P ^ , 4 # R# )z<>
|
|||
|
|
Returns the program name we were actually called as.
|
|||
|
|
|
|||
|
|
Specifically, this is the (Python's os module's concept of a) basename
|
|||
|
|
of the first argument in the parsed argument vector.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.2
|
|||
|
|
r6 )ro r<> <00>path<74>basenamerT s &r) <00> called_as<61>Program.called_asi s. <00> <00> 26<32><19><19><19>r<EFBFBD>w<EFBFBD>w<EFBFBD> <1F> <1F><04> <09> <09>!<21> <0C>-<2D>B<><02>Br, c <00> <<01> V ^8<> d QhRS[ /# r<> r<> )r' r( s "<22>r) r* r+ w s <00><> <00> .<2E> .<2E><03> .r, c <0C>B <00> V P ;' g
V P # )z]
|
|||
|
|
Derive program's help-oriented binary name(s) from init args & argv.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
)rm r<> rT s &r) re <00>Program.binaryv s <00> <00> <14>|<7C>|<7C>-<2D>-<2D>t<EFBFBD>~<7E>~<7E>-r, c <00>0 <<01> V ^8<> d QhRS[ S[, /# r<> <00>r rS )r' r( s "<22>r) r* r+ <00> s <00><> <00> 6<> 6<>d<EFBFBD>3<EFBFBD>i<EFBFBD> 6r, c <0C>D <00> V P ;' g V P .# )z^
|
|||
|
|
Derive program's completion-oriented binary name(s) from args & argv.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.2
|
|||
|
|
)rn r<> rT s &r) ri <00>Program.binary_names s <00> <00> <14>!<21>!<21>5<>5<>d<EFBFBD>n<EFBFBD>n<EFBFBD>%5<>5r, c <00> <<01> V ^8<> d QhRR/# )r$ r% r rt )r' r( s "<22>r) r* r+ <00> s <00><> <00> !<21> !<21>i<EFBFBD> !r, c <0C>< <00> V P ^ , P # )zR
|
|||
|
|
Obtain core program args from ``self.core`` parse result.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
)r<> r<> rT s &r) r<> <00> Program.args<67> s <00> <00> <14>y<EFBFBD>y<EFBFBD><11>|<7C> <20> <20> r, c <00> <<01> V ^8<> d QhRS[ /# r<> )r )r' r( s "<22>r) r* r+ <00> s <00><> <00> (<28> (<28> <1D> (r, c <0C><> <00> V P 4 pV P f WP 4 ,
p\ VR7 # )z<>
|
|||
|
|
The initial parser context, aka core program flags.
|
|||
|
|
|
|||
|
|
The specific arguments contained therein will differ depending on
|
|||
|
|
whether a bundled namespace was specified in `.__init__`.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
)r<> )rV rc r_ r )rU r<> s & r) r<> <00>Program.initial_context<78> s4 <00> <00> <14>~<7E>~<7E> <1F><04> <0F>><3E>><3E> !<21> <10>N<EFBFBD>N<EFBFBD>$<24> $<24>D<EFBFBD> <1C>$<24>'<27>'r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ <00> s <00><> <00> D<01> D<01>t<EFBFBD> Dr, c <08>x <00> \ R P V P V P ;' g R4 4 R# )<03>{} {}rk N)r<> r' rd rL rT s &r) r<> <00>Program.print_version<6F> s% <00> <00>
<0A>g<EFBFBD>n<EFBFBD>n<EFBFBD>T<EFBFBD>Y<EFBFBD>Y<EFBFBD><04> <0C> <0C>(A<>(A<> <09>B<>Cr, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ <00> s <00><> <00>
|
|||
|
|
<1E>
|
|||
|
|
<1E>D<EFBFBD>
|
|||
|
|
r, c <08>H <00> R pV P e Rp\ RP V P V4 4 \ R4 \ R4 \ R4 V P V P
|
|||
|
|
P
4 4 V P e V P 4 R# R# )z-task1 [--task1-opts] ... taskN [--taskN-opts]Nz$<subcommand> [--subcommand-opts] ...zUsage: {} [--core-opts] {}r6 z
Core options:)rc r<> r' re <00>
print_columnsr<73> <00> help_tuplesr<73> )rU <00> usage_suffixs & r) r<> <00>Program.print_help<6C> s| <00> <00>F<> <0C> <0F>><3E>><3E> %<25>A<>L<EFBFBD>
<0A>*<2A>1<>1<>$<24>+<2B>+<2B>|<7C>L<>M<>
<0A>b<EFBFBD> <09>
<0A>o<EFBFBD> <1E>
<0A>b<EFBFBD> <09> <0C><1A><1A>4<EFBFBD>/<2F>/<2F>;<3B>;<3B>=<3D>><3E> <0F>><3E>><3E> %<25> <10>O<EFBFBD>O<EFBFBD> <1D> &r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ <00> s <00><> <00> 9<> 9<><14> 9r, c <0C> <00> \ R4 \ V P RR7 pVP V P R, 4 V n Rp\ VP
V P
|
|||
|
|
V P
|
|||
|
|
P 4 4 R# )z<>
|
|||
|
|
Filter out core args, leaving any tasks or their args for later.
|
|||
|
|
|
|||
|
|
Sets ``self.core`` to the `.ParseResult` from this step.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
z#Parsing initial context (core args)T)<02>initial<61>ignore_unknown<77><6E> NNz-Core-args parse result: {!r} & unparsed: {!r}N)r r r<> <00>
|
|||
|
|
parse_argvro r<> r' <00>unparsed)rU r<> r<> s & r) r<> <00>Program.parse_core_args<67> s_ <00> <00> <0E>3<>4<><17><04> 4<> 4<>T<EFBFBD>J<><06><1A>%<25>%<25>d<EFBFBD>i<EFBFBD>i<EFBFBD><02>m<EFBFBD>4<><04> <09>=<3D><03>
<0A>c<EFBFBD>j<EFBFBD>j<EFBFBD><14><19><19>D<EFBFBD>I<EFBFBD>I<EFBFBD>$6<>$6<>7<>8r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ <00> s <00><> <00> O<01> O<01><14> Or, c <0C>2 <00> V P R, P pV P V P VR7 pV P P P p VP V4 w rEV P P
V4 V P P 4 \ P ! VVV P P P R7 V n R# \ d* p\ RP TP 4 4 hRp?ii ; i)zY
|
|||
|
|
Load a task collection based on parsed core args, or die trying.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
r] )r9 <00>start)<02> loaded_from<6F>auto_dash_namesz%Can't find any collection named {!r}!N)r<> r<> rf r9 rZ <00>load<61>set_project_location<6F> load_projectr <00> from_moduler<65> r r r r' rd )rU r
<00>loader<65> coll_namer<65> <00>parentr? s & r) r<> <00>Program.load_collection<6F> s<> <00> <00> <15> <09> <09>-<2D>(<28>.<2E>.<2E><05><15>"<22>"<22><17>;<3B>;<3B>e<EFBFBD> #<23>
|
|||
|
|
<EFBFBD><06> <19>I<EFBFBD>I<EFBFBD>(<28>(<28>.<2E>.<2E> <09> O<01> #<23>[<5B>[<5B><19> 3<>N<EFBFBD>F<EFBFBD>
|
|||
|
|
<11>K<EFBFBD>K<EFBFBD> ,<2C> ,<2C>V<EFBFBD> 4<> <10>K<EFBFBD>K<EFBFBD> $<24> $<24> &<26> (<28> 4<> 4<><16> "<22> $<24> <0B> <0B> 1<> 1<> A<> A<> <0E>D<EFBFBD>O<EFBFBD><4F>
|
|||
|
|
"<22> O<01><16>><3E>E<>E<>a<EFBFBD>f<EFBFBD>f<EFBFBD>M<>N<> N<><4E> O<01>s <00> BC" <00>" D<03>-$D<03>Dc <00>@ <<01> V ^8<> d QhRS[ RS[S[S[3, RR/# )r$ <00>context<78>new_argsr% N)r r rS r )r' r( s "<22>r) r* r+ <00> s- <00><> <00> 6<> 6<>$<24> 6<>04<30>S<EFBFBD>#<23>X<EFBFBD><0E> 6<>
<0A> 6r, c <08><> <00> VP 4 F; w r4VP ' g K VP VP V, n K= R # <00>N)<04>items<6D> got_value<75>_valuer<65> )rU r r <00>key<65>args &&& r) <00>_update_core_context<78> Program._update_core_context<78> s5 <00> <00> !<21><0E><0E>(<28>H<EFBFBD>C<EFBFBD><12>}<7D>}<7D>}<7D>+.<2E>:<3A>:<3A><07> <0C> <0C>S<EFBFBD>!<21>(<28> )r, c <00> <<01> V ^8<> d QhRS[ /# r<> )r )r' r( s "<22>r) r* r+ <00> s <00><> <00>
|
|||
|
|
<EFBFBD>
|
|||
|
|
<EFBFBD>f<EFBFBD>
|
|||
|
|
r, c <08><> <00> \ V P V P P V P P
|
|||
|
|
P R 7 R7 # ))<01>ignore_unknown_help)r r<> )r r<> rZ <00> to_contextsr9 r<> r& rT s &r) r<> <00>Program._make_parser<65> sB <00> <00><15><18>(<28>(<28><19>_<EFBFBD>_<EFBFBD>0<>0<>$(<28>K<EFBFBD>K<EFBFBD>$5<>$5<>$I<>$I<> 1<> <0E>
|
|||
|
|
<EFBFBD>
|
|||
|
|
r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ <00> s <00><> <00> B<01> B<01>T<EFBFBD> Br, c <0C><> <00> V P 4 V n \ RP V P 4 4 V P P V P P 4 pVP ^ 4 V n V P V P ^ , V P P R7 Wn \ RP V P 4 4 R# )a<>
|
|||
|
|
Parse leftover args, which are typically tasks & per-task args.
|
|||
|
|
|
|||
|
|
Sets ``self.parser`` to the parser used, ``self.tasks`` to the
|
|||
|
|
parsed per-task contexts, and ``self.core_via_tasks`` to a context
|
|||
|
|
holding any core flags seen within the task contexts.
|
|||
|
|
|
|||
|
|
Also modifies ``self.core`` to include the data from ``core_via_tasks``
|
|||
|
|
(so that it correctly reflects any supplied core flags regardless of
|
|||
|
|
where they appeared).
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
zParsing tasks against {!r})r r z Resulting task contexts: {!r}N)
r<> r<> r r' rZ r r<> r <00>pop<6F>core_via_tasksr" r<> r<> )rU r<> s & r) r<> <00>Program.parse_tasks<6B> s<> <00> <00> <1B>'<27>'<27>)<29><04> <0B>
<0A>*<2A>1<>1<>$<24>/<2F>/<2F>B<>C<><15><1B><1B>'<27>'<27><04> <09> <09>(:<3A>(:<3A>;<3B><06> $<24>j<EFBFBD>j<EFBFBD><11>m<EFBFBD><04><1B> <0C>!<21>!<21><18>I<EFBFBD>I<EFBFBD>a<EFBFBD>L<EFBFBD>4<EFBFBD>+><3E>+><3E>+C<>+C<> "<22>
|
|||
|
|
<EFBFBD> <1C>
|
|||
|
|
<EFBFBD>
<0A>-<2D>4<>4<>T<EFBFBD>Z<EFBFBD>Z<EFBFBD>@<40>Ar, c <00>$ <<01> V ^8<> d QhRS[ RR/# )r$ rd r% Nr<4E> )r' r( s "<22>r) r* r+ s <00><> <00> <16> <16>C<EFBFBD> <16>D<EFBFBD> r, c <0C><> <00> V P P V, pVP 4 p\ P ! V P
|
|||
|
|
V, 4 pRpV' d RMRp\
VP V P W4 4 \
R4 \
R4 V' dc VP 4 FB pVP 4 ' d \
V P V, 4 K7 \
R4 KD \
R4 M'\
V P R, 4 \
R4 \
R4 V' d V P V4 R# \
V P R, 4 \
R4 R# )zX
|
|||
|
|
Print help for a specific task, e.g. ``inv --help <taskname>``.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
z3Usage: {} [--core-opts] {} {}[other tasks here ...]z [--options] r6 z
|
|||
|
|
Docstring:<3A>nonezOptions:N)
r<> r<> r<> <00>inspect<63>getdocrZ r<> r' re <00>
|
|||
|
|
splitlines<EFBFBD>strip<69>leading_indentr<74> )rU rd <00>ctx<74>tuples<65> docstring<6E>header<65>opts<74>lines && r) r<> <00>Program.print_task_help s <00> <00> <13>k<EFBFBD>k<EFBFBD>"<22>"<22>4<EFBFBD>(<28><03><14> <1F> <1F>"<22><06><1B>N<EFBFBD>N<EFBFBD>4<EFBFBD>?<3F>?<3F>4<EFBFBD>#8<>9<> <09>F<><06>!'<27>~<7E>R<EFBFBD><04>
<0A>f<EFBFBD>m<EFBFBD>m<EFBFBD>D<EFBFBD>K<EFBFBD>K<EFBFBD><14>4<>5<>
<0A>b<EFBFBD> <09>
<0A>l<EFBFBD><1B> <14>!<21>,<2C>,<2C>.<2E><04><17>:<3A>:<3A><<3C><<3C><19>$<24>-<2D>-<2D><04>4<>5<><19>"<22>I<EFBFBD> /<2F>
|
|||
|
|
<12>"<22>I<EFBFBD> <11>$<24>%<25>%<25><06>.<2E> /<2F> <11>"<22>I<EFBFBD>
<0A>j<EFBFBD><19> <11> <10> <1E> <1E>v<EFBFBD> &<26> <11>$<24>%<25>%<25><06>.<2E> /<2F> <11>"<22>Ir, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ ' s <00><> <00> <<3C> <<3C>D<EFBFBD> <r, c <08><> <00> V P pV' g' R p\ VP VP 4 4 h\ V RP V P
|
|||
|
|
4 4 ! 4 R# )z"No tasks found in collection '{}'!zlist_{}N)r<> r r' rd r<> r<> )rU <00>focusr<73> s & r) r<> <00>Program.list_tasks' sM <00> <00><14>&<26>&<26><05><14>6<>C<EFBFBD><16>s<EFBFBD>z<EFBFBD>z<EFBFBD>%<25>*<2A>*<2A>-<2D>.<2E> .<2E> <10><04>i<EFBFBD>&<26>&<26>t<EFBFBD>'7<>'7<>8<>9<>;r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ 1 s <00><> <00> /<2F> /<2F>4<EFBFBD> /r, c <08>` <00> V P V P 4 pV P VR 7 R# ))<01>pairsN<73><03> _make_pairsr<73> <00>display_with_columns)rU rC s & r) <00> list_flat<61>Program.list_flat1 s) <00> <00><14> <20> <20><14>!7<>!7<>8<><05> <0C>!<21>!<21><05>!<21>.r, c <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ 5 s <00><> <00> <<3C> <<3C>T<EFBFBD> <r, c <08>d <00> V P V P 4 pR pV P WR7 R# )z '*' denotes collection defaults)rC <00>extraNrD )rU rC rK s & r) <00> list_nested<65>Program.list_nested5 s. <00> <00><14> <20> <20><14>!7<>!7<>8<><05>1<><05> <0C>!<21>!<21><05>!<21>;r, c
|
|||
|
|
<00><> <<01> V ^8<> d QhRRRS[ S[S[, , RS[S[S[S[ S[, 3, , /# )r$ <00>collr <00> ancestorsr% )r r rS r
|
|||
|
|
)r' r( s "<22>r) r* r+ : sJ <00><> <00> C<15> C<15><1A>C<15> <1C>D<EFBFBD><13>I<EFBFBD>&<26>C<15>
|
|||
|
|
<0E>e<EFBFBD>C<EFBFBD><18>#<23> <1D>&<26>'<27> (<28> Cr, c <08>: <00> Vf . p. p\ V4 V P , pRP R V 4 4 p\ VP P 4 4 EF| w rgWaP 8H pTp \ \ VP \ VP 4 4 4 p
|
|||
|
|
V' g V P ' d2 RP V 4 p V
|
|||
|
|
U u. uF p RP V 4 NK p
|
|||
|
|
p V P R8X d Tp V' d
|
|||
|
|
V R,
p V P R8X d_ Tp V ' d V P ' d
|
|||
|
|
RV , p V
|
|||
|
|
U
u. uF q<>V
, NK
p
|
|||
|
|
p
V' d V' d V
|
|||
|
|
P ^ V 4 V
|
|||
|
|
' d! RP RP V
|
|||
|
|
4 4 MR pX V , V, pVP V\! V4 34 EK V P" ;' d \ V4 ^, V P" 8<> p\ VP$ P 4 4 EFP w ppTp V' g V P ' d RP V 4 p V' dp R
Uu. uF< p\' VV4 ' g K R
|
|||
|
|
P \ \' VV4 4 V4 NK> ppV R P RP V4 4 ,
p V P R8X d$ VP WI, \! V4 34 M;V P R8X d+ V' d# VP WY, \! V4 34 V' d EK% V P) VW&., R 7 pVP+ V4 EKS V# u up i u up
i u upi )Nr<4E> c 3 <00>$ " <00> T F qx <00> K R # 5ir rt <00><02>.0<EFBFBD>xs & r) <00> <genexpr><3E>&Program._make_pairs.<locals>.<genexpr>C s <00> <00> <00> 6<>I<EFBFBD>q<EFBFBD><11>I<EFBFBD>s <00><01>.{}<7D>nested<65>*r5 z ({})z, r6 r<> z [{}])rO rP )r<> <00> collections)<16>len<65>indent<6E>join<69>sortedr<64> r r2 rB <00>map<61> transform<72>aliasesr<73> r' r<> <00>insert<72>appendr r<> r[ r<> rE <00>extend)rU rO rP rC r] <00>
ancestor_pathrd <00>task<73>
|
|||
|
|
is_default<EFBFBD> displaynamerb rU <00>prefix<69>alias<61> alias_str<74>full<6C>truncate<74>subcoll<6C>attr<74>tallies<65>recursed_pairss &&& r) rE <00>Program._make_pairs: s<> <00> <00>
|
|||
|
|
<15> <1C><1A>I<EFBFBD><12><05><14>Y<EFBFBD> <1E>$<24>+<2B>+<2B>-<2D><06><1B><08><08> 6<>I<EFBFBD> 6<>6<>
<0A> <20><14><1A><1A>!1<>!1<>!3<>4<>J<EFBFBD>D<EFBFBD> <1D> <1C> <1C>-<2D>J<EFBFBD> <1F>K<EFBFBD><1A>3<EFBFBD>t<EFBFBD>~<7E>~<7E>v<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>/C<>D<>E<>G<EFBFBD> <19>D<EFBFBD>N<EFBFBD>N<EFBFBD>N<EFBFBD> #<23>l<EFBFBD>l<EFBFBD>;<3B> 7<> <0B>4;<3B><<3C>G<EFBFBD>q<EFBFBD>5<EFBFBD><<3C><<3C><01>?<3F>G<EFBFBD><07><<3C><13> <1F> <1F>8<EFBFBD>+<2B> <1F><06> <1D> <1F>3<EFBFBD>&<26>K<EFBFBD> <14> <1F> <1F>6<EFBFBD>)<29>&<26><06> <1A>d<EFBFBD>n<EFBFBD>n<EFBFBD>n<EFBFBD> <20>6<EFBFBD>\<5C>F<EFBFBD>7><3E>?<3F>w<EFBFBD>e<EFBFBD>E<EFBFBD>><3E>><3E>w<EFBFBD><07>?<3F> <1D>)<29><1B>N<EFBFBD>N<EFBFBD>1<EFBFBD>f<EFBFBD>-<2D>>E<><07><0E><0E>t<EFBFBD>y<EFBFBD>y<EFBFBD><17>'9<>:<3A>2<EFBFBD>I<EFBFBD><19>K<EFBFBD>'<27>)<29>3<>D<EFBFBD> <11>L<EFBFBD>L<EFBFBD>$<24><08><14><0E>/<2F> 0<>A 5<>D <18>?<3F>?<3F>N<>N<><03>I<EFBFBD><0E><11>(:<3A>t<EFBFBD><EFBFBD><EFBFBD>'N<><08> #<23>D<EFBFBD>$4<>$4<>$:<3A>$:<3A>$<<3C> =<3D>M<EFBFBD>D<EFBFBD>'<27> <1E>K<EFBFBD><18>D<EFBFBD>N<EFBFBD>N<EFBFBD>N<EFBFBD> #<23>l<EFBFBD>l<EFBFBD>;<3B> 7<> <0B><17> !9<><12> 8<><04> <1E>w<EFBFBD><04>-<2D> F<01>G<EFBFBD>N<EFBFBD>N<EFBFBD>3<EFBFBD>w<EFBFBD>w<EFBFBD><04>'=<3D>#><3E><04>E<> 8<> <18> <12>
|
|||
|
|
<1C>w<EFBFBD>~<7E>~<7E>d<EFBFBD>i<EFBFBD>i<EFBFBD><07>.@<40> A<>A<> <0B><13> <1F> <1F>8<EFBFBD>+<2B><15> <0C> <0C>f<EFBFBD> 2<>H<EFBFBD>W<EFBFBD>4E<34> F<>G<><15>!<21>!<21>V<EFBFBD>+<2B><08><15> <0C> <0C>m<EFBFBD> 9<>8<EFBFBD>G<EFBFBD>;L<> M<>N<><1B>8<EFBFBD>!%<25>!1<>!1<> <20>I<EFBFBD><06>,><3E> "2<> "<12><0E> <16> <0C> <0C>^<5E>,<2C>+ ><3E>, <15> <0C><>] =<3D><> @<01><> s <00>N<06>N<06>7N<06>)Nc <00> <<01> V ^8<> d QhRR/# rs rt )r' r( s "<22>r) r* r+ s <00><> <00> <20> <20>4<EFBFBD> r, c <08><> <00> V P ' d \ R 4 hV P pVP 4 p\ \
|
|||
|
|
P ! V4 4 R# )z:The --list-depth option is not supported with JSON format!N)r<> r r<> <00>
|
|||
|
|
serializedr<EFBFBD> <00>json<6F>dumps)rU rO <00>datas & r) <00> list_json<6F>Program.list_json sG <00> <00>
|
|||
|
|
<10>?<3F>?<3F>?<3F><16>L<><0E>
<0E> <14>%<25>%<25><04><13><EFBFBD><EFBFBD> <20><04>
<0A>d<EFBFBD>j<EFBFBD>j<EFBFBD><14> <1E> r, c <00>& <<01> V ^8<> d QhRS[ RS[ /# )r$ rK r% r<> )r' r( s "<22>r) r* r+ <00> s <00><> <00> <14> <14>c<EFBFBD> <14>3<EFBFBD> r, c <08>T <00> V P pV P pV' d R P V4 MRpRpV' g V' dB V' d RP V4 MRpV' d V' d RMRpRP WgV4 pRP WE4 pV P e RpV# )<07> '{}'r6 zdepth={}z; z ({}{}{})zAvailable{} tasks{}<7D> Subcommands)r<> r<> r' rc ) rU rK <00>root<6F>depth<74> specifier<65>tail<69>depthstr<74>joiner<65>texts && r) <00>task_list_opener<65>Program.task_list_opener<65> s<> <00> <00><13>~<7E>~<7E><04><14><0F><0F><05>,0<>G<EFBFBD>N<EFBFBD>N<EFBFBD>4<EFBFBD>(<28>b<EFBFBD> <09><11><04> <10>E<EFBFBD>38<33>z<EFBFBD>(<28>(<28><15>/<2F>b<EFBFBD>H<EFBFBD> #<23><05>T<EFBFBD>B<EFBFBD>F<EFBFBD> <1E>%<25>%<25>h<EFBFBD><05>><3E>D<EFBFBD>$<24>+<2B>+<2B>I<EFBFBD><<3C><04> <10>><3E>><3E> %<25> <20>D<EFBFBD><13> r, c <00>` <<01> V ^8<> d QhRS[ S[S[S[S[, 3, , RS[RR/# )r$ rC rK r% N<>r r
|
|||
|
|
rS r )r' r( s "<22>r) r* r+ <00> s= <00><> <00> D<01> D<01> <1D>e<EFBFBD>C<EFBFBD><18>#<23> <1D>$6<> 7<>8<>D<01>AD<41>D<01>
<0A>Dr, c <08>` <00> V P p\ R P V P VR7 4 4 V P V4 V P
|
|||
|
|
P pV' dI RpV' d# RP V4 pRP V4 p\ RP WT4 4 R# R# )z{}:
|
|||
|
|
)rK r6 r~ rX zDefault{} task: {}
|
|||
|
|
N)r<> r<> r' r<> r<> r<> r2 )rU rC rK r<> r2 <00>specifics &&& r) rF <00> Program.display_with_columns<6E> s<> <00> <00> <14>~<7E>~<7E><04>
<0A>g<EFBFBD>n<EFBFBD>n<EFBFBD>T<EFBFBD> 2<> 2<><15> 2<> ?<3F>@<40>A<> <0C><1A><1A>5<EFBFBD>!<21> <17>(<28>(<28>0<>0<><07> <12><19>H<EFBFBD><13>"<22>><3E>><3E>$<24>/<2F><08> <1F>,<2C>,<2C>w<EFBFBD>/<2F><07> <11>(<28>/<2F>/<2F><08>B<> C<>
r, c <00>Z <<01> V ^8<> d QhRS[ S[S[S[S[, 3, , RR/# )r$ r7 r% Nr<4E> )r' r( s "<22>r) r* r+ <00> s0 <00><> <00> +<12> +<12> <1E>u<EFBFBD>S<EFBFBD>(<28>3<EFBFBD>-<2D>%7<> 8<>9<>+<12>
<0A>+r, c <0C><> <00> \ R V 4 4 p\ 4 ^ , V,
|
|||
|
|
V P ,
|
|||
|
|
V P ,
|
|||
|
|
^,
|
|||
|
|
p\ P
|
|||
|
|
! VR7 pV F<> w rVVf RpVP
V4 pV\ V4 ,
|
|||
|
|
pRP V P VVR, V P R, 34 p V' dM \ W<>^ , , 4 VR, F% p
|
|||
|
|
\ R\ V 4 , V
|
|||
|
|
, 4 K' K<> \ V P 4 4 K<> \ R4 R# )z<>
|
|||
|
|
Print tabbed columns from (name, help) ``tuples``.
|
|||
|
|
|
|||
|
|
Useful for listing tasks + docstrings, flags + help strings, etc.
|
|||
|
|
|
|||
|
|
.. versionadded:: 1.0
|
|||
|
|
c 3 <00>F " <00> T F p\ V^ , 4 x <00> K R# 5i)r N)r\ rS s & r) rV <00>(Program.print_columns.<locals>.<genexpr><3E> s <00> <00> <00>3<>F<EFBFBD>q<EFBFBD><13>Q<EFBFBD>q<EFBFBD>T<EFBFBD><19><19>F<EFBFBD>s <00> !)<01>widthNr6 ra r ) <0C>maxr <00>leading_indent_width<74> col_padding<6E>textwrap<61> TextWrapper<65>wrapr\ r^ r5 r<> <00>rstrip) rU r7 <00>
|
|||
|
|
name_width<EFBFBD>
|
|||
|
|
desc_width<EFBFBD>wrapperrd <00>help_str<74> help_chunks<6B> name_padding<6E>spec<65>chunks && r) r<> <00>Program.print_columns<6E> s <00> <00> <19>3<>F<EFBFBD>3<>3<>
|
|||
|
|
<EFBFBD> <14>J<EFBFBD>q<EFBFBD>M<EFBFBD><18>
<19><12>'<27>'<27>
(<28> <13> <1E> <1E>
<1F> <10>
<10> <13> <1B>&<26>&<26>Z<EFBFBD>8<><07> $<24>N<EFBFBD>D<EFBFBD><17> <1F> <1D><08>!<21>,<2C>,<2C>x<EFBFBD>0<>K<EFBFBD>%<25><03>D<EFBFBD> <09>1<>L<EFBFBD><15>7<EFBFBD>7<EFBFBD><18>'<27>'<27><18> <20>3<EFBFBD>&<26><18>$<24>$<24>s<EFBFBD>*<2A> <12><0E>D<EFBFBD> <1B><15>d<EFBFBD><11>^<5E>+<2B>,<2C> (<28><12>_<EFBFBD>_<EFBFBD>E<EFBFBD><19>3<EFBFBD><13>T<EFBFBD><19>?<3F>e<EFBFBD>3<>4<> -<2D> <16>d<EFBFBD>k<EFBFBD>k<EFBFBD>m<EFBFBD>$<24>+ %<25>, <0E>b<EFBFBD> r, c <00>@ <<01> V ^8<> d Qh/ R;R& S[ S[, ;R& # )r$ r r<> ro r<> )r' r( s "<22>r) r* r+ s$ <00><> <00> <00> <18><17> <01>j <0F>s<EFBFBD>)<29>O<EFBFBD>k r, )rm rn rl ro rZ r9 rh r<> r, rg r<> r<> r<> rf rc r<> r<> r<> rL )NNNNNNNN)T)NTr )r6 )0<>__name__<5F>
|
|||
|
|
__module__<EFBFBD> __qualname__<5F>__firstlineno__<5F>__doc__rV r_ r<> r5 <00> indent_widthr] r<> rp rv r<> r r<> r<> r<> r<> r<> r<> <00>propertyrd r<> re ri r<> r<> r<> r<> r<> r<> r" r<> r<> r<> r<> rG rL rE rz r<> rF r<> <00>__annotate_func__<5F>__static_attributes__<5F>__classdictcell__)r( s @r) r! r! s<> <00><> <00> <00> <08> f
|
|||
|
|
<EFBFBD> f
|
|||
|
|
<EFBFBD>P
|
|||
|
|
<EFBFBD>
|
|||
|
|
<EFBFBD>@ <1D><18><18>/<2F>/<2F>N<EFBFBD><14>L<EFBFBD>
<10><<3C>
<1F>F<EFBFBD><13>K<EFBFBD>_3<> _3<>B
*<2A>
*<2A> 3 <20> 3 <20>jC<18> C<18>J <17> <17>< 1<> 1<>H<"<22> <"<22>|<13> <13>&<26> &<26>4<19> <19>. <0E>6<> <0E>6<> <0E>
|
|||
|
|
C<01> <0E>
|
|||
|
|
C<01> <0E>.<2E> <0E>.<2E> <0E>6<> <0E>6<> <0E>!<21> <0E>!<21> <0E> (<28> <0E> (<28> D<01> D<01>
|
|||
|
|
<1E>
|
|||
|
|
<1E> 9<> 9<> O<01> O<01>: 6<> 6<>
|
|||
|
|
<EFBFBD>
|
|||
|
|
<EFBFBD>B<01> B<01>0 <16> <16>B<<3C> <<3C>/<2F> /<2F><<3C> <<3C>
|
|||
|
|
C<15> C<15>J <20> <20> <14> <14> D<01> D<01>"+<12> +<12>a <01> r, r! )-r<> r1 rw r<> r<> r<> <00> importlibr <00>typingr r r r r r r
|
|||
|
|
r r6 r r
r r <00>completion.completer r r<> r r r <00>
|
|||
|
|
exceptionsr r r r <00> terminalsr <00>utilr r r r r r r r! rt r, r) <00><module>r<> sa <00><01> <0E> <0E> <0B> <09>
|
|||
|
|
<EFBFBD> <0F> #<23> <02> <02> <02> =<3D> <<3C> B<> 3<> 3<> L<> L<> <1F> 1<> 1<><10> <1E>#<23> <1D>{<12> {r,
|