&NjN SrSSKrSSKrSSKJr SSKJr SSKJrJ r J r J r J r J r JrJrJrJrJrJrJr SSKJr SSKJrJrJr \(a SS KJr SS KJr \"S \ S 9r"S S\ \5rS\ S\ S\ 4Sjr "SS5r!SSS\ S\ SS4Sjr"g)zb This module contains the core `.Task` class & convenience decorators used to generate new tasks. N)deepcopy)update_wrapper) TYPE_CHECKINGAnyCallableDictGenericIterableListOptionalSetTupleTypeTypeVarUnion)Context)Argument ParseResulttranslate_underscores) Signature)ConfigT)boundc\rSrSrSrS$S\S\\S\\S\\\S\\S \ S \ S \\ \\ 4S \\ \ \\4S \\ \ \\4S\ S\\\S\\\SS4Sjjr\S\4Sj5rS\4SjrS\S\ 4SjrS\4SjrS\ S\ S\4Sjr\S\ 4Sj5rS\SS4SjrS\\\S\\4SjrS\S \S\\S\ \\ 44S jrS%S!\\ S\ \4S"jjrS#rg)&Task%a/ Core object representing an executable task & its argument specification. For the most part, this object is a clearinghouse for all of the data that may be supplied to the `@task ` decorator, such as ``name``, ``aliases``, ``positional`` etc, which appear as attributes. In addition, instantiation copies some introspection/documentation friendly metadata off of the supplied ``body`` object, such as ``__doc__``, ``__name__`` and ``__module__``, allowing it to "appear as" ``body`` for most intents and purposes. .. versionadded:: 1.0 Nbodynamealiases positionaloptionaldefaultauto_shortflagshelpprepost autoprintiterable incrementablereturncXl[XR5 [USS5Ul[USS5Ul[USS5UlX lX0lX`lURU5Ul [U5Ul U =(d /Ul U =(d /UlXplU=(d 0R!5UlU =(d /UlU =(d /UlSUlXlg)N__doc____name__ __module__r)rrgetattrr-r/r0_namer is_defaultfill_implicit_positionalsr!tupler"r)r*r$copyr%r&r' times_calledr()selfrrr r!r"r#r$r%r&r'r(r)r*s I/home/mande/repo/quber/.venv/lib/python3.13/site-packages/invoke/tasks.py__init__ Task.__init__<s" tYY'tY3 j"5 !$ b9  !88Dh  B *0b.ZR%%' 9"JB "c@UR=(d UR$N)r2r/r8s r9r Task.namegszz*T]]*r<cSnUR(a*SRSRUR55nSRURU5$)Nr.z ({})z, z )r formatjoinr)r8r s r9__repr__ Task.__repr__ks@ <<nnTYYt||%<=G%%dii99r<otherc[U[5(aURUR:wagURUR:XagURRURR:H$![ a gf=f)NFT) isinstancerrr__code__AttributeError)r8rFs r9__eq__ Task.__eq__qsl%&&$))uzz*A 99 " yy))UZZ-@-@@@!  s ,A:: BBcX[UR5[UR5-$r>)hashrrr?s r9__hash__ Task.__hash__sDIIdii00r<argskwargsc[US[5(d(Sn[UR[ US555eUR "U0UD6nU=R S- slU$)Nrz9Task expected a Context as its first arg, got {} instead!r)rHr TypeErrorrBtyperr7)r8rQrRerrresults r9__call__ Task.__call__s]$q'7++MCCJJtDG}56 6D+F+ Q r<c URS:$)Nr)r7r?s r9called Task.calleds  1$$r<rc*[U[R5(aUnO URn[R "U5n[ URR55n[U5(d [S5eURUSSS9$)a Returns a modified `inspect.Signature` based on that of ``body``. :returns: an `inspect.Signature` matching that of ``body``, but with the initial context argument removed. :raises TypeError: if the task lacks an initial positional `.Context` argument. .. versionadded:: 1.0 .. versionchanged:: 2.0 Changed from returning a two-tuple of ``(arg_names, spec_dict)`` to returning an `inspect.Signature`. z,Tasks must have an initial Context argument!rN) parameters) rHtypes FunctionTyperXinspect signaturelistr^valueslenrTreplace)r8rfuncsigparamss r9argspec Task.argspecsz dE.. / /D==D%cnn++-.6{{JK K{{fQRj{11r<cUcvURUR5RR5Vs/sH8nUR[ R RLdM,URPM: nnU$s snfr>) rjrr^rdr#raremptyr)r8r!xs r9r4Task.fill_implicit_positionalsss  dii0;;BBDDA99 1 1 7 77D   s +A<(A< taken_namesch0nXR;US'XR;US'XR;a[US'UbUO/US'XR;aSUS'UnSU;aXS'[ U5nU/nUR (a(UH"nXq:XaM Xs;aMURU5 O XdS 'US[RR4;a&[U5nUS(a U[LdXS'X$S'X4H3n XR;dMURRU 5US ' U$ U$) Nr!r"kindr#Tr*_ attr_namenamesr%)r!r"r)rcr*rr$appendrarrmrUboolr%pop) r8rr#rpopts original_namerucharrr possibilitys r9arg_opts Task.arg_optss> "!__4\==0Z == DL*1)) r/r0 __qualname____firstlineno__r-rr strr rwrrrr r:propertyrrDobjectrKintrOrrXr[rjr4r r}rr__static_attributes__rr<r9rr%s 2#!#.2"$ $)-/304,015)#)#sm)## )# Xc]+ )# 3- )#)#)#tCH~&)#eDIsN+ ,)#uT#Y^,-)#)#8C=))#  .)# )#V+c++:#: F t 1#1 cSQ%%%2H22< "8C=1  # //"%/47H/ c3h/d59/#+D>/ h//r<rrQrRr+c4^^TRS[5m[U5S:Xa7[US5(a$[ US[5(d T"US40TD6$U(aST;a [ S5eUTS'S[ S[[4UU4SjjnU$) a Marks wrapped callable object as a valid Invoke task. May be called without any parentheses if no extra options need to be specified. Otherwise, the following keyword arguments are allowed in the parenthese'd form: * ``name``: Default name to use when binding to a `.Collection`. Useful for avoiding Python namespace issues (i.e. when the desired CLI level name can't or shouldn't be used as the Python level name.) * ``aliases``: Specify one or more aliases for this task, allowing it to be invoked as multiple different names. For example, a task named ``mytask`` with a simple ``@task`` wrapper may only be invoked as ``"mytask"``. Changing the decorator to be ``@task(aliases=['myothertask'])`` allows invocation as ``"mytask"`` *or* ``"myothertask"``. * ``positional``: Iterable overriding the parser's automatic "args with no default value are considered positional" behavior. If a list of arg names, no args besides those named in this iterable will be considered positional. (This means that an empty list will force all arguments to be given as explicit flags.) * ``optional``: Iterable of argument names, declaring those args to have :ref:`optional values `. Such arguments may be given as value-taking options (e.g. ``--my-arg=myvalue``, wherein the task is given ``"myvalue"``) or as Boolean flags (``--my-arg``, resulting in ``True``). * ``iterable``: Iterable of argument names, declaring them to :ref:`build iterable values `. * ``incrementable``: Iterable of argument names, declaring them to :ref:`increment their values `. * ``default``: Boolean option specifying whether this task should be its collection's default task (i.e. called if the collection's own name is given.) * ``auto_shortflags``: Whether or not to automatically create short flags from task options; defaults to True. * ``help``: Dict mapping argument names to their help strings. Will be displayed in ``--help`` output. For arguments containing underscores (which are transformed into dashes on the CLI by default), either the dashed or underscored version may be supplied here. * ``pre``, ``post``: Lists of task objects to execute prior to, or after, the wrapped task whenever it is executed. * ``autoprint``: Boolean determining whether to automatically print this task's return value to standard output when invoked directly via the CLI. Defaults to False. * ``klass``: Class to instantiate/return. Defaults to `.Task`. If any non-keyword arguments are given, they are taken as the value of the ``pre`` kwarg for convenience's sake. (It is an error to give both ``*args`` and ``pre`` at the same time.) .. versionadded:: 1.0 .. versionchanged:: 1.1 Added the ``klass`` keyword argument. klassrrr&z2May not give *args and 'pre' kwarg simultaneously!rr+c>T"U40TD6nU$r>r)r_taskrrRs r9innertask..innercsd%f% r<)rxrrecallablerHrTrr)rQrRrrs ` @r9taskr!sl 7D1E 4yA~(47++JtAw4M4MT!W''' F?D u Ha Lr<c \rSrSrSrSSSS\\S\\\S4S \\\\ 4S S4 S jjr S \S \ 4S jr S\ S S4Sjr S \4SjrS\ S \4SjrSSSSS \4SjrS \\\ 44SjrSS\\SS\\\\ 4S S4SjjrSrg)Callikz Represents a call/execution of a `.Task` with given (kw)args. Similar to `~functools.partial` with some added functionality (such as the delegation to the inner task, and optional tracking of the name it's being called by.) .. versionadded:: 1.0 Nrr called_asrQ.rRr+c|XlX lU=(d [5UlU=(d [ 5Ulg)a Create a new `.Call` object. :param task: The `.Task` object to be executed. :param str called_as: The name the task is being called as, e.g. if it was called by an alias or other rebinding. Defaults to ``None``, aka, the task was referred to by its default name. :param tuple args: Positional arguments to call with, if any. Default: ``None``. :param dict kwargs: Keyword arguments to call with, if any. Default: ``None``. N)rrr5rQdictrR)r8rrrQrRs r9r: Call.__init__vs). "OEG & r<rc.[URU5$r>)r1r)r8rs r9 __getattr__Call.__getattr__styy$''r<memoc"UR5$r>)clone)r8rs r9 __deepcopy__Call.__deepcopy__szz|r<c@SnURb?URURR:waSRUR5nSRURR URRUUR UR5$)Nr.z (called as: {!r})z%<{} {!r}{}, args: {!r}, kwargs: {!r}>)rrrrB __class__r/rQrR)r8akas r9rD Call.__repr__st >> %$..DIINN*J&--dnn=C6== NN # # IINN  II KK   r<rFcfSR5Hn[X5[X5:wdM g g)Nztask args kwargsFT)splitr1)r8rFattrs r9rK Call.__eq__s1 ',,.Dt"ge&::/r<configrcore_parse_resultrc([XRS9$)z Generate a `.Context` appropriate for this call, with given config. .. versionadded:: 1.0 .. versionchanged:: 3.0 Added the ``core_parse_result`` parameter. )r remainder)rr)r8rrs r9 make_contextCall.make_contextsf0K0KLLr<c[URUR[UR5[UR 5S9$)zY Return keyword args suitable for cloning this call into another. .. versionadded:: 1.1 )rrrQrR)rrrrrQrRr?s r9 clone_dataCall.clone_datas7 nn$))$DKK(   r<intowith_c|UbUO URnUR5nUbURU5 U"S0UD6$)a Return a standalone copy of this Call. Useful when parameterizing task executions. :param into: A subclass to generate instead of the current class. Optional. :param dict with_: A dict of additional keyword arguments to use when creating the new clone; typically used when cloning ``into`` a subclass that has extra args on top of the base class. Optional. .. note:: This dict is used to ``.update()`` the original object's data (the return value from its `clone_data`), so in the event of a conflict, values in ``with_`` will win out. .. versionadded:: 1.0 .. versionchanged:: 1.1 Added the ``with_`` kwarg. r)rrr)r8rrrdatas r9r Call.clones>6(dnn    KK }t}r<)rQrrRr)NNN)NN)r/r0rrr-r rrrrr:rrrrDrwrKrrrrrrrr<r9rrks'$(*.+/ ''C='uS#X' ' c3h( '  ':(((F  #  Ft M M) M  M  DcN  (,*.tF|$S#X'  r<rrc[XUS9$)a  Describes execution of a `.Task`, typically with pre-supplied arguments. Useful for setting up :ref:`pre/post task invocations `. It's actually just a convenient wrapper around the `.Call` class, which may be used directly instead if desired. For example, here's two build-like tasks that both refer to a ``setup`` pre-task, one with no baked-in argument values (and thus no need to use `.call`), and one that toggles a boolean flag:: @task def setup(c, clean=False): if clean: c.run("rm -rf target") # ... setup things here ... c.run("tar czvf target.tgz target") @task(pre=[setup]) def build(c): c.run("build, accounting for leftover files...") @task(pre=[call(setup, clean=True)]) def clean_build(c): c.run("build, assuming clean slate...") Please see the constructor docs for `.Call` for details - this function's ``args`` and ``kwargs`` map directly to the same arguments as in that method. .. versionadded:: 1.0 )rQrR)r)rrQrRs r9callrsB  //r<)#r-rar_r6r functoolsrtypingrrrrr r r r r rrrrcontextrparserrrrrrrrrrrrrr<r9rs  $ @@! Cx y71:yxGGsGxGT~~B!0v!0c!0S!0V!0r<