&NjEeSSKrSSKrSSKJr SSKJr SSKJr SSKJrJ r J r J r J r J r SSKJr SSKJrJr SS KJrJrJr SS KJrJr SS KJr "S S \5r"SS\5rg)N)contextmanager)cycle)PathLike)Any GeneratorIteratorListOptionalUnion)Mock)Config DataProxy) AuthFailureFailureResponseNotAccepted)ResultRunner)FailingResponderc\rSrSr%Sr\\\S'\\\S'\\S'SS\\ S\SS4S jjr \ S\ 4S j5r \ RS \ SS4S j5r S \S\S\4SjrSSS \S\S\4SjrS \S\S\4SjrSSS \S\S\4SjrS \S\4Sjr\S \S\S4Sj5r\ S\4Sj5r\S\\\4S\S4Sj5rSrg)Contexta Context-aware API wrapper & state-passing object. `.Context` objects are created during command-line parsing (or, if desired, by hand) and used to share parser and configuration state with executed tasks (see :ref:`why-context`). Specifically, the class offers wrappers for core API calls (such as `.run`) which take into account CLI parser flags, configuration files, and/or changes made at runtime. It also acts as a proxy for its `~.Context.config` attribute - see that attribute's documentation for details. Instances of `.Context` may be shared between tasks when executing sub-tasks - either the same context the caller was given, or an altered copy thereof (or, theoretically, a brand new one). .. versionadded:: 1.0 command_prefixes command_cwds remainderNconfigreturncFUbUO [5nURU//US9 g)z :param config: `.Config` object to use as the base configuration. Defaults to an anonymous/default `.Config` instance. :param remainder: The invoking program's :ref:`parser remainder ` value, if any was obtained. N)_configrrr)r_set)selfrrs K/home/mande/repo/quber/.venv/lib/python3.13/site-packages/invoke/context.py__init__Context.__init__;s/"-68   cUR$)a The fully merged `.Config` object appropriate for this context. `.Config` settings (see their documentation for details) may be accessed like dictionary keys (``c.config['foo']``) or object attributes (``c.config.foo``). As a convenience shorthand, the `.Context` object proxies to its ``config`` attribute in the same way - e.g. ``c['foo']`` or ``c.foo`` returns the same value as ``c.config['foo']``. r)r!s r"rContext.configRs||r%valuec"URUS9 g)Nr')r )r!r)s r"rr(cs %  r%commandkwargsc rURRRU5nUR"X140UD6$)a` Execute a local shell command, honoring config options. Specifically, this method instantiates a `.Runner` subclass (according to the ``runner`` config option; default is `.Local`) and calls its ``.run`` method with ``command`` and ``kwargs``. See `.Runner.run` for details on ``command`` and the available keyword arguments. .. versionadded:: 1.0 )rrunnerslocal_runr!r+r,runners r"run Context.runls2$$**40yy3F33r%r2rc JURU5nUR"U40UD6$N)_prefix_commandsr3)r!r2r+r,s r"r0 Context._runs&''0zz',V,,r%c rURRRU5nUR"X140UD6$)a Execute a shell command via ``sudo`` with password auto-response. **Basics** This method is identical to `run` but adds a handful of convenient behaviors around invoking the ``sudo`` program. It doesn't do anything users could not do themselves by wrapping `run`, but the use case is too common to make users reinvent these wheels themselves. .. note:: If you intend to respond to sudo's password prompt by hand, just use ``run("sudo command")`` instead! The autoresponding features in this method will just get in your way. Specifically, `sudo`: * Places a `.FailingResponder` into the ``watchers`` kwarg (see :doc:`/concepts/watchers`) which: * searches for the configured ``sudo`` password prompt; * responds with the configured sudo password (``sudo.password`` from the :doc:`configuration `); * can tell when that response causes an authentication failure (e.g. if the system requires a password and one was not configured), and raises `.AuthFailure` if so. * Builds a ``sudo`` command string using the supplied ``command`` argument, prefixed by various flags (see below); * Executes that command via a call to `run`, returning the result. **Flags used** ``sudo`` flags used under the hood include: - ``-S`` to allow auto-responding of password via stdin; - ``-p `` to explicitly state the prompt to use, so we can be sure our auto-responder knows what to look for; - ``-u `` if ``user`` is not ``None``, to execute the command as a user other than ``root``; - When ``-u`` is present, ``-H`` is also added, to ensure the subprocess has the requested user's ``$HOME`` set properly. **Configuring behavior** There are a couple of ways to change how this method behaves: - Because it wraps `run`, it honors all `run` config parameters and keyword arguments, in the same way that `run` does. - Thus, invocations such as ``c.sudo('command', echo=True)`` are possible, and if a config layer (such as a config file or env var) specifies that e.g. ``run.warn = True``, that too will take effect under `sudo`. - `sudo` has its own set of keyword arguments (see below) and they are also all controllable via the configuration system, under the ``sudo.*`` tree. - Thus you could, for example, pre-set a sudo user in a config file; such as an ``invoke.json`` containing ``{"sudo": {"user": "someuser"}}``. :param str password: Runtime override for ``sudo.password``. :param str user: Runtime override for ``sudo.user``. .. versionadded:: 1.0 )rr.r/_sudor1s r"sudo Context.sudos3J$$**40zz&4V44r%c URRRnURSURRR5nURSURRR 5nUR S05nSnUbSRU5nSn U(a.SRSRUR555n URU5nSRXIX5n [[R"U5S RU5S S 9n URS [URRR 55n U R#U 5 UR"U 4S U 0UD6$![$a;n ['U R([*5(a[-U R.US 9nUeeSn A ff=f)Npassworduserenvz -H -u {} z--preserve-env='{}' ,zsudo -S -p '{}' {}{}{}z{} zSorry, try again. )patternresponsesentinelwatchers)resultprompt)rr;rHpopr>r?getformatjoinkeysr7rreescapelistr3rFappendr isinstancereasonrrrG)r!r2r+r,rHr>r?r@ user_flags env_flagscmd_strwatcherrFfailureerrors r"r: Context._sudos!!((::j$++*:*:*C*CDzz&$++"2"2"7"78jj#  $++D1J .55chhsxxz6JKI''0*11 z #IIf%]]8,* ::j$t{{/G/G*HI  ::gCCFC C '..*=>>#7>>&I  s<F G6GGc[UR5nURnU(a!URSSR U55 SR X!/-5$)z Prefixes ``command`` with all prefixes found in ``command_prefixes``. ``command_prefixes`` is a list of strings which is modified by the `prefix` context manager. rzcd {}z && )rPrcwdinsertrKrL)r!r+prefixescurrent_directorys r"r7Context._prefix_commands sM--. HH  OOAw~~.?@ A{{8i/00r%)NNNc## URRU5 Sv URR5 g!URR5 f=f7f)a Prefix all nested `run`/`sudo` commands with given command plus ``&&``. Most of the time, you'll want to be using this alongside a shell script which alters shell state, such as ones which export or alter shell environment variables. For example, one of the most common uses of this tool is with the ``workon`` command from `virtualenvwrapper `_:: with c.prefix('workon myvenv'): c.run('./manage.py migrate') In the above snippet, the actual shell command run would be this:: $ workon myvenv && ./manage.py migrate This context manager is compatible with `cd`, so if your virtualenv doesn't ``cd`` in its ``postactivate`` script, you could do the following:: with c.cd('/path/to/app'): with c.prefix('workon myvenv'): c.run('./manage.py migrate') c.run('./manage.py loaddata fixture') Which would result in executions like so:: $ cd /path/to/app && workon myvenv && ./manage.py migrate $ cd /path/to/app && workon myvenv && ./manage.py loaddata fixture Finally, as alluded to above, `prefix` may be nested if desired, e.g.:: with c.prefix('workon myenv'): c.run('ls') with c.prefix('source /some/script'): c.run('touch a_file') The result:: $ workon myenv && ls $ workon myenv && source /some/script && touch a_file Contrived, but hopefully illustrative. .. versionadded:: 1.0 N)rrQrI)r!r+s r"prefixContext.prefixsHd $$W- (   ! ! % % 'D ! ! % % 'sA>AAAcUR(dg[[[UR555H3upUR S5(dUR S5(dM3 O URWSVs/sHo"R SS5PM nn[ [RR"U65$s snf)z[ Return the current working directory, accounting for uses of `cd`. .. versionadded:: 1.0 rA~/N z\ ) rreversedrP enumerate startswithreplacestrospathrL)r!irnpathss r"r\ Context.cwdPs   Yt/@/@%A BCGAs##ts';';D 7;6G6G6KL6Kdc5)6KL277<<'((MsCrnc## [U5nURRU5 Sv URR5 g!URR5 f=f7f)ai Context manager that keeps directory state when executing commands. Any calls to `run`, `sudo`, within the wrapped block will implicitly have a string similar to ``"cd && "`` prefixed in order to give the sense that there is actually statefulness involved. Because use of `cd` affects all such invocations, any code making use of the `cwd` property will also be affected by use of `cd`. Like the actual 'cd' shell builtin, `cd` may be called with relative paths (keep in mind that your default starting directory is your user's ``$HOME``) and may be nested as well. Below is a "normal" attempt at using the shell 'cd', which doesn't work since all commands are executed in individual subprocesses -- state is **not** kept between invocations of `run` or `sudo`:: c.run('cd /var/www') c.run('ls') The above snippet will list the contents of the user's ``$HOME`` instead of ``/var/www``. With `cd`, however, it will work as expected:: with c.cd('/var/www'): c.run('ls') # Turns into "cd /var/www && ls" Finally, a demonstration (see inline comments) of nesting:: with c.cd('/var/www'): c.run('ls') # cd /var/www && ls with c.cd('website1'): c.run('ls') # cd /var/www/website1 && ls .. note:: Space characters will be escaped automatically to make dealing with such directory names easier. .. versionadded:: 1.0 .. versionchanged:: 1.5 Explicitly cast the ``path`` argument (the only argument) to a string; this allows any object defining ``__str__`` to be handed in (such as the various ``Path`` objects out there), and not just string literals. N)rlrrQrI)r!rns r"cd Context.cdgsQ^4y   & $     ! ! #D   ! ! #s'A(A A( A%%A()NrA)__name__ __module__ __qualname____firstlineno____doc__r rl__annotations__r rr#propertyrsetterrrr3r0r;r:r7rrrbr\r rrs__static_attributes__rur%r"rrs63is)N$(       .  ]]!F!t!!434#4&4&-8-c-S-V-F5CF53F56F5R9H9s9c9f9| 1 1 15(c5(i0@&A5(5(n)S)),3$uXs]+3$ :J0K3$3$r%rc^\rSrSrSrSS\\S\SS4U4SjjjrS\S\ \4S jr S \ S \ S\ 4S jr S \ S \S\S\ 4SjrS \ S \S\S\ 4SjrS \ S \ S\ SS4SjrSrU=r$) MockContextia A `.Context` whose methods' return values can be predetermined. Primarily useful for testing Invoke-using codebases. .. note:: This class wraps its ``run``, etc methods in `unittest.mock.Mock` objects. This allows you to easily assert that the methods (still returning the values you prepare them with) were actually called. .. note:: Methods not given `Results <.Result>` to yield will raise ``NotImplementedError`` if called (since the alternative is to call the real underlying method - typically undesirable when mocking.) .. versionadded:: 1.0 .. versionchanged:: 1.5 Added ``Mock`` wrapping of ``run`` and ``sudo``. Nrr,rc v>[T U]U5 URSURSS55 UR 5Hup4[ [ [4n[U[5(a-UR 5HupgURU5XF'M OX[XE5(d[US5(aURU5nO%Sn[UR[U555eURSRU5U5 URU[[!X5S95 M g) a Create a ``Context``-like object whose methods yield `.Result` objects. :param config: A Configuration object to use. Identical in behavior to `.Context`. :param run: A data structure indicating what `.Result` objects to return from calls to the instantiated object's `~.Context.run` method (instead of actually executing the requested shell command). Specifically, this kwarg accepts: - A single `.Result` object. - A boolean; if True, yields a `.Result` whose ``exited`` is ``0``, and if False, ``1``. - An iterable of the above values, which will be returned on each subsequent call to ``.run`` (the first item on the first call, the second on the second call, etc). - A dict mapping command strings or compiled regexen to the above values (including an iterable), allowing specific call-and-response semantics instead of assuming a call order. :param sudo: Identical to ``run``, but whose values are yielded from calls to `~.Context.sudo`. :param bool repeat: A flag determining whether results yielded by this class' methods repeat or are consumed. For example, when a single result is indicated, it will normally only be returned once, causing ``NotImplementedError`` afterwards. But when ``repeat=True`` is given, that result is returned on every call, forever. Similarly, iterable results are normally exhausted once, but when this setting is enabled, they are wrapped in `itertools.cycle`. Default: ``True``. :raises: ``TypeError``, if the values given to ``run`` or other kwargs aren't of the expected types. .. versionchanged:: 1.5 Added support for boolean and string result values. .. versionchanged:: 1.5 Added support for regex dict keys. .. versionchanged:: 1.5 Added the ``repeat`` keyword argument. .. versionchanged:: 2.0 Changed ``repeat`` default value from ``False`` to ``True``. __repeatrepeatT__iter__z)Not sure how to yield results from a {!r}__{})wrapsN)superr#r rIitemsrboolrlrRdict _normalizehasattr TypeErrorrKtyper getattr) r!rr,methodresults singletonskeyr)err __class__s r"r#MockContext.__init__sp   *fjj489%||~OF!$,J'4((")--/JC#'??5#9GL#2G00G55//'2B 4= 9:: IIfmmF+W 5 IIfd)>? @% .r%r)cj[US5(a[U[5(aU/n/nUH\n[U[5(a[ U(aSOSS9nO [U[5(a [ U5nUR U5 M^ [ US5(a [U5$[U5$)Nrrr )exitedr) rrRrlrrrQrriter)r!r)robjs r"rMockContext._normalizesuj))Zs-C-CGEC#t$$A!4C%%Sk NN3  ")z!:!:uW~MW Mr%attnamer+c[X5n[U[5(aX2n[U5nUR(dX&lU$![aO UR 5H4upE[ US5(dMUR U5(dM0Un Mt [ef=f![[[[4a [U5ef=f)Nmatch) rrRrKeyErrorrrrnextr+AttributeError IndexError StopIterationNotImplementedError)r!rr+rrr)rGs r" _yield_resultMockContext._yield_results /$(C#t$$ ',C"#YF>>!(M% ''*iik "300SYYw5G5G"'C!'2 ' '& HmD /%g. . /s9 B'A #B' .B$=B$B$B' B$$B''&C argsc&URSU5$)N__runrr!r+rr,s r"r3MockContext.run5s !!'733r%c&URSU5$)N__sudorrs r"r;MockContext.sudo<s !!(G44r%rGcSRU5n[S5n[X5n[ U[ 5(dUeUR U5XR'g![a Uef=f)a} Modify the stored mock results for given ``attname`` (e.g. ``run``). This is similar to how one instantiates `MockContext` with a ``run`` or ``sudo`` dict kwarg. For example, this:: mc = MockContext(run={'mycommand': Result("mystdout")}) assert mc.run('mycommand').stdout == "mystdout" is functionally equivalent to this:: mc = MockContext() mc.set_result_for('run', 'mycommand', Result("mystdout")) assert mc.run('mycommand').stdout == "mystdout" `set_result_for` is mostly useful for modifying an already-instantiated `MockContext`, such as one created by test setup or helper methods. .. versionadded:: 1.0 rz>Can't update results for non-dict or nonexistent mock results!N)rKrrrrRrr)r!rr+rGheckr)s r"set_result_forMockContext.set_result_forCsh.--( L   D*E%&&J0  J s A A!rur6)rvrwrxryrzr rrr#rrrlrrr3r;rr~ __classcell__)rs@r"rrs(NAx/NA#NA$NANA` N N N(/S/3/6/<434s4c4f45C55s5v5%1%1%(%128%1 %1%1r%r)rmrN contextlibr itertoolsrrtypingrrrr r r unittest.mockr rrr exceptionsrrrr.rrrFrrrrur%r"rsO %%AA#&E$iE$P J1'J1r%