ServerSync/lib/invoke/__pycache__/collection.cpython-314.pyc

+
t<10>iZ<00><00><><00>^R
It^RI
Ht^RIHtHtHtHtHtH	t	^
RI
HtHt^
RI
HtHt^
RIHt^
RIHt!RR	4tR
#)
<EFBFBD>N)
<01>
ModuleType)<06>Any<6E>Callable<6C>Dict<63>List<73>Optional<61>Tuple)<02>Lexicon<6F>helpline)<02>merge_dicts<74>	copy_dict)
<01>Context)
<01>Taskc<00><>
a<00>]t
Rt^toR
tV3
RlRltR2V3
RlRll
tV3
RlRltV3
R	lR
ltV3
RlRlt	]
R3V3
R
lRll
4tR4V3
RlRll
tR5V3
RlRll
t
V3
RlRltV3
RlRltV3
RlRltR2V3
RlRll
tV3
RlRltV3
RlRltV3
RlR ltR2V3
R!lR"ll
tV3
R#lR$ltV3
R%lR&ltV3
R'lR(lt]V3
R)lR*l4tR2V3
R+lR,ll
tV3
R-lR.ltV3
R/lR0ltR1tVtR#)6<>
Collectionz[
A collection of executable tasks. See :doc:`/concepts/namespaces`.

.. versionadded:: 1.0
c

<00>*<
<01>V^8<>dQ
h
R
S
[RS
[RR/#)<05><00>args<67>kwargs<67>returnN)
r)<02>format<61>
__classdict__s"<22><>8/tmp/pip-target-zhdecbcm/lib/python/invoke/collection.py<70>__annotate__<5F>Collection.__annotate__s'<00><><00>_
(<28>_
(<28>c<EFBFBD>_
(<28>S<EFBFBD>_
(<28>T<EFBFBD>_
(<28>c
<0C>$<00>\
4Vn
\
4VnR
VnR
Vn/VnVP
RR
4VnVP
RR
4VnVPfRVn\V
4
pV'dC\V
^,\4'd&VPVP
^4
4
VnVFpVPV4
K	VP4FwrVVPWe4K	R
#)a<>	
Create a new task collection/namespace.

`.Collection` offers a set of methods for building a collection of
tasks from scratch, plus a convenient constructor wrapping said API.

In either case:

* The first positional argument may be a string, which (if given) is
  used as the collection's default name when performing namespace
  lookups;
* A ``loaded_from`` keyword argument may be given, which sets metadata
  indicating the filesystem path the collection was loaded from. This
  is used as a guide when loading per-project :ref:`configuration files
  <config-hierarchy>`.
* An ``auto_dash_names`` kwarg may be given, controlling whether task
  and collection names have underscores turned to dashes in most cases;
  it defaults to ``True`` but may be set to ``False`` to disable.

  The CLI machinery will pass in the value of the
  ``tasks.auto_dash_names`` config value to this kwarg.

**The method approach**

May initialize with no arguments and use methods (e.g.
`.add_task`/`.add_collection`) to insert objects::

    c = Collection()
    c.add_task(some_task)

If an initial string argument is given, it is used as the default name
for this collection, should it be inserted into another collection as a
sub-namespace::

    docs = Collection('docs')
    docs.add_task(doc_task)
    ns = Collection()
    ns.add_task(top_level_task)
    ns.add_collection(docs)
    # Valid identifiers are now 'top_level_task' and 'docs.doc_task'
    # (assuming the task objects were actually named the same as the
    # variables we're using :))

For details, see the API docs for the rest of the class.

**The constructor approach**

All ``*args`` given to `.Collection` (besides the abovementioned
optional positional 'name' argument and ``loaded_from`` kwarg) are
expected to be `.Task` or `.Collection` instances which will be passed
to `.add_task`/`.add_collection` as appropriate. Module objects are
also valid (as they are for `.add_collection`). For example, the below
snippet results in the same two task identifiers as the one above::

    ns = Collection(top_level_task, Collection('docs', doc_task))

If any ``**kwargs`` are given, the keywords are used as the initial
name arguments for the respective values::

    ns = Collection(
        top_level_task=some_other_task,
        docs=Collection(doc_task)
    )

That's exactly equivalent to::

    docs = Collection(doc_task)
    ns = Collection()
    ns.add_task(some_other_task, 'top_level_task')
    ns.add_collection(docs, 'docs')

See individual methods' API docs for details.
N<EFBFBD>loaded_from<6F>auto_dash_namesT)r
<00>tasks<6B>collections<6E>default<6C>name<6D>_configuration<6F>poprr<00>list<73>
isinstance<EFBFBD>str<74>	transform<72>_add_object<63>items)<07>selfrr<00>_args<67>argr#<00>objs&*,    r<00>__init__<5F>Collection.__init__s<><00><00>V<1D>Y<EFBFBD><04>
<EFBFBD>"<22>9<EFBFBD><04><18>&*<2A><04><0C><18><04>	<09>.0<EFBFBD><04><1B>!<21>:<3A>:<3A>m<EFBFBD>T<EFBFBD>:<3A><04><18>%<25>z<EFBFBD>z<EFBFBD>*;<3B>T<EFBFBD>B<><04><1C><0F><1F><1F>'<27>#'<27>D<EFBFBD> <20><14>T<EFBFBD>
<EFBFBD><05><10>Z<EFBFBD><04>Q<EFBFBD><07><13>-<2D>-<2D><1C><0E><0E>u<EFBFBD>y<EFBFBD>y<EFBFBD><11>|<7C>4<>D<EFBFBD>I<EFBFBD><18>C<EFBFBD><10><1C><1C>S<EFBFBD>!<21><19> <20><1C><1C><1E>I<EFBFBD>D<EFBFBD><10><1C><1C>S<EFBFBD>'<27>(rNc

<00>:<
<01>V^8<>dQ
h
R
S
[RS
[
S
[,RR/#)rr/r#rN)rrr()rrs"<22>rrrts&<00><><00><1F><1F>s<EFBFBD><1F>(<28>3<EFBFBD>-<2D><1F>4<EFBFBD>rc<08><><00>\
V
\4'dVPpML\
V
\\34'dVP
pM#\
RP\V
4
4
4
h
V!WR
7R#)zNo idea how to insert {!r}!<21>
r#N)	r'r<00>add_taskrr<00>add_collection<6F>	TypeErrorr<00>type)r,r/r#<00>methods&&& rr*<00>Collection._add_objecttsX<00><00><15>c<EFBFBD>4<EFBFBD> <20> <20><19>]<5D>]<5D>F<EFBFBD>
<17><03>j<EFBFBD>*<2A>5<>
6<>
6<><19>(<28>(<28>F<EFBFBD><1B>9<>@<40>@<40><14>c<EFBFBD><19>K<>L<>L<><0E>s<EFBFBD>rc

<00> <
<01>V^8<>dQ
h
R
S
[/
#<00>rr<00>
r()rrs"<22>rrr~s<00><><00>
<EFBFBD>
<EFBFBD>#<23>
rc
	<08>J
<00>\
VPP44
p
VPP4Uu.uFpRP	V4
NK	ppR
P	VP
RP
\V
4
\V4
,4
4#uupi)z{}...z<Collection {!r}: {}>z, )r&r <00>keysr!rr#<00>join<69>sorted)r,<00>
task_names<EFBFBD>
xr!s&   r<00>__repr__<5F>Collection.__repr__~s<00><00><19>$<24>*<2A>*<2A>/<2F>/<2F>+<2B>,<2C>
<EFBFBD>26<EFBFBD>2B<EFBFBD>2B<EFBFBD>2G<EFBFBD>2G<EFBFBD>2I<EFBFBD>J<>2I<32>Q<EFBFBD>w<EFBFBD>~<7E>~<7E>a<EFBFBD>(<28>2I<32><0B>J<>&<26>-<2D>-<2D><10>I<EFBFBD>I<EFBFBD>t<EFBFBD>y<EFBFBD>y<EFBFBD><16>
<EFBFBD>!3<>f<EFBFBD>[<5B>6I<36>!I<>J<>
<EFBFBD>	
<EFBFBD><EFBFBD>K
s<00>B c

<00>&<
<01>V^8<>dQ
h
R
S
[RS
[
/#)r<00>otherr)<02>object<63>bool)rrs"<22>rrr<00>s<00><><00><15><15>F<EFBFBD><15>t<EFBFBD>rc<08><><00>\
V
\4'd\VPV
P8H;
'd;VPV
P8H;
'dVPV
P8H#R#)
F)r'rr#r r!)r,rGs&&r<00>__eq__<5F>Collection.__eq__<5F>sa<00><00><15>e<EFBFBD>Z<EFBFBD>(<28>(<28><14>	<09>	<09>U<EFBFBD>Z<EFBFBD>Z<EFBFBD>'<27>:<3A>:<3A><18>J<EFBFBD>J<EFBFBD>%<25>+<2B>+<2B>-<2D>:<3A>:<3A><18>$<24>$<24><05>(9<>(9<>9<>
<0E>
rc

<00> <
<01>V^8<>dQ
h
R
S
[/
#r<)
rI)rrs"<22>rrr<00>s<00><><00>
%<25>
%<25>$<24>
%rc
<08>,<00>\
VP4
#<00>
N)rIrB)
r,s
&r<00>__bool__<5F>Collection.__bool__<5F>s<00><00><13>D<EFBFBD>O<EFBFBD>O<EFBFBD>$<24>$rc

<00><><
<01>V^8<>dQ
h
R
S
[RS
[
S
[,RS
[
S
[S
[S
[3,,RS
[
S
[,RS
[
S
[,RR/#)r<00>moduler#<00>configrrrr)rrr(rrrI)rrs"<22>rrr<00>sh<00><><00>Z
<1A>Z
<1A><1A>Z
<1A><17>s<EFBFBD>m<EFBFBD>Z
<1A><19><14>c<EFBFBD>3<EFBFBD>h<EFBFBD><1E>(<28>	Z
<1A>
<1E>c<EFBFBD>]<5D>Z
<1A>"<22>$<24><1E>
Z
<1A>
<16>Z
rc<0C>aa
aaaa<0E>S
PPR
4
R,oRRVVVV
VV3Rlll
pR	F<>p\S
VR4pV'gK\V\4'gK2V!VP
R7
p	V	P
VP4
V	nV	P
VP4
V	nVP'dV	PVP4
M
RV	n	\VP4
p
V'd\W<>4W<>nV	u#	\R\S
4
P!44pV!4pVFp
VP#V
4
K	V'dVP%V4
V#)
a#
Return a new `.Collection` created from ``module``.

Inspects ``module`` for any `.Task` instances and adds them to a new
`.Collection`, returning it. If any explicit namespace collections
exist (named ``ns`` or ``namespace``) a copy of that collection object
is preferentially loaded instead.

When the implicit/default collection is generated, it will be named
after the module's ``__name__`` attribute, or its last dotted section
if it's a submodule. (I.e. it should usually map to the actual ``.py``
filename.)

Explicitly given collections will only be given that module-derived
name if they don't already have a valid ``.name`` attribute.

If the module has a docstring (``__doc__``) it is copied onto the
resulting `.Collection` (and used for display in help, list etc
output.)

:param str name:
    A string, which if given will override any automatically derived
    collection name (or name set on the module's root namespace, if it
    has one.)

:param dict config:
    Used to set config options on the newly created `.Collection`
    before returning it (saving you a call to `.configure`.)

    If the imported module had a root namespace object, ``config`` is
    merged on top of it (i.e. overriding any conflicts.)

:param str loaded_from:
    Identical to the same-named kwarg from the regular class
    constructor - should be the path where the module was
    found.

:param bool auto_dash_names:
    Identical to the same-named kwarg from the regular class
    constructor - determines whether emitted names are auto-dashed.

.. versionadded:: 1.0
<EFBFBD>
.Nc

<00>><00>V^8<>dQ
h
R
\\,RR/#)r<00>obj_namerr)rr()
rs
"rr<00>,Collection.from_module.<locals>.__annotate__<5F>s<00><00>		<1C>		<1C>(<28>3<EFBFBD>-<2D>		<1C><<3C>		rc
<00><><<06>S	;
'g
T;
'gS.
p
\
SSR7pS!V
/VB
pSPVn
V#)
)rr)<02>dict<63>__doc__)
rXrr<00>instancer<00>clsrrS<00>module_namer#s
&   <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>r<00>instantiate<74>+Collection.from_module.<locals>.instantiate<74>sN<00><><00><19>3<>3<>H<EFBFBD>3<>3<><0B>4<>D<EFBFBD><19>'<27><1F><0E>F<EFBFBD><1B>D<EFBFBD>+<2B>F<EFBFBD>+<2B>H<EFBFBD>%<25>~<7E>~<7E>H<EFBFBD><1C><1B>Or)
rXc
<00>"<00>\
V\4#rO)r'r<00>
rCs
&r<00><lambda><3E>(Collection.from_module.<locals>.<lambda><3E>s<00><00><1A>A<EFBFBD>t<EFBFBD>!4r<00><><EFBFBD><EFBFBD><EFBFBD>rO)<02>ns<6E>	namespace)<13>__name__<5F>split<69>getattrr'rr#<00>_transform_lexiconr r!r"r)r
r$r<00>filter<65>vars<72>valuesr5<00>	configure)r^rSr#rTrrr`<00>	candidater/<00>ret<65>
obj_configr <00>
collection<EFBFBD>taskr_sfff&ff        @r<00>from_module<6C>Collection.from_module<6C>s)
<00><><00>h
<1D>o<EFBFBD>o<EFBFBD>+<2B>+<2B>C<EFBFBD>0<><12>4<><0B>		<1C>		<1C>-<2D>I<EFBFBD><19>&<26>)<29>T<EFBFBD>2<>C<EFBFBD><12>s<EFBFBD>z<EFBFBD>#<23>z<EFBFBD>2<>2<>!<21>3<EFBFBD>8<EFBFBD>8<EFBFBD>4<><03><1F>2<>2<>3<EFBFBD>9<EFBFBD>9<EFBFBD>=<3D><03>	<09>"%<25>"8<>"8<><13><1F><1F>"I<><03><0F>25<32>+<2B>+<2B>+<2B>C<EFBFBD>M<EFBFBD>M<EFBFBD>#<23>+<2B>+<2B>.<2E>4<EFBFBD><14><0B>'<27>s<EFBFBD>'9<>'9<>:<3A>
<EFBFBD><19><1F>
<EFBFBD>3<>%/<2F>"<22><1A>
<EFBFBD>-<2D>"<17>4<>d<EFBFBD>6<EFBFBD>l<EFBFBD>6I<36>6I<36>6K<36>L<><05> <20>]<5D>
<EFBFBD><19>D<EFBFBD><16><1F><1F><04>%<25><1A><11><16> <20> <20><16>(<28><19>rc


<00>x<
<01>V^8<>dQ
h
R
RRS
[S
[
,RS
[S
[S
[
R3,,RS
[S
[,RR/#)	rrurr#<00>aliases.r"rN)rr(r	rI)rrs"<22>rrr<00>sR<00><><00>- <20>- <20><14>- <20><17>s<EFBFBD>m<EFBFBD>- <20><1A>%<25><03>S<EFBFBD><08>/<2F>*<2A>	- <20>
<1A>$<24><1E>- <20>
<0E>
- rc<0C><><00>Vf<>V
P'dV
PpMg\V
PR4'dV
PPpM4\V
PR4'dV
PpM\R4
h
VP
V4
pW P9dRp\VPV4
4
h
WPV&\V
P4
\T;
'g.4
,F/pVPPVP
V4
VR7K1	VRJgVf.V
P'dVPV4
W nR
#R
#R
#)a1
Add `.Task` ``task`` to this collection.

:param task: The `.Task` object to add to this collection.

:param name:
    Optional string name to bind to (overrides the task's own
    self-defined ``name`` attribute and/or any Python identifier (i.e.
    ``.func_name``.)

:param aliases:
    Optional iterable of additional names to bind the task as, on top
    of the primary name. These will be used in addition to any aliases
    the task itself declares internally.

:param default: Whether this task should be the collection default.

.. versionadded:: 1.0
N<EFBFBD>	func_nameriz&Could not obtain a name for this task!zFName conflict: this collection has a sub-collection named {!r} already)
<01>toT)r#<00>hasattr<74>bodyr{ri<00>
ValueErrorr)r!rr r&ry<00>alias<61>
is_default<EFBFBD>_check_default_collisionr")r,rur#ryr"<00>errr<72>s&&&&&  rr5<00>Collection.add_task<73>s
<00><00>4<10><<3C><13>y<EFBFBD>y<EFBFBD>y<EFBFBD><1B>y<EFBFBD>y<EFBFBD><04><18><14><19><19>K<EFBFBD>0<>0<><1B>y<EFBFBD>y<EFBFBD>*<2A>*<2A><04><18><14><19><19>J<EFBFBD>/<2F>/<2F><1B>}<7D>}<7D><04> <20>!I<>J<>J<><13>~<7E>~<7E>d<EFBFBD>#<23><04><0F>#<23>#<23>#<23>Z<>C<EFBFBD><1C>S<EFBFBD>Z<EFBFBD>Z<EFBFBD><04>-<2D>.<2E>.<2E><1F>
<EFBFBD>
<EFBFBD>4<EFBFBD><18><19>$<24>,<2C>,<2C>'<27>$<24>w<EFBFBD>}<7D>}<7D>"<22>*=<3D>=<3D>=<3D>E<EFBFBD><10>J<EFBFBD>J<EFBFBD><1C><1C>T<EFBFBD>^<5E>^<5E>E<EFBFBD>2<>t<EFBFBD><1C><<3C>><3E><12>d<EFBFBD>?<3F>w<EFBFBD><EFBFBD>4<EFBFBD>?<3F>?<3F>?<3F><10>)<29>)<29>$<24>/<2F><1F>L<EFBFBD>4C
<01>rc

<00>N<
<01>V^8<>dQ
h
R
RRS
[S
[
,RS
[S
[,RR/#)r<00>collrr#r"rN)rr(rI)rrs"<22>rrr
s;<00><><00>' <20>' <20><1A>' <20><17>s<EFBFBD>m<EFBFBD>' <20><1A>$<24><1E>	' <20>

<0E>' rc<0C><>
<00>\
V
\4'd\PV
4
p
T;
'g
V
PpV'g\R
4
h
VP
V4
pW P9dRp\VPV4
4
h
WPV&V'dVPV4
W nR#R#)a<>

Add `.Collection` ``coll`` as a sub-collection of this one.

:param coll: The `.Collection` to add.

:param str name:
    The name to attach the collection as. Defaults to the collection's
    own internal name.

:param default:
    Whether this sub-collection('s default task-or-collection) should
    be the default invocation of the parent collection.

.. versionadded:: 1.0
.. versionchanged:: 1.5
    Added the ``default`` parameter.
z&Non-root collections must have a name!z<Name conflict: this collection has a task named {!r} alreadyN)r'rrrvr#rr)r rr!r<>r")r,r<>r#r"r<>s&&&& rr6<00>Collection.add_collection
s<><00><00>0<16>d<EFBFBD>J<EFBFBD>'<27>'<27><1D>)<29>)<29>$<24>/<2F>D<EFBFBD><13> <20> <20>t<EFBFBD>y<EFBFBD>y<EFBFBD><04><13><1C>E<>F<>F<><13>~<7E>~<7E>d<EFBFBD>#<23><04><0F>:<3A>:<3A><1D>P<>C<EFBFBD><1C>S<EFBFBD>Z<EFBFBD>Z<EFBFBD><04>-<2D>.<2E>.<2E>!%<25><18><18><14><1E><12><10>)<29>)<29>$<24>/<2F><1F>L<EFBFBD>rc

<00>$<
<01>V^8<>dQ
h
R
S
[RR/#)rr#rNr=)rrs"<22>rrrF
s<00><><00>=<3D>=<3D>S<EFBFBD>=<3D>T<EFBFBD>=rc<08>v<00>VP'd'Rp\VPWP44
h
R
#)z3'{}' cannot be the default because '{}' already is!N)r"rr)r,r#<00>msgs&& rr<><00>#Collection._check_default_collisionF
s-<00><00><0F><<3C><<3C><<3C>G<>C<EFBFBD><1C>S<EFBFBD>Z<EFBFBD>Z<EFBFBD><04>l<EFBFBD>l<EFBFBD>;<3B><<3C><<3C>rc

<00><<
<01>V^8<>dQ
h
R
S
[RS
[
S
[S
[3,/#)r<00>pathr)r(r	)rrs"<22>rrrK
s#<00><><00>
<1A>
<1A><03>
<1A><05>c<EFBFBD>3<EFBFBD>h<EFBFBD><0F>
rc<0C>n<00>V
P
R
4
pVP^4
pR
PV4
pW43#)a

Obtain first collection + remainder, of a task path.

E.g. for ``"subcollection.taskname"``, return ``("subcollection",
"taskname")``; for ``"subcollection.nested.taskname"`` return
``("subcollection", "nested.taskname")``, etc.

An empty path becomes simply ``('', '')``.
rV)rjr%r@)r,r<><00>partsr<73><00>rests&&   r<00>_split_path<74>Collection._split_pathK
s3<00><00><15>
<EFBFBD>
<EFBFBD>3<EFBFBD><0F><05><14>y<EFBFBD>y<EFBFBD><11>|<7C><04><12>x<EFBFBD>x<EFBFBD><05><EFBFBD><04><13>z<EFBFBD>rc

<00>$<
<01>V^8<>dQ
h
R
S
[RR/#)rr<>rrr=)rrs"<22>rrrZ
s<00><><00>
<1A>
<1A>C<EFBFBD>
<1A>L<EFBFBD>
rc<0C><><00>V
P
R
4
pTpV'd%VPVP^4
,pK,V#)zX
Given a ``path`` to a subcollection, return that subcollection.

.. versionadded:: 1.0
rV)rjr!r%)r,r<>r<>rts&&  r<00>subcollection_from_path<74>"Collection.subcollection_from_pathZ
s7<00><00><15>
<EFBFBD>
<EFBFBD>3<EFBFBD><0F><05><19>
<EFBFBD><13>#<23>/<2F>/<2F><05>	<09>	<09>!<21><0C>=<3D>J<EFBFBD><19>rc

<00>6<
<01>V^8<>dQ
h
R
S
[S
[
,RS
[/#<00>rr#r)rr(r)rrs"<22>rrrf
s<00><><00>.<2E>.<2E><08><13>
<0A>.<2E><13>.rc<0C>2<00>VP
V
4
^,#)
a<>

Returns task named ``name``. Honors aliases and subcollections.

If this collection has a default task, it is returned when ``name`` is
empty or ``None``. If empty input is given and no task has been
selected as the default, ValueError will be raised.

Tasks within subcollections should be given in dotted form, e.g.
'foo.bar'. Subcollection default tasks will be returned on the
subcollection's name.

.. versionadded:: 1.0
)
<01>task_with_config<69>r,r#s&&r<00>__getitem__<5F>Collection.__getitem__f
s<00><00><14>$<24>$<24>T<EFBFBD>*<2A>1<EFBFBD>-<2D>-rc

<00>t<
<01>V^8<>dQ
h
R
S
[RS
[RS
[
S
[S
[3,RS
[S
[S
[
S
[S
[3,3,/#)rr<>r<><00>oursr)r(rrr	)rrs"<22>rrrv
sG<00><><00>*<2A>*<2A><17>*<2A>"<22>*<2A>*.<2E>s<EFBFBD>C<EFBFBD>x<EFBFBD>.<2E>*<2A>	<0E>s<EFBFBD>D<EFBFBD><13>c<EFBFBD><18>N<EFBFBD>"<22>	#<23>*rc<08>f<00>VPV
,PV4
wrEV\V3
/VB
3#rO)r!r<>r[)r,r<>r<>r<>rurTs&&&&  r<00>_task_with_merged_config<69>#Collection._task_with_merged_configv
s6<00><00><1C>'<27>'<27><04>-<2D>><3E>><3E>t<EFBFBD>D<><0C><04><13>T<EFBFBD>&<26>)<29>D<EFBFBD>)<29>)<29>)rc

<00>b<
<01>V^8<>dQ
h
R
S
[S
[
,RS
[S
[
S
[S
[
S
[3,3,/#r<>)rr(r	rr)rrs"<22>rrr|
s3<00><><00>"&<26>"&<26><1C>S<EFBFBD>M<EFBFBD>"&<26>	<0E>s<EFBFBD>D<EFBFBD><13>c<EFBFBD><18>N<EFBFBD>"<22>	#<23>"&rc<0C>~
<00>VP
4pV
'g2VP'g\R
4
h
WP,V3#VPV
4
p
RV
9d&VP	V
4
wr4VPW4V4#WP9dVPV
RV4#VPV
,V3#)a<>

Return task named ``name`` plus its configuration dict.

E.g. in a deeply nested tree, this method returns the `.Task`, and a
configuration dict created by merging that of this `.Collection` and
any nested `Collections <.Collection>`, up through the one actually
holding the `.Task`.

See `~.Collection.__getitem__` for semantics of the ``name`` argument.

:returns: Two-tuple of (`.Task`, `dict`).

.. versionadded:: 1.0
z$This collection has no default task.rV<00>)<08>
configurationr"rr)r<>r<>r!r )r,r#r<>r<>r<>s&&   rr<><00>Collection.task_with_config|
s<><00><00>$<14>!<21>!<21>#<23><04><13><17><<3C><<3C><<3C> <20>!G<>H<>H<><17><0C><0C>%<25>t<EFBFBD>+<2B>+<2B><13>~<7E>~<7E>d<EFBFBD>#<23><04><0E>$<24>;<3B><1D>)<29>)<29>$<24>/<2F>J<EFBFBD>D<EFBFBD><17>0<>0<><14>T<EFBFBD>B<>B<><0F>#<23>#<23>#<23><17>0<>0<><14>r<EFBFBD>4<EFBFBD>@<40>@<40><13>z<EFBFBD>z<EFBFBD>$<24><1F><14>%<25>%rc

<00>&<
<01>V^8<>dQ
h
R
S
[RS
[
/#r<>)r(rI)rrs"<22>rrr<00>
s<00><><00><19><19><13><19><14>rc<08><<00>W
,R# \dR
#i;i
)TF)
<01>KeyErrorr<72>s&&r<00>__contains__<5F>Collection.__contains__<5F>
s!<00><00>	<19><10>J<EFBFBD><17><><17>
	<19><18>
	<19>s<00><00><03>
c

<00>F<
<01>V^8<>dQ
h
R
S
[S
[
,RS
[S
[,/#)r<00>ignore_unknown_helpr)rrIr<00>
ParserContext)rrs"<22>rrr<00>
s&<00><><00><16><16>#+<2B>D<EFBFBD>><3E><16>	
<0A>m<EFBFBD>	<1C>rc<0C><><00>.pVPP4F:wr4W,pVP\VVVP	V
R
7
R74
K<	V#)a7

Returns all contained tasks and subtasks as a list of parser contexts.

:param bool ignore_unknown_help:
    Passed on to each task's ``get_arguments()`` method. See the config
    option by the same name for details.

.. versionadded:: 1.0
.. versionchanged:: 1.7
    Added the ``ignore_unknown_help`` kwarg.
)
r<>)r#ryr)rBr+<00>appendr<64><00>
get_arguments)r,r<><00>result<6C>primaryryrus&&    r<00>to_contexts<74>Collection.to_contexts<74>
sa<00><00><14><06> $<24><0F><0F> 5<> 5<> 7<><1C>G<EFBFBD><17>=<3D>D<EFBFBD><12>M<EFBFBD>M<EFBFBD><1D> <20>#<23><1D>+<2B>+<2B>,?<3F>,<2C><16><12>
<0E>!8<><16>
rc

<00>,<
<01>V^8<>dQ
h
R
S
[RS
[RS
[/#)r<00>collection_name<6D>	task_namerr=)rrs"<22>rrr<00>
s"<00><><00>
<EFBFBD>
<EFBFBD>C<EFBFBD>
<EFBFBD>C<EFBFBD>
<EFBFBD>C<EFBFBD>
rc<08>d<00>RP
VPV
4
VPV4
.4
#)
rV)r@r))r,r<>r<>s&&&r<00>subtask_name<6D>Collection.subtask_name<6D>
s-<00><00><12>x<EFBFBD>x<EFBFBD>
<11>^<5E>^<5E>O<EFBFBD>
,<2C>d<EFBFBD>n<EFBFBD>n<EFBFBD>Y<EFBFBD>.G<>H<>
<EFBFBD>	
rc

<00>&<
<01>V^8<>dQ
h
R
S
[RS
[/#r<>r=)rrs"<22>rrr<00>
s<00><><00>%!<21>%!<21>c<EFBFBD>%!<21>c<EFBFBD>%!rc<0C>L
<00>V
'gV
#R
Rr2VP'gRR
r2.p\V
4
^
,
p\V
4
FOwrgV^V39
d1Wr8Xd+W^
,
,R8wdW^
,,R8wdTpVPV4
KQ	RP	V4
#)a~

Transform ``name`` with the configured auto-dashes behavior.

If the collection's ``auto_dash_names`` attribute is ``True``
(default), all non leading/trailing underscores are turned into dashes.
(Leading/trailing underscores tend to get stripped elsewhere in the
stack.)

If it is ``False``, the inverse is applied - all dashes are turned into
underscores.

.. versionadded:: 1.0
<EFBFBD>
_<>
-rVr<>)r<00>len<65>	enumerater<65>r@)r,r#<00>from_r|<00>replaced<65>end<6E>
i<>chars&&      rr)<00>Collection.transform<72>
s<><00><00> <14><17>K<EFBFBD><17><13>r<EFBFBD><13>#<23>#<23>#<23><1B>S<EFBFBD>2<EFBFBD><15><08><11>$<24>i<EFBFBD>!<21>m<EFBFBD><03> <20><14><EFBFBD>G<EFBFBD>A<EFBFBD><12>!<21>S<EFBFBD><18>!<21><18>M<EFBFBD><18>Q<EFBFBD><15>K<EFBFBD>3<EFBFBD>&<26><18>Q<EFBFBD><15>K<EFBFBD>3<EFBFBD>&<26><19><04><14>O<EFBFBD>O<EFBFBD>D<EFBFBD>!<21>'<27><12>w<EFBFBD>w<EFBFBD>x<EFBFBD> <20> rc

<00>&<
<01>V^8<>dQ
h
R
S
[RS
[/#)r<00>oldr)
r
)rrs"<22>rrr<00>
s<00><><00><13><13>g<EFBFBD><13>'<27>rc<0C>B
<00>\
4pV
P4F,wr4\P!V4
W P	V4
&K.	V
P
P4F6wr4VP
VP	V4
VP	V4
R
7K8	V#)zZ
Take a Lexicon and apply `.transform` to its keys and aliases.

:returns: A new Lexicon.
)r<>r|)r
r+<00>copy<70>deepcopyr)ryr<>)r,r<><00>new<65>key<65>values&&   rrl<00>Collection._transform_lexicon<6F>
s{<00><00><16>i<EFBFBD><03><1E>)<29>)<29>+<2B>J<EFBFBD>C<EFBFBD>'+<2B>}<7D>}<7D>U<EFBFBD>';<3B>C<EFBFBD><0E><0E>s<EFBFBD>#<23>$<24>&<26><1E>+<2B>+<2B>+<2B>+<2B>-<2D>J<EFBFBD>C<EFBFBD><0F>I<EFBFBD>I<EFBFBD>D<EFBFBD>N<EFBFBD>N<EFBFBD>3<EFBFBD>/<2F>D<EFBFBD>N<EFBFBD>N<EFBFBD>5<EFBFBD>4I<34>I<EFBFBD>J<>.<2E><12>
rc

<00>F<
<01>V^8<>dQ
h
R
S
[S
[
S
[S
[
,3,/
#r<)rr(r)rrs"<22>rrr
s!<00><><00><13><13>D<EFBFBD><13>d<EFBFBD>3<EFBFBD>i<EFBFBD><1E>0<>rc
<0C><>
aa<07>/p
SPP4F0wr#\\SPVP
44
W&K2	SPP4FrwopVPP4FNwrV\\VV3R
lV44
pVPV8XdVS3
,
pWaSPSV4&KP	Kt	V
#)a<>

Return all task identifiers for this collection as a one-level dict.

Specifically, a dict with the primary/"real" task names as the key, and
any aliases as a list value.

It basically collapses the namespace tree into a single
easily-scannable collection of invocation strings, and is thus suitable
for things like flat-style task listings or transformation into parser
contexts.

.. versionadded:: 1.0
c
<00>(<<02>SP
S
V4#rO)
r<>)rC<00>	coll_namer,s&<26><>rrd<00>'Collection.task_names.<locals>.<lambda>s<00><><00>$<24>"3<>"3<>I<EFBFBD>q<EFBFBD>"Ar)
r r+r&<00>mapr)ryr!rBr"r<>)r,rrr#rur<>r<>ryr<>sf      @rrB<00>Collection.task_namess<><00><><00><11><03><1E>*<2A>*<2A>*<2A>*<2A>,<2C>J<EFBFBD>D<EFBFBD><1C>S<EFBFBD><14><1E><1E><14><1C><1C>><3E>?<3F>C<EFBFBD>I<EFBFBD>-<2D> $<24>/<2F>/<2F>5<>5<>7<>O<EFBFBD>I<EFBFBD>t<EFBFBD>&*<2A>o<EFBFBD>o<EFBFBD>&;<3B>&;<3B>&=<3D>"<22>	<09><1E><17>A<>7<EFBFBD>K<><12><07>
<18><<3C><<3C>9<EFBFBD>,<2C><1B>	<09>|<7C>+<2B>G<EFBFBD>?F<>D<EFBFBD>%<25>%<25>i<EFBFBD><19>;<3B><<3C>'><3E> 8<><13>
rc

<00>L<
<01>V^8<>dQ
h
R
S
[S
[
,RS
[S
[
S
[3,/#)r<00>taskpathr)rr(rr)rrs"<22>rrr s'<00><><00>2<>2<>h<EFBFBD>s<EFBFBD>m<EFBFBD>2<>t<EFBFBD>C<EFBFBD><13>H<EFBFBD>~<7E>2rc<0C>d<00>V
f\
VP4
#VPV
4
^
,#)
a<>

Obtain merged configuration values from collection & children.

:param taskpath:
    (Optional) Task name/path, identical to that used for
    `~.Collection.__getitem__` (e.g. may be dotted for nested tasks,
    etc.) Used to decide which path to follow in the collection tree
    when merging config values.

:returns: A `dict` containing configuration values.

.. versionadded:: 1.0
)r
r$r<>)r,r<>s&&rr<><00>Collection.configuration s1<00><00><14><1B><1C>T<EFBFBD>0<>0<>1<>1<><13>$<24>$<24>X<EFBFBD>.<2E>q<EFBFBD>1<>1rc

<00>:<
<01>V^8<>dQ
h
R
S
[S
[
S
[3,RR/#)r<00>optionsrN<>rr(r)rrs"<22>rrr2s#<00><><00>2<>2<><14>c<EFBFBD>3<EFBFBD>h<EFBFBD><1E>2<>D<EFBFBD>2rc<0C>2<00>\
VPV
4R
#)a<>

(Recursively) merge ``options`` into the current `.configuration`.

Options configured this way will be available to all tasks. It is
recommended to use unique keys to avoid potential clashes with other
config options

For example, if you were configuring a Sphinx docs build target
directory, it's better to use a key like ``'sphinx.target'`` than
simply ``'target'``.

:param options: An object implementing the dictionary protocol.
:returns: ``None``.

.. versionadded:: 1.0
N)rr$)r,r<>s&&rrp<00>Collection.configure2s<00><00>"	<14>D<EFBFBD>'<27>'<27><17>1rc

<00>6<
<01>V^8<>dQ
h
R
S
[S
[
S
[3,/
#r<r<>)rrs"<22>rrrEs<00><><00>
<EFBFBD>
<EFBFBD>D<EFBFBD><13>c<EFBFBD><18>N<EFBFBD>
rc
<0C><00>R
VPR\V4
RVPR\VPP4RR7U
Uu.uFUp
R
VP
V
P4
R\V
4
RV
PUu.uFq P
V4
NK	up/NKW	upp
R\VPP4R	R7U
u.uFp
V
P4NK	up
/#uupiuupp
iuup
i)
z<EFBFBD>
Return an appropriate-for-serialization version of this object.

See the documentation for `.Program` and its ``json`` task listing
format; this method is the driver for that functionality.

.. versionadded:: 1.0
r#<00>helpr"r c

<00><00>VP#rOr4rcs
&rrd<00>'Collection.serialized.<locals>.<lambda>Xs<00><00>1<EFBFBD>6<EFBFBD>6r)
r<>ryr!c
<00>.<00>VP;
'gR#)
r<>r4rcs
&rrdr<>]s<00><00>Q<EFBFBD>V<EFBFBD>V<EFBFBD>\<5C>\<5C>r<EFBFBD>\r)
r#rr"rAr ror)ryr!<00>
serialized)r,rC<00>
ys&  rr<><00>Collection.serializedEs<><00><00>
<13>D<EFBFBD>I<EFBFBD>I<EFBFBD><12>H<EFBFBD>T<EFBFBD>N<EFBFBD><15>t<EFBFBD>|<7C>|<7C><13> <20><04>
<EFBFBD>
<EFBFBD> 1<> 1<> 3<>9I<39>J<>
<0E>K
<01>A<EFBFBD>	<1B>D<EFBFBD>N<EFBFBD>N<EFBFBD>1<EFBFBD>6<EFBFBD>6<EFBFBD>2<><1A>H<EFBFBD>Q<EFBFBD>K<EFBFBD><1D>1<EFBFBD>9<EFBFBD>9<EFBFBD>E<>9<EFBFBD>a<EFBFBD><0E><0E>q<EFBFBD> 1<>9<EFBFBD>E<><12>
K
<01>
<0E>
<1A><1F><18>$<24>$<24>+<2B>+<2B>-<2D>3I<33><12><0E><12>A<EFBFBD><12><0C><0C><0E><12><0E>
<EFBFBD>	
<EFBFBD><EFBFBD> F
<01><>	<0E><>s<00>:C7<14>C2$<24>!C7<14>C=<16>2C7)r$rr!r"rr#r rO)NNNN)NNN)NN) ri<00>
__module__<EFBFBD>__qualname__<5F>__firstlineno__r\r0r*rDrKrP<00>classmethodrvr5r6r<>r<>r<>r<>r<>r<>r<>r<>r<>r)rl<00>propertyrBr<>rpr<><00>__static_attributes__<5F>__classdictcell__)
rs
@rrrs
<00><><00><00><08>_
(<28>_
(<28>B<1F><1F>
<EFBFBD>
<EFBFBD><15><15>
%<25>
%<25><11>Z
<1A>Z
<1A><11>Z
<1A>x- <20>- <20>^
' <20>' <20>R
=<3D>=<3D>

<1A>
<1A>
<1A>
<1A>.<2E>.<2E> *<2A>*<2A>"&<26>"&<26>H
<19><19><16><16>8
<EFBFBD>
<EFBFBD>
%!<21>%!<21>N
<13><13>"<0E><13><0E><13>>2<>2<>$2<>2<>&
<EFBFBD>
rr)r<><00>typesr<00>typingrrrrrr	<00>utilr
rrTrr
<00>parserrr<>r rr<00>rr<00><module>r<>
s)<00>


<01><0B><1C>=<3D>=<3D>#<23>*<2A>,<2C><17>T	

<EFBFBD>T	

r