&Nj,SSKrSSKrSSKrSSKrSSKJr SSKJr SSKJrJ r J r SSKJ r SSK J r JrJrJrJrJrJr SSKJr SS KJrJr SS KJr SS KJr SS KJrJr SS K J!r! S\%S\%S\\%\ 44Sjr&"SS5r'"SS\'5r("SS\)5r*S\\%\ 4S\\%\ 4S\\%\ 44Sjr+S\,S\,S\*4Sjr-S\,S\%4S jr.S!\\%\ 4S\\%\ 44S"jr/S#\\%\ 4S$\\%S%4SS4S&jr0S\\%\ 4S'\\%\ 4SS4S(jr1g!\"a SSK#J$r! Nf=f))N)spec_from_loader)PathLike)joinsplitext expanduser) ModuleType)AnyDictIteratorOptionalTupleTypeUnion) Environment)UnknownFileTypeUnpicklableConfigMember)Local)WINDOWS)debugyaml)SourceFileLoader)_SourceFileLoadernamepathreturnc[RRU5(d0$[SU5n[ S5n[ SU5UlURU5 [U5$)Nmod) osrexistsrrr__spec__ exec_modulevars)rrloaderrs J/home/mande/repo/quber/.venv/lib/python3.13/site-packages/invoke/config.py load_sourcer&sV 77>>$   eT *F U C#E62CL s 9c ^\rSrSrSr\"SR 55\"SSR 555-r\S\"54S\ \ \ 4S\ SS \ \ S 4S S4S jj5rS \ S \ 4SjrS \ S\ S S4U4SjjrS \\ \ \ 44SjrS\S \4SjrS \4SjrS \ S\ S S4SjrS \ S \ 4SjrS \ S \ 4SjrS\ S\ S S4SjrS \ 4SjrS \ S \4Sjr\S \4Sj5r\S \4Sj5r S \ S S4Sjr!S \ S\ S S4S jr"S \ S S4S!jr#S"\ S S4S#jr$S*S$jr%S\ S \ 4S%jr&S \ 4S&jr'S\ S \ 4S'jr(S\ S\ S S4S(jr)S)r*U=r+$)+ DataProxy$a Helper class implementing nested dict+attr access for `.Config`. Specifically, is used both for `.Config` itself, and to wrap any other dicts assigned as config values (recursively). .. warning:: All methods (of this object or in subclasses) must take care to initialize new attributes via ``self._set(name='value')``, or they'll run into recursion errors! .. versionadded:: 1.0 z get has_key items iteritems iterkeys itervalues keys values c#D# UHnSRU5v M g7f)z__{}__N)format).0xs r% DataProxy.As'  OOA  s z> cmp contains iter sizeof Ndatarootkeypath.rcnU"5nURUS9 URUS9 URUS9 U$)a Alternate constructor for 'baby' DataProxies used as sub-dict values. Allows creating standalone DataProxy objects while also letting subclasses like `.Config` define their own ``__init__`` without muddling the two. :param dict data: This particular DataProxy's personal data. Required, it's the Data being Proxied. :param root: Optional handle on a root DataProxy/Config which needs notification on data updates. :param tuple keypath: Optional tuple describing the path of keys leading to this DataProxy's location inside the ``root`` structure. Required if ``root`` was given (and vice versa.) .. versionadded:: 1.0 _config)_root)_keypath_set)clsr1r2r3objs r% from_dataDataProxy.from_dataLs::e  t '" r'keyc URU5$![a XR;a[URU5s$SR U5n[ UR5Vs/sHo3RS5(aMUPM Os snfnnUSR [[URR5555- nUSR U5- n[U5ef=f)Nz)No attribute or config key found for {!r}_z Valid keys: {!r}z Valid real attributes: {!r}) _getKeyError_proxiesgetattrr6r,dir __class__ startswithsortedlistkeysAttributeError)selfr?errr.attrss r% __getattr__DataProxy.__getattr__os &99S> ! &mm#t||S11=DDSIC #DNN 3M 31<<;LQ 3MEM )00tDLL--/01 C 4;;EB BC % % &s"/C5(C5,B BA&C5valuecX>U[U5;nU(dX U'g[TU] X5 gN)rFsuper __setattr__)rMr?rR has_real_attrrGs r%rVDataProxy.__setattr__s,s4y( I G  +r'c,[UR5$rT)iterr6rMs r%__iter__DataProxy.__iter__sDLL!!r'othercz[USS5n[U[5(aUn[URU:H5$)Nr6)rE isinstancedictboolr6)rMr^ other_vals r%__eq__DataProxy.__eq__s: E9d3  eT " "IDLLI-..r'c,[UR5$rT)lenr6r[s r%__len__DataProxy.__len__s4<<  r'cBX RU'URX5 grT)r6_track_modification_of)rMr?rRs r% __setitem__DataProxy.__setitem__s! S ##C/r'c$URU5$rT)rBrMr?s r% __getitem__DataProxy.__getitem__syy~r'cUS;a [U5eURUn[U[5(aDU4n[ US5(aUR U-n[ USU5n[RX$US9nU$)N) __setstate__r8r7)r1r2r3) rLr6r`rahasattrr8rEr)r=)rMr?rRr3r2s r%rBDataProxy._gets # # % % S! eT " "fGtZ((--'14$/D''Uw'OE r'argskwargscU(a[R"U/UQ76 UR5Hup4[RXU5 M g)a| Convenience workaround of default 'attrs are config keys' behavior. Uses `object.__setattr__` to work around the class' normal proxying behavior, but is less verbose than using that directly. Has two modes (which may be combined if you really want): - ``self._set('attrname', value)``, just like ``__setattr__`` - ``self._set(attname=value)`` (i.e. kwargs), even less typing. N)objectrVitems)rMrvrwr?rRs r%r:DataProxy._sets<    t +d + ,,.JC   t% 0)r'cbSRURRUR5$)Nz<{}: {}>)r,rG__name__r6r[s r%__repr__DataProxy.__repr__s#  !8!8$,,GGr'cXR;$rTr5ros r% __contains__DataProxy.__contains__sll""r'c[US5$)Nr7rtr[s r%_is_leafDataProxy._is_leafstW%%r'c[US5$)N_modifyrr[s r%_is_rootDataProxy._is_rootstY''r'cSnUR(a URnOUR(aUnUb&UR[ US[ 55U5 ggNr8)rr7r_removerEtuple)rMr?targets r%_track_removal_ofDataProxy._track_removal_ofsI  ==ZZF ]]F   NN74UW=s C r'cSnUR(a URnOUR(aUnUb&UR[ US[ 55X5 ggr)rr7rrrEr)rMr?rRrs r%rk DataProxy._track_modification_ofsG ==ZZF ]]F   NN74UW=s J r'c@URU URU5 grT)r6rros r% __delitem__DataProxy.__delitem__s LL  s#r'rc>X;aX g[RX5 grT)ry __delattr__)rMrs r%rDataProxy.__delattr__s <   t *r'cL[UR55nUHnX M grT)rJrK)rMrKr?s r%clearDataProxy.clears!DIIK C r'cU=(a USUR;nURR"U6nU(dU$URUS5 U$Nr)r6popr)rMrv key_existedrets r%r DataProxy.popsP6tAw$,,6 ll%J tAw' r'cbURR5nURUS5 U$r)r6popitemr)rMrs r%rDataProxy.popitems+ll""$ s1v& r'cU=(a USUR;nURR"U6nU(aU$UupEURXE5 U$r)r6 setdefaultrk)rMrvrrr?defaults r%rDataProxy.setdefaultsQ6tAw$,,6 ll%%t, J  ##C1 r'cU(aUR5H up4X@U'M gU(a>USn[U[5(aUH nXSX'M gUH nUSXS'M gg)Nrr)rzr`ra)rMrvrwr?rRargpairs r%updateDataProxy.update)sj $lln !S - q'C#t$$C #DI D$(GDaM r'rN),r} __module__ __qualname____firstlineno____doc__rsplitrD classmethodr strr r r r=rPrVr r\ryrbrdintrhrlrprBr:r~rpropertyrrrrkrrrrrrr__static_attributes__ __classcell__)rGs@r%r)r)$sq             0'+#(7 38n {# sCx    D&s&s&( ,s ,3 ,4 ,"(4S>2" /F /t /!!0s03040ss(1#111"H#H###&$&&($(( DS DT DK#KcKdK$s$t$+++ "    ,C ,3 ,4 , ,r'r)c\rSrSrSrSrSrSr\S\ \ \ 44Sj5r S1S\ \ \ \ 4S\ \ \ \ 4S \ \ S \ \ S \ \S \ \S \4SjjrS2SjrS3S\ \ \ 4S\SS4SjjrS3S\ \ \ 4S\SS4SjjrS3S\SS4SjjrS3S\SS4SjjrS3S\SS4SjjrS\ \SS4SjrS3S\SS4SjjrS2SjrS3S\ \ \ 4S\SS4SjjrS\\\ S4SS4SjrS4S\ S\S\SS4SjjrS\S\ 4S jr\rS\S\ 4S!jr S\ S\ \ \ 44S"jr!S2S#jr"S$\ S%\ SS4S&jr#S5S'\ \$SSS4S(jjr%S5S'\ \$SS\ \ \ 44S)jjr&S*\'\ S+4S,\ S-\ SS4S.jr(S*\'\ S+4S,\ SS4S/jr)S0r*g)6Configi9a Invoke's primary configuration handling class. See :doc:`/concepts/configuration` for details on the configuration system this class implements, including the :ref:`configuration hierarchy `. The rest of this class' documentation assumes familiarity with that document. **Access** Configuration values may be accessed and/or updated using dict syntax:: config['foo'] or attribute syntax:: config.foo Nesting works the same way - dict config values are turned into objects which honor both the dictionary protocol and the attribute-access method:: config['foo']['bar'] config.foo.bar **A note about attribute access and methods** This class implements the entire dictionary protocol: methods such as ``keys``, ``values``, ``items``, ``pop`` and so forth should all function as they do on regular dicts. It also implements new config-specific methods such as `load_system`, `load_collection`, `merge`, `clone`, etc. .. warning:: Accordingly, this means that if you have configuration options sharing names with these methods, you **must** use dictionary syntax (e.g. ``myconfig['keys']``) to access the configuration data. **Lifecycle** At initialization time, `.Config`: - creates per-level data structures; - stores any levels supplied to `__init__`, such as defaults or overrides, as well as the various config file paths/filename patterns; - and loads config files, if found (though typically this just means system and user-level files, as project and runtime files need more info before they can be found and loaded.) - This step can be skipped by specifying ``lazy=True``. At this point, `.Config` is fully usable - and because it pre-emptively loads some config files, those config files can affect anything that comes after, like CLI parsing or loading of task collections. In the CLI use case, further processing is done after instantiation, using the ``load_*`` methods such as `load_overrides`, `load_project`, etc: - the result of argument/option parsing is applied to the overrides level; - a project-level config file is loaded, as it's dependent on a loaded tasks collection; - a runtime config file is loaded, if its flag was supplied; - then, for each task being executed: - per-collection data is loaded (only possible now that we have collection & task in hand); - shell environment data is loaded (must be done at end of process due to using the rest of the config as a guide for interpreting env var names.) At this point, the config object is handed to the task being executed, as part of its execution `.Context`. Any modifications made directly to the `.Config` itself after this point end up stored in their own (topmost) config level, making it easier to debug final values. Finally, any *deletions* made to the `.Config` (e.g. applications of dict-style mutators like ``pop``, ``clear`` etc) are also tracked in their own structure, allowing the config object to honor such method calls without mutating the underlying source data. **Special class attributes** The following class-level attributes are used for low-level configuration of the config system itself, such as which file paths to load. They are primarily intended for overriding by subclasses. - ``prefix``: Supplies the default value for ``file_prefix`` (directly) and ``env_prefix`` (uppercased). See their descriptions for details. Its default value is ``"invoke"``. - ``file_prefix``: The config file 'basename' default (though it is not a literal basename; it can contain path parts if desired) which is appended to the configured values of ``system_prefix``, ``user_prefix``, etc, to arrive at the final (pre-extension) file paths. Thus, by default, a system-level config file path concatenates the ``system_prefix`` of ``/etc/`` with the ``file_prefix`` of ``invoke`` to arrive at paths like ``/etc/invoke.json``. Defaults to ``None``, meaning to use the value of ``prefix``. - ``env_prefix``: A prefix used (along with a joining underscore) to determine which environment variables are loaded as the env var configuration level. Since its default is the value of ``prefix`` capitalized, this means env vars like ``INVOKE_RUN_ECHO`` are sought by default. Defaults to ``None``, meaning to use the value of ``prefix``. .. versionadded:: 1.0 invokeNrc [(a![RRSS5nOSn0SS_SS_SS_SS_S S _S S _S 0_S S _SS_SS _SS _SS _SS_SS_SS_SU_SS_S/0ES[0S SS S.SSSS SS S.SS 0S .$)!aR Return the core default settings for Invoke. Generally only for use by `.Config` internals. For descriptions of these values, see :ref:`default-values`. Subclasses may choose to override this method, calling ``Config.global_defaults`` and applying `.merge_dicts` to the result, to add to or modify these values. .. versionadded:: 1.0 COMSPECzcmd.exebash asynchronousFdisowndryecho echo_stdinNencodingenv err_streamfallbackThide in_stream out_stream echo_formatz{command}pty replace_envshellwarnwatcherslocalz[sudo] password: )passwordpromptusertasks)auto_dash_namescollection_namededupeexecutor_classignore_unknown_help search_rootcommand)runrunnerssudortimeouts)rrenvirongetr)rs r%global_defaultsConfig.global_defaultssD" 7JJNN9i8E E(%u  d  D rdDTd;uu !"#$B%. ' - $(#*"&',# #D)o8 8 r' overridesdefaults system_prefix user_prefixproject_location runtime_pathlazyctUR0S9 URSS9 Uc[UR55nURUS9 UR0S9 Uc [(dSnURUS9 URSS 9 URSS 9 UR0S 9 UcS nURUS 9 URSS9 URSS9 UR0S9 UR U5 UR nUc UR nSRUR55nURUS9 UR0S9 URU5 Uc0nURUS9 UR0S9 UR0S9 U(dUR5 UR5 g)ao Creates a new config object. :param dict defaults: A dict containing default (lowest level) config data. Default: `global_defaults`. :param dict overrides: A dict containing override-level config data. Default: ``{}``. :param str system_prefix: Base path for the global config file location; combined with the prefix and file suffixes to arrive at final file path candidates. Default: ``/etc/`` (thus e.g. ``/etc/invoke.yaml`` or ``/etc/invoke.json``). :param str user_prefix: Like ``system_prefix`` but for the per-user config file. These variables are joined as strings, not via path-style joins, so they may contain partial file paths; for the per-user config file this often means a leading dot, to make the final result a hidden file on most systems. Default: ``~/.`` (e.g. ``~/.invoke.yaml``). :param str project_location: Optional directory path of the currently loaded `.Collection` (as loaded by `.Loader`). When non-empty, will trigger seeking of per-project config files in this directory. :param str runtime_path: Optional file path to a runtime configuration file. Used to fill the penultimate slot in the config hierarchy. Should be a full file path to an existing file, not a directory path or a prefix. :param bool lazy: Whether to automatically load some of the lower config levels. By default (``lazy=False``), ``__init__`` automatically calls `load_system` and `load_user` to load system and user config files, respectively. For more control over what is loaded when, you can say ``lazy=True``, and no automatic loading is done. .. note:: If you give ``defaults`` and/or ``overrides`` as ``__init__`` kwargs instead of waiting to use `load_defaults` or `load_overrides` afterwards, those *will* still end up 'loaded' immediately. r5)rymljsonpy)_file_suffixesN _defaults _collectionz/etc/)_system_prefix) _system_path) _system_found)_systemz~/.) _user_prefix) _user_path) _user_found)_userz{}_) _env_prefix_env _overrides)_modifications) _deletions) r: copy_dictrrset_project_location env_prefixprefixr,upperset_runtime_pathload_base_conf_filesmerge) rMrrrrrrrr s r%__init__Config.__init__sD "  !> ?   !5!5!78H H % b !  #M  / t $  % "   K { + T " d #   !!"23__  J\\*"2"2"45  j ) r  l+  I Y '  $ R    % % ' r'c@URSS9 URSS9 g)NF)r) load_system load_userr[s r%r Config.load_base_conf_filess! u% U#r'r1rcRURUS9 U(aUR5 gg)a Set or replace the 'defaults' configuration level, from ``data``. :param dict data: The config data to load as the defaults level. :param bool merge: Whether to merge the loaded data into the central config. Default: ``True``. :returns: ``None``. .. versionadded:: 1.0 rNr:rrMr1rs r% load_defaultsConfig.load_defaultss# D !  JJL r'cRURUS9 U(aUR5 gg)a Set or replace the 'overrides' configuration level, from ``data``. :param dict data: The config data to load as the overrides level. :param bool merge: Whether to merge the loaded data into the central config. Default: ``True``. :returns: ``None``. .. versionadded:: 1.0 rNrrs r%load_overridesConfig.load_overridess# T "  JJL r'c$URSUS9 g)aC Load a system-level config file, if possible. Checks the configured ``_system_prefix`` path, which defaults to ``/etc``, and will thus load files like ``/etc/invoke.yml``. :param bool merge: Whether to merge the loaded data into the central config. Default: ``True``. :returns: ``None``. .. versionadded:: 1.0 systemr rN _load_filerMrs r%rConfig.load_systems xu5r'c$URSUS9 g)a< Load a user-level config file, if possible. Checks the configured ``_user_prefix`` path, which defaults to ``~/.``, and will thus load files like ``~/.invoke.yml``. :param bool merge: Whether to merge the loaded data into the central config. Default: ``True``. :returns: ``None``. .. versionadded:: 1.0 rrNr r"s r%rConfig.load_users vU3r'c$URSUS9 g)a) Load a project-level config file, if possible. Checks the configured ``_project_prefix`` value derived from the path given to `set_project_location`, which is typically set to the directory containing the loaded task collection. Thus, if one were to run the CLI tool against a tasks collection ``/home/myuser/code/tasks.py``, `load_project` would seek out files like ``/home/myuser/code/invoke.yml``. :param bool merge: Whether to merge the loaded data into the central config. Default: ``True``. :returns: ``None``. .. versionadded:: 1.0 projectrNr r"s r% load_projectConfig.load_projects( y6r'rc^URUS9 UR0S9 URSS9 g)z: Set the runtime config file path. .. versionadded:: 1.0 ) _runtime_path)_runtimeN)_runtime_foundr9)rMrs r%r Config.set_runtime_paths0  % 2   &r'c&URSSUS9 g)ap Load a runtime-level config file, if one was specified. When the CLI framework creates a `Config`, it sets ``_runtime_path``, which is a full path to the requested config file. This method attempts to load that file. :param bool merge: Whether to merge the loaded data into the central config. Default: ``True``. :returns: ``None``. .. versionadded:: 1.0 runtimeT)r absoluterNr r"s r% load_runtimeConfig.load_runtimes y4uEr'c[S5 UR5 [S5 [URURS9nUR UR 5S9 [S5 UR5 g)a9 Load values from the shell environment. `.load_shell_env` is intended for execution late in a `.Config` object's lifecycle, once all other sources (such as a runtime config file or per-collection configurations) have been loaded. Loading from the shell is not terrifically expensive, but must be done at a specific point in time to ensure the "only known config keys are loaded from the env" behavior works correctly. See :ref:`env-vars` for details on this design decision and other info re: how environment variables are scanned and loaded. .. versionadded:: 1.0 z*Running pre-merge for shell env loading...zDone with pre-merge.)configr rz0Loaded shell environment, triggering final mergeN)rrrr6rr:load)rMr$s r%load_shell_envConfig.load_shell_envs[" :;  $%DLL9I9IJ v{{} % @A r'ch[S5 URUS9 U(aUR5 gg)z Update collection-driven config data. `.load_collection` is intended for use by the core task execution machinery, which is responsible for obtaining collection-driven data. See :ref:`collection-configuration` for details. .. versionadded:: 1.0 z Loading collection configurationrN)rr:rrs r%load_collectionConfig.load_collection+s, 01 d #  JJL r'cSnUb [US5nURUS9 URSS9 URSS9 UR0S9 g)z Set the directory path where a project-level config file may be found. Does not do any file loading on its own; for that, see `load_project`. .. versionadded:: 1.0 N)_project_prefix) _project_path)_project_found)_project)rr:)rMrproject_prefixs r%rConfig.set_project_location<sT  !$^N . 1  %  & 2 r'r r1c SRU5nSRU5nSRU5nURnUc URn[X5bgU(a[X5nUcgU/n ON[USRU55n U cgURV s/sHn SR X-U 45PM n n U Hn [ U 5n [U 5SRS5n [USRU 55nURXn"U 55 URX\5 URUS 5 O [X5cURUS 5 gU(aUR5 ggs sn f![a( Sn[URW XR55ef=f![a9nURS :Xa#S n[URU 55 SnAGM5eSnAff=f) N _{}_found_{}_path_{}z _{}_prefix.rz_load_{}zUConfig files of type {!r} (from file {!r}) are not supported! Please use one of: {!r}TzDidn't see any {}, skipping.F)r, file_prefixr rErrrrlstriprLrr:IOErrorerrnorr)rMr r1rfoundrr1midfix absolute_pathpaths path_prefixr.filepathtype_r$msgerNs r%r!Config._load_fileRs""6*  (||F#!! >[[F 4  +  #D/M$"OE!$ (;(;F(CDK",,,A+.23,  H!(+H $X.q188=E$T:+<+ 2F;;F>> H,G<;G<<Hcz[U5n[R"U5sSSS5 $!,(df  g=frT)openr safe_loadrMrfds r% _load_yamlConfig._load_yamls! $Z2>>"%ZZ, :cz[U5n[R"U5sSSS5 $!,(df  g=frT)rYrr6r[s r% _load_jsonConfig._load_jsons $Z299R=ZZr_c0n[SU5R5H\up4URS5(aM[U[R 5(aSn[ URU55eXBU'M^ U$)Nr__z'{}' is a module, which can't be used as a config value. (Are you perhaps giving a tasks file instead of a config file by mistake?))r&rzrHr`typesrrr,)rMrr1r?rRrNs r%_load_pyConfig._load_pysu&ud3::>I= r'c[S5 UR0S9 [SRUR55 [ UR UR5 [SRUR 55 [ UR UR 5 URSS5 URSS5 URS S 5 [S RUR55 [ UR UR5 URS S 5 [SRUR55 [ UR UR5 [SRUR55 [ UR UR5 [SRUR55 [UR UR5 g)z< Merge all config sources, in order. .. versionadded:: 1.0 z9Merging config sources in order onto new empty _config...r5zDefaults: {!r}zCollection-driven: {!r}rz System-widerzPer-userr'z Per-projectz!Environment variable config: {!r}r0RuntimezOverrides: {!r}zModifications: {!r}zDeletions: {!r}N) rr:r,r merge_dictsr6r _merge_filerrrr obliterater[s r%r Config.merges_ IJ "  %%dnn56DLL$..1 '..t/?/?@ADLL$"2"23 =1 , M2 188CDDLL$)), I. &&t78DLL$//2 #**4+>+>?@DLL$"5"56 &&t784<<1r'rdesccUS- n[USRU55n[USRU55n[USRU55nUc[SRU55 gU(a2[SRX$U55 [URU5 g[SRU55 g)Nz config filerErFrGz${} has not been loaded yet, skippingz {} ({}): {!r}z{} not found, skipping)rEr,rrjr6)rMrrnrNrr1s r%rkConfig._merge_files k0067tZ..t45tU\\$/0 = 8??E F  /((T: ;  d + *11$7 8r'intocUc UROUnU"S0URUS9D6nSR5HqnSRU5n[ X5n[ U[ 5(d(URU[R"U55 M\[[ X45U5 Ms UR5 UR5 U$)a  Return a copy of this configuration object. The new object will be identical in terms of configured sources and any loaded (or user-manipulated) data, but will be a distinct object with as little shared mutable state as possible. Specifically, all `dict` values within the config are recursively recreated, with non-dict leaf values subjected to `copy.copy` (note: *not* `copy.deepcopy`, as this can cause issues with various objects such as compiled regexen or threading locks, often found buried deep within rich aggregates like API or DB clients). The only remaining config values that may end up shared between a config and its clone are thus those 'rich' objects that do not `copy.copy` cleanly, or compound non-dict objects (such as lists or tuples). :param into: A `.Config` subclass that the new clone should be "upgraded" to. Used by client libraries which have their own `.Config` subclasses that e.g. define additional defaults; cloning "into" one of these subclasses ensures that any new keys/subtrees are added gracefully, without overwriting anything that may have been pre-defined. Default: ``None`` (just clone into another regular `.Config`). :returns: A `.Config`, or an instance of the class given to ``into``. .. versionadded:: 1.0 )rqa collection system_prefix system_path system_found system user_prefix user_path user_found user project_prefix project_path project_found project env_prefix env runtime_path runtime_found runtime overrides modifications rGr) rG_clone_init_kwargsrr,rEr`rar:copyrjr r)rMrqklassnewrmy_datas r%clone Config.clonesF#',D9d--4-89 * EG+D,<<%Dd)Ggt,,tyy12GC.8AF   "  r'cx[UR5nUb[X!R55 [ USS9$)ai Supply kwargs suitable for initializing a new clone of this object. Note that most of the `.clone` process involves copying data between two instances instead of passing init kwargs; however, sometimes you really do want init kwargs, which is why this method exists. :param into: The value of ``into`` as passed to the calling `.clone`. :returns: A `dict`. T)rr)rrrjrra)rMrq new_defaultss r%rsConfig._clone_init_kwargs1s>"!0    &:&:&< =!   r'r3.r?rRc[URX4-5 URn[U5nU(a'UR S5nXd;a0XF'XFnU(aM'X4U'UR 5 g)a; Update our user-modifications config level with new data. :param tuple keypath: The key path identifying the sub-dict being updated. May be an empty tuple if the update is occurring at the topmost level. :param str key: The actual key receiving an update. :param value: The value being written. rN)exciserrrJrr)rMr3r?rRr1 keypath_listsubkeys r%rConfig._modifyNsk t& 01""G} !%%a(F!! *O } O c] O #8, Ox(OOb$ $sCx.$4S>$$$666"4t4t4"7$7$7, 'Xh%7 'D 'F$F$F$437cN+/ "xd/B)C.BF==%)=:>= =~&x&C&I!x!C!ST#s(^$22993949&V(4>2VhVr04 T(^, c3h :uS#XS<uS#XSTr'rc\rSrSrSrg)AmbiguousMergeErrorirN)r}rrrrrr'r%rrsr'rbaseupdatesc:U=(d 0R5Hup#X ;a[U[5(a5[X[5(a[XU5 MF[ XU5e[X[5(a[ XU5e[ US5(aX0U'M[ R "U5X'M[U[5(a[U5X'M[ US5(aX0U'M[ R "U5X'M U$)a Recursively merge dict ``updates`` into dict ``base`` (mutating ``base``.) * Values which are themselves dicts will be recursed into. * Values which are a dict in one input and *not* a dict in the other input (e.g. if our inputs were ``{'foo': 5}`` and ``{'foo': {'bar': 5}}``) are irreconciliable and will generate an exception. * Non-dict leaf values are run through `copy.copy` to avoid state bleed. .. note:: This is effectively a lightweight `copy.deepcopy` which offers protection from mismatched types (dict vs non-dict) and avoids some core deepcopy problems (such as how it explodes on certain object types). :returns: The value of ``base``, which is mostly useful for wrapper functions like `copy_dict`. .. versionadded:: 1.0 fileno)rzr`rarj _merge_errorrtrtr)rrr?rRs r%rjrjs2}"++-  ;%&&di.. 51&ty%88di..&ty%88UH-- %I $ % 0DI %&&%e, ))!S !IIe, =.> Kr'origrvc\[SR[U5[U555$)NzCan't cleanly merge {} with {})rr,_format_mismatch)rrvs r%rrs- (// T "$4S$9  r'r.c8SR[U5U5$)Nz {} ({!r}))r,type)r.s r%rrs   d1gq ))r'sourcec[0U5$)z Return a fresh copy of ``source`` with as little shared state as possible. Uses `merge_dicts` under the hood, with an empty ``base`` dict; see its documentation for details on behavior. .. versionadded:: 1.0 )rj)rs r%rrs r6 ""r'dict_r3.cUn[U5nUR5nU(a$URS5nXR;agX%nU(aM$XB;aX$ gg)zd Remove key pointed at by ``keypath`` from nested dict ``dict_``, if exists. .. versionadded:: 1.0 rN)rJr)rr3r1rleaf_keyr?s r%r~r~s[ D=L!H q! ? y ,  Nr' deletionscUR5H.up#[U[5(a[XX5 M,X M0 g)z\ Remove all (nested) keys mentioned in ``deletions``, from ``base``. .. versionadded:: 1.0 N)rzr`rarl)rrr?rRs r%rlrls9  oo'  eT " " ty). 1 (r')2rtrrreimportlib.utilrros.pathrrrrtypingr r r r r rrrr exceptionsrrrr terminalsrutilrrimportlib.machineryr ImportErrorimportlib._bootstraprrr&r)r ValueErrorrrjryrrrr~rlrr'r%rs| +..DDD@4cc3hR,R,jP YP f * 8 sCx.8#'S>8 #s(^8vvF/B**3* #d38n #c3h #$sCx.5c?t& T#s(^ S#X 4 E's"D DD