zjZddlZddlmZddlmZmZmZmZmZm Z ddl m Z m Z ddl mZmZddlmZddlmZGd d Zy) N) ModuleType)AnyCallableDictListOptionalTuple)Lexiconhelpline) merge_dicts copy_dict)Context)TaskceZdZdZdededdfdZd3dedeeddfd Zdefd Z d e de fd Z de fd Z e d4dedeedeeeefdeedee ddf dZ d5dddeedeeedfdee ddf dZ d6dddeedee ddfdZdeddfdZdedeeeffdZdeddfdZd3deedefdZded ed!eeefdeeeeefffd"Zdeedeeeeefffd#Zdede fd$Z d3d%ee deefd&Zd'ed(edefd)Zdedefd*Z d+e!de!fd,Z"e#deeeeffd-Z$d3d.eedeeeffd/Z%d0eeefddfd1Z&deeeffd2Z'y)7 Collectionzg A collection of executable tasks. See :doc:`/concepts/namespaces`. .. versionadded:: 1.0 argskwargsreturnNct|_t|_d|_d|_i|_|j dd|_|j dd|_|jd|_t|}|r8t|dtr%|j|j d|_|D]}|j||jD]\}}|j||y)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 `. * 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 loaded_fromauto_dash_namesTr)r tasks collectionsdefaultname_configurationpoprrlist isinstancestr transform _add_objectitems)selfrr_argsargrobjs R/var/www/api.ozpay.ru/ozpay/venv/lib/python3.12/site-packages/invoke/collection.py__init__zCollection.__init__sVY "9&*  .0!::mT:%zz*;TB    '#'D T  ZQ-uyy|4DI "C   S ! "  (ID#   S$ ' (r(rct|tr |j}nFt|ttfr |j }n#t djt||||y)NzNo idea how to insert {!r}!r) r radd_taskrradd_collection TypeErrorformattype)r%r(rmethods r)r#zCollection._add_objecttsT c4 ]]F j*5 6((F9@@cKL Lsr+c >t|jj}|jjDcgc]}dj |}}dj |j dj t|t|zScc}w)Nz{}...zz, )rrkeysrr1rjoinsorted)r% task_namesxrs r)__repr__zCollection.__repr__~s|$**//+, 262B2B2G2G2IJQw~~a(J J&-- IItyy !3f[6I!IJ  KsBotherct|trO|j|jk(xr4|j|jk(xr|j|jk(Sy)NF)r rrrr)r%r;s r)__eq__zCollection.__eq__sT eZ ( UZZ':JJ%++-:$$(9(99  r+c,t|jSN)boolr8)r%s r)__bool__zCollection.__bool__sDOO$$r+moduleconfigrrcjjddd dttddffd }dD]}t |d}|st |t s$||j } | j|j| _ | j|j| _ |jr| j|jnd| _ t|j} |r t| || | _| cSt!d t#j%} |} | D]} | j'| |r| j)|| S) 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 .Nobj_namerrcj xs|xsg}t}|i|}j|_|S)N)rr)dict__doc__) rGrrinstancerclsrrB module_namers r) instantiatez+Collection.from_module..instantiatesH3H3 4D'FD+F+H%~~H Or+)ns namespace)rGc"t|tSr?)r rr9s r)z(Collection.from_module..s At!4r+r?)__name__splitrr!getattrr rr_transform_lexiconrrrr"rrr filtervarsvaluesr. configure)rLrBrrCrrrN candidater(ret obj_configr collectiontaskrMs``` `` @r) from_modulezCollection.from_modulesBhoo++C04  (3- <  - I&)T2Cz#z2!388422399= "%"8"8"I25++CMM#++.4 's'9'9:  F3%/"  "4d6l6I6I6KL ]  &D    % &    (r+r`raliases.rc|t|jr |j}n[t|jdr|jj}n.t|jdr |j}n t d|j |}||jvrd}t |j|||j|<t|jt|xsgzD].}|jj|j ||0|dus|&|jr|j|||_yyy)a 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 func_namerTz&Could not obtain a name for this task!zFName conflict: this collection has a sub-collection named {!r} already)toT)rhasattrbodyrdrT ValueErrorr"rr1rrrbalias is_default_check_default_collisionr)r%r`rrbrerrris r)r.zCollection.add_tasks4 <yyyyK0yy**J/}} !IJJ~~d# 4## #ZCSZZ-. . 4$,,'$w}"*== =E JJ  T^^E2t  < = d?w4??  ) )$ /DL4Cr+collcRt|trtj|}|xs |j}|s t d|j |}||jvrd}t |j|||j|<|r|j|||_ yy)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>tD fT&)D)))r+cR|j}|s(|js td||j|fS|j|}d|vr'|j |\}}|j |||S||j vr|j |d|S|j||fS)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.rE) configurationrrhr"rur~rr)r%rr|rmrts r)ryzCollection.task_with_config|s$!!#<< !GHH %t+ +~~d# $;))$/JD$00tTB B 4## #00r4@ @zz$%%r+c. ||y#t$rYywxYw)NTF)KeyErrorrzs r) __contains__zCollection.__contains__s#  J  s  ignore_unknown_helpc g}|jjD]7\}}||}|jt|||j |9|S)aw 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)rrbr)r8r$append ParserContext get_arguments)r%rresultprimaryrbr`s r) to_contextszCollection.to_contextssj $ 5 5 7  GW=D MM #++,?,   r+collection_name task_namecddj|j||j|gS)NrE)r6r")r%rrs r) subtask_namezCollection.subtask_names-xx ^^O ,dnnY.G H  r+c|s|Sd\}}|jsd\}}g}t|dz }t|D]9\}}|d|fvr||k(r||dz dk7r ||dzdk7r|}|j|;dj |S)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 )_-)rrr rrEr)rlen enumeraterr6)r%rfrom_rereplacedendichars r)r"zCollection.transforms K r## IE2$i!m  "GAt!S!EMQK3&QK3& OOD ! "wwx  r+oldc>t}|jD],\}}tj|||j |<.|j jD]6\}}|j |j ||j |8|S)zr Take a Lexicon and apply `.transform` to its keys and aliases. :returns: A new Lexicon. )rre)r r$copydeepcopyr"rbri)r%rnewkeyvalues r)rWzCollection._transform_lexicons i))+ .s$"3"3Iq"Ar+) rr$rmapr"rbrr8rr)r%r]rr`rmrrbrs` @r)r8zCollection.task_namess****, @JD$S>?CI @ $//557 GOIt&*oo&;&;&= G" 7A7K <<9, |+G?FD%%i;< G G r+taskpathcX|t|jS|j|dS)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 )rrry)r%rs r)rzCollection.configuration s1  T001 1$$X.q11r+optionsc0t|j|y)a7 (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%rs r)r[zCollection.configure2s" D''1r+c|jt||jt|jj dDcgc]Q}|j |jt||jDcgc]}|j |c}dSc}}t|jj dDcgc]}|jc}dScc}wcc}}wcc}w)z 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 c|jSr?r-rRs r)rSz'Collection.serialized..Xs 166r+)r)rhelprbc"|jxsdS)Nrr-rRs r)rSz'Collection.serialized..]sQVV\rr+)rrrrr) rr rr7rrZr"rbr serialized)r%r9ys r)rzCollection.serializedEsIITN||  1 1 39IJ   !NN1662$QK;<99Eaq 1E $$++-3I    F s 7C, C'C, C2 'C, r?)NNNN)NNN)NN)(rT __module__ __qualname__rJrr*rr!r#r:objectr@r=rA classmethodrrrar r.r/rkrurwr{r~ryrrrrrr"r rWpropertyr8rr[rr+r)rr s/ _(c_(S_(T_(Bs(3-4 # Ft%$%#+/%)*. ZZsmZc3h( Z c] Z "$ Z ZZ~#-1"& - - sm- %S/* - $ -  - d#"& ' ' sm' $ '  ' R=S=T=  c3h  C L . .. **"**.sCx.* sDcN" #* "&SM"& sDcN" #"&H59#+D> m 8 C C C %!c%!c%!Ng'"Dd3i0>2hsm2tCH~2$2c3h2D2& DcN r+r)rtypesrtypingrrrrrr utilr r rCr rparserrrrrrrr+r)rs) ==#*,T  T  r+