*d3dZddlZddlmZddlmZddlmZddlm Z m Z m Z m Z m Z ddlmZddlmZdd lmZdd lmZdd lmZmZdd lmZdd lmZddlmZmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ej6de7Z8GddZ9GddZ:Gdd Z;dS)!a) Solver-agnostic logic to compose the requests passed to the solver and accumulate its results. The state exposed to the solver is handled by two objects whose primary function is to serve read-only information to the solver and its other helpers. - ``SolverInputState``: fully solver agnostic. It handles: - The local state on disk, namely the prefix state. This includes the already installed packages in the prefix (if any), the explicit requests made in that prefix in the past (history), its pinned specs, packages configured as aggressive updates and others. - The runtime context, determined by the configuration file(s), `CONDA_*` environment variables, command line flags and the requested specs (if any). - ``IndexHelper``: can be subclassed to add solver-specific logic (e.g. custom index building). It should, provide, at least, a method to query the index for the _explicit pool_ of packages for a given spec (e.g. its potential dependency tree). Note that the IndexHelper might need pieces of ``SolverInputState`` to build the index (e.g. installed packages, configured channels and subdirs...) .. todo:: Embed IndexHelper in SolverInputState? Since ``conda`` follows an iterative approach to solve a request, in addition the _input_ state, the Solver itself can store additional state in a separate helper: the ``SolverOutputState`` object. This is meant to help accumulate the following pieces of data: - ``specs``: a mapping of package names to its corresponding ``MatchSpec`` objects. These objects are passed to the actual Solver, hoping it will return a solution. - ``records``: a mapping of package names to ``PackageRecord`` objects. It will end up containing the list of package records that will compose the final state of the prefix (the _solution_). Its default value is set to the currently installed packages in the prefix. The solver will alter this list as needed to accommodate the final solution. If the algorithm was not iterative, the sole purpose of the solver would be to turn the ``specs`` into ``records``. However, ``conda``'s logic will try to constrain the solution to mimic the initial state as much as possible to reduce the amount of changes in the prefix. Sometimes, the initial request is too constrained, which results in a number of conflicts. These conflicts are then stored in the ``conflicts`` mapping, which will determine which ``specs`` are relaxed in the next attempt. Additionally, ``conda`` stores other solve artifacts: - ``for_history``: The explicitly requested specs in the command-line should end up in the history. Some modifier flags can affect how this mapping is populated (e.g. ``--update-deps``.) - ``neutered``: Pieces of history that were found to be conflicting in the future and were annotated as such to avoid falling in the same conflict again. The mappings stored in ``SolverOutputState`` are backed by ``TrackedMap`` objects, which allow to keep the reasons _why_ those specs or records were added to the mappings, as well as richer logging for each action. N)chain)PathLike)MappingProxyType)IterableMappingOptionalTypeUnion) IndexedSet) CondaError)NULL)dals) DepsModifierUpdateModifier)context)dashlist)get_major_minor_version paths_equal)_supplement_index_with_system) PrefixData)get_pinned_specs)PackagesNotFoundErrorSpecsConfigurationConflictError)History)Channel MatchSpec) PrefixGraph) PackageRecord) EnumAsBools TrackedMapzconda.c:eZdZdZdeedeefdZdS) IndexHelpera+ The _index_ refers to the combination of all configured channels and their platform-corresponding subdirectories. It provides the sources for available packages that can become part of a prefix state, eventually. Subclass this helper to add custom repodata fetching if needed. specsreturnctN)NotImplementedError)selfr%s ;lib/python3.11/site-packages/conda_libmamba_solver/state.py explicit_poolzIndexHelper.explicit_poolfs!!N)__name__ __module__ __qualname____doc__rrstrr,r-r+r$r$]sI"8I#6"8C=""""""r-r$c.eZdZdZejejejej ej ej ej ej dZdZdej ejddddddf deeeefdeeeeefd eed eed eed eed eedeedeedeefdZdZefdZedefdZedeee ffdZ!edeeeffdZ"edeeeffdZ#edeeeffdZ$edeeeffdZ%edeeeffdZ&edeeeffdZ'edefdZ(edefdZ)edefdZ*edefd Z+ede,fd!Z-ede,fd"Z.edefd#Z/edefd$Z0edefd%Z1edefd&Z2dee3fd'Z4dee3fd(Z5dee3fd)Z6dS)*SolverInputStatea Helper object to provide the input data needed to compute the state that will be exposed to the solver. Parameters ---------- prefix Path to the prefix we are operating on. This will be used to expose ``PrefixData``, ``History``, pinned specs, among others. requested The MatchSpec objects required by the user (either in the command line or through the Python API). update_modifier A value of ``UpdateModifier``, which has an effect on which specs are added to the final list. The default value here must match the default value in the ``context`` object. deps_modifier A value of ``DepsModifier``, which has an effect on which specs are added to the final list. The default value here must match the default value in the ``context`` object. ignore_pinned Whether pinned specs can be ignored or not. The default value here must match the default value in the ``context`` object. force_remove Remove the specs without solving the environment (which would also remove their) dependencies. The default value here must match the default value in the ``context`` object. force_reinstall Uninstall and install the computed records even if they were already satisfied in the given prefix. The default value here must match the default value in the ``context`` object. prune Remove dangling dependencies that ended up orphan. The default value here must match the default value in the ``context`` object. command The subcommand used to invoke this operation (e.g. ``create``, ``install``, ``remove``...). It can have an effect on the computed list of records. _pip_interop_enabled Internal only. Whether ``PrefixData`` will also expose packages not installed by ``conda`` (e.g. ``pip`` and others can put Python packages in the prefix). )NOT_SETNO_DEPS ONLY_DEPSSPECS_SATISFIED_SKIP_SOLVEFREEZE_INSTALLED UPDATE_DEPS UPDATE_SPECS UPDATE_ALL)anacondacondaz conda-buildz python.appconsole_shortcutpowershell_shortcutr3NFprefix requestedupdate_modifier deps_modifier ignore_pinned force_removeforce_reinstallprunecommand_pip_interop_enabledc "||_t|| |_| |_t ||_dt|D|_dtj D|_ i} t| d| D|_ i|_|D] } t| } | |j| j<!|d||_|d||_|d||_|d||_|d ||_||_| |_d |jD|_|dS) N)pip_interop_enabledci|] }|j| Sr3name.0specs r+ z-SolverInputState.__init__..sMMMD 4MMMr-ci|] }|j| Sr3rOrQs r+rTz-SolverInputState.__init__..s#c#c#cDIt#c#c#cr-ci|] }|j| Sr3rOrRrecords r+rTz-SolverInputState.__init__..sCCCfCCCr-rDrErFrGrHc.i|]}|t|Sr3r)rRps r+rTz-SolverInputState.__init__..s RRR1q)A,,RRRr-)rBr _prefix_datarKrget_requested_specs_map_historyr_pinnedraggressive_update_packages_aggressive_updatesr_virtual _requestedrrP_default_to_context_if_null_update_modifier_deps_modifier_ignore_pinned _force_remove_force_reinstall_prune_command_DO_NOT_REMOVE_NAMES_do_not_remove _check_state) r*rBrCrDrErFrGrHrIrJrKvirtualrSs r+__init__zSolverInputState.__init__s &vCWXXX$8!??AA MM4DV4L4LMMM #c#c@b#c#c#c %g...CC7CCC  . .DT??D)-DODI & & $ @ @ ! ! #>>P]^^">>P]^^!==nl[[ $ @ @ ! !   SR8QRRR r-c|jD]N\}}|j|}|r-||st |g|g|jOdS)zO Run some consistency checks to ensure configuration is solid. N)pinneditems installedgetmatchrrB)r*rPpin_specrss r+rmzSolverInputState._check_states~ #k//11 \ \ND(**400I \ !:!: \5ykH:t{[[[ \ \r-cj|turt||n|j||S)zTObtain default value from the context if value is set to NULL; otherwise leave as is)r getattr _ENUM_STR_MAPrt)r*rPvaluers r+rcz,SolverInputState._default_to_context_if_nulls4).$ww%%%D True if the used subcommand was ``install``. installrjr|s r+ is_installingzSolverInputState.is_installing-s } ))r-c|jdkS)z= True if the used subcommand was ``update``. updaterr|s r+ is_updatingzSolverInputState.is_updating4 }((r-c|jdkS)z= True if the used subcommand was ``create``. createrr|s r+ is_creatingzSolverInputState.is_creating;rr-c|jdkS)z= True if the used subcommand was ``remove``. removerr|s r+ is_removingzSolverInputState.is_removingBrr-c*t|jS)a Use attribute access to test whether the modifier is set to that value >>> update_modifier = EnumAsBools(context.update_modifier) >>> update_modifier.UPDATE_SPECS True >>> update_modifier.UPDATE_DEPS False )r!rdr|s r+rDz SolverInputState.update_modifierKs40111r-c*t|jS)a Use attribute access to test whether the modifier is set to that value >>> deps_modifier = EnumAsBools(context.deps_modifier) >>> deps_modifier.NOT_SET True >>> deps_modifier.DEPS_ONLY False )r!rer|s r+rEzSolverInputState.deps_modifierXs4.///r-c|jSr()rfr|s r+rFzSolverInputState.ignore_pinnedgs ""r-c|jSr()rgr|s r+rGzSolverInputState.force_removeks !!r-c|jSr()rhr|s r+rHz SolverInputState.force_reinstallos $$r-c|jSr()rir|s r+rIzSolverInputState.pruness {r-c#K|jD]k}|d}|rR|jrG|jdr-t |jdd}|VldS)a Collect all channels added with the `channel::package=*` syntax. For now, we only collect those specifically requested by the user in the current command (same as conda), but we should investigate whether history keeps channels around too. channelzfile://z::rN)rCvaluesget_exact_valueoriginal_spec_str startswithrsplit)r*rSrs r+channels_from_specsz$SolverInputState.channels_from_specsysN))++  D**955G )Md.D.O.OPY.Z.ZM%d&<&B&B4&H&H&KLLG   r-c# Kt}|jD]X}|jjs |jjr|jjdvr*|jj}||vr|||jVYdS)N)@z pypi) setrsrrauthtokenrP subdir_urladd)r* seen_urlsrXrs r+channels_from_installedz(SolverInputState.channels_from_installedsEE n++-- % %F~" fn&: ~"&@@@2J** j)))n$$$ % %r-c#RKtjrtjdVdSdS)Nz#https://repo.anaconda.com/pkgs/free)rrestore_free_channelrfrom_urlr|s r+maybe_free_channelz#SolverInputState.maybe_free_channels<  ' J"#HII I I I I I J Jr-)7r.r/r0r1rr6r7r8rr9r:r;r<r=ryrkr r2bytesrrrrboolrormrrcpropertyrr}rrrsrrqrnrrrCrrrrr!rDrErFrGrHrIrrrrr3r-r+r5r5js((V ''!+&4&O*;%1&3$/  M@B4B4O0<0D(,',*/ %!%/3,,c5(*+,HU3 >%:;<,".1 ,  - ,  ~ ,tn,"$,~,#,'tn,,,,\\\\@Gaaaa!Z!!!X!B73 #56BBBXB/i0///X/ .Y/ . . .X ./i0///X/:GCN$;:::X:5wsI~6555X5173 >2111X1*t***X* )T)))X) )T)))X) )T)))X) 2 2 2 2X 2 0{ 0 0 0X 0#t###X#"d"""X"%%%%X%tX Xg%6    %'):%%%%"JHW$5JJJJJJr-r5ceZdZdZdddddddedeeeefdeeee fdeeeefdeeeefd eeeeff d Z d Z e d Z e d Ze dZdedeeeffdZdefdZdZdZdZdedfdZedZdS)SolverOutputStatea This is the main mutable object we will massage before passing the result of the computation (the ``specs`` mapping) to the solver. It will also store the result of the solve (in ``records``). Parameters ---------- solver_input_state This instance provides the initial state for the output. specs Mapping of package names to ``MatchSpec`` objects that will override the initialization driven by ``solver_input_state`` (check ``._initialize_specs_from_input_state()`` for more details). records Mapping of package names to ``PackageRecord`` objects. If not provided, it will be initialized from the ``installed`` records in ``solver_input_state``. for_history Mapping of package names to ``MatchSpec`` objects. These specs will be written to the prefix history once the solve is complete. Its default initial value is taken from the explicitly requested packages in the ``solver_input_state`` instance. neutered Mapping of package names to ``MatchSpec`` objects. These specs are also written to the prefix history, as part of the neutered specs. If not provided, their default value is a blank mapping. conflicts If a solve attempt is not successful, conflicting specs are kept here for further relaxation of the version and build constrains. If not provided, their default value is a blank mapping. Notes ----- Almost all the attributes in this object map package names (``str``) to ``MatchSpec`` (_specs_ in short) objects. The only mapping with different values is ``records``, which stores ``PackageRecord`` objects. A quick note on these objects: * ``MatchSpec`` objects are a query language for packages, based on the ``PackageRecord`` schema. ``PackageRecord`` objects is how packages that are already installed are represented. This is what you get from ``PrefixData.iter_records()``. Since they are related, ``MatchSpec`` objects can be created from a ``PackageRecord`` with ``.to_match_spec()``. * ``MatchSpec`` objects also feature fields like ``target`` and ``optional``. These are, essentially, used by the low-level classic solver (:class:`conda.resolve.Resolve`) to mark specs as items it can optionally play with to satisfy the solver constrains. A ``target`` marked spec is _soft-pinned_ in the sense that the solver will try to satisfy that but it will stop trying if it gets in the way, so you might end up a different version or build. ``optional`` seems to be in the same lines, but maybe the entire spec can be dropped from the request? The key idea here is that these two fields might not be directly usable by the solver, but it might need some custom adaptation. For example, for ``libmamba`` we might need a separate pool that can be configured as a flexible task. See more details in the first comment of ``conda.core.solve.classic.Solver._add_specs`` N)r%records for_historyneutered conflictssolver_input_stater%rrrrcr||_td|_|r|j|dn(|jr!|j|jdtd|_|r|j|dn|td|_|r|j|dn(|jr!|j|jdtd|pid |_ td |pid |_ dS) Nrz,Initialized from explicitly passed argumentsreasonz-Initialized from installed packages in prefixr%rz6Initialized from requested specs in solver input staterzFrom arguments)datarr) rr"rrrsr%"_initialize_specs_from_input_staterrCrr)r*rr%rrrrs r+rozSolverOutputState.__init__s5G4>y4I4I   L  0^  _ _ _ _  )  L  ",F     /9.A.A  6 J  e,Z  [ [ [ [  3 3 5 5 54>}4M4M     # #$R $     )    # #",O $    2< hn"6F2 2 2  3= yB8H3 3 3 r-c|jjr|j|jjd|jjD]\}}||jjvr+|j|t|d>||jj vr,|j|t|ddx|j dkr*|j|t|dn0|jd |jjDd |jj D]-}|j|t|d d.d S) z Provide the initial value for the ``.specs`` mapping. This depends on whether there's a history available (existing prefix) or not (new prefix). z As in historyrz#Installed and in aggressive updatesz(Installed and protected in do_not_removeF)r overwriterz2Installed from PyPI; protect from indirect pruningc.i|]}|t|Sr3r)rRrPs r+rTzHSolverOutputState._initialize_specs_from_input_state..,s UUU4yUUUr-z"Installed and no history availablezVirtual systemN) rrr%rrsrrrrrrsubdirrn)r*rPrXs r+rz4SolverOutputState._initialize_specs_from_input_states  " *"  J  d5=o  V V V $ 7 A G G I I   f42EEEJNNioo6[#T4BBBJNN!$I"' # ]f,, JNN!$S#+ 8 J  UU43J3TUUU;     +3 \ \D JNN449IUZN [ [ [ [ \ \r-crtt|jjS)z Massage currently stored records so they can be returned as the type expected by the solver API. This is what you should return in ``Solver.solve_final_state()``. )r rrrgraphr|s r+current_solutionz"SolverOutputState.current_solution6s+ +dl&9&9&;&;<<BCCCr-cHd|jDS)z/ Specs that are _not_ virtual. cDi|]\}}|d||S__rrRrPrSs r+rTz0SolverOutputState.real_specs..Cs0]]]ztTtW[G\G\]d]]]r-r%rrr|s r+ real_specszSolverOutputState.real_specs>s' ^]TZ-=-=-?-?]]]]r-cHd|jDS)z) Specs that are virtual. cDi|]\}}|d||Srrrs r+rTz3SolverOutputState.virtual_specs..Js0YYYztT4??SWCXCXYdYYYr-rr|s r+ virtual_specszSolverOutputState.virtual_specsEs' ZYTZ-=-=-?-?YYYYr-indexr&c|jjr|n||||jS)z Main method to populate the ``specs`` mapping. ``index`` is needed only in some cases, and only to call its method ``.explicit_pool()``. )rr_prepare_for_remove_prepare_for_add_prepare_for_solver%)r*rs r+ prepare_specszSolverOutputState.prepare_specsLsU  " . )  $ $ & & & &  ! !% ( ( ( !!!zr-c |j}|jD]\}fd|jD}|s.t |dkr|||d}|jr0|j|| d||j vr+|j|t|d||j vr1|j|| d||j vrK|j|t|j ||d X|j|t||d t}|jr9t||j}|jD]\}td }||jv} ||jvr | s|j||d I| r|j|r5d} |j||| ||d} |j||j|| ||vr|j||dt*d |jjr|jD]}\}}||j vr@|j|t|| ddN|j|| d~n|jjrX|jj} |jd|j r|j D]Y}||jvr$|j|| |d/|j|t|dZ|jD]:\}}|jdkr*|j|t|d;n|jD]Y}||jvr$|j|| |d/|j|t|dZn[|jjrO|j D]G}||jvr<||j vr3||jvr*|j|t|dHd|jvrd|jvr|jd}d|j vr<|jjr0|jd| dn|jdtdd rd!} n*d"} tA|j!d#z} t| $|jd| tDj#sE|j D]+\}||jvr|j|d%,|jD]&\}||vr|j|d&'d'|jvrd'|jvrtI|j%tDj&r|jd'}|jd'd(|j!} d s0t| $d)} |jd'| tDj'rBd'|jvr;td'| d*+d,} |jd'| d*Sd*Sd*Sd*Sd*Sd*S)-a This is the core logic for specs processing. In contrast with the ``conda remove`` logic, this part is more intricate since it has to deal with details such as the role of the history specs, aggressive updates, pinned packages and the deps / update modifiers. Parameters ---------- index Needed to query for the dependency tree of potentially conflicting specs. c>g|]}||Sr3)ru)rRrXrSs r+ z6SolverOutputState._prepare_for_add..ts+___DJJW]L^L^_f___r-r rz Spec matches unmanageable recordrz)Spec matches record in aggressive updatesz1Spec matches record in explicit pool for its name)targetzSpec matches record in historyzSpec matches recordF)optionalz#Pinned, installed and not requestedzXPinned, installed and requested; constraining request as pin because they are compatiblezqPinned, installed and requested; pin and request are conflicting, so adding user request due to higher precedencez>Pin matches one of the potential dependencies of user requestszEpinned spec %s conflicts with explicit specs. Overriding pinned spec.T)rrz/Relaxing installed because it caused a conflictzFreezing as installedz+Redefining from scratch due to --update-allz8Update all, with history, pinned: reusing existing entryzRUpdate all, with history, not pinned: adding spec from history with no constraintsrzKUpdate all, with history: treat pip installed stuff as explicitly installedz6Update all, no history, pinned: reusing existing entryzRUpdate all, no history, not pinned: adding spec from installed with no constraintszRelaxed because conflictingpythonzHFreezing python due to business rule, freeze-installed, and no conflictsversionz2Leaving Python pinning as it was calculated so farz)Pinning Python to match installed version.*)rzAggressive updates relaxationzExplicitly requested by userr?z>=z;Pinning conda with version greater than currently installedN)rrzHPinning conda with version greater than currently installed, auto update)(rr%rrrrlen _raise_incompatible_spec_recordsis_unmanageabler to_match_specrrrrdist_strrqr,rCrsrurlogwarnrDr:r=_datacopyclearrr<rtrrrofflinerrB conda_prefixauto_update_conda)r*rsisrPrecord_matchesrX pin_overridesr,pinrCr old_specsrrequired_versionrSs @r+rz"SolverOutputState._prepare_for_addXs: %***,,* * JD$____4<3F3F3H3H___N! >""a''55dNKKK$A&F%  &..009[/// )D//2]T^++ ((**N $$  ck$/8I8IJJJ; )D1B1BCCCLa : M 3 3CM4H4H4J4J K KLLM***,,& & JD$D5111C -Is}$$Y$ tS1VWWWW! =&,,T22 M=JNN4VN<<<!%%d++++[JNN4t)))JNN!$v/C/C/E/EPTUUUP# JNN4)=)=)?)?H_N```` a +H ` (--//I J  $Q  R R R{(  K  Dsz))  %dO#]'   %dOO$?'%(M$7$7$9$9LD&}..  %dOO$<' M  Dsz))  %dO#['   %dOO$<'  - `& ` ` **CK//CM11JNN44A^N___ t| # # (E(E\(+Ft~--#2E2V- ((**'z~~h (0C0CDD88I&&<QFFHF5fnEELG$T7;;;D xf=== W!4::<< W W d4:%%JNN46UNVVV---// R RJD$=(( tT2PQQQ tz ! !3=((CJ(<==)]7+F:g&D4FN44 88I&& = /?@@@V wV<<<( =WCM-I-I 2B4PPPc wV<<<<< " !(((( = =-I-Ir-cR|j|jjddS)z.Just add the user requested specs to ``specs``zAdding user-requested specsrN)r%rrrCr|s r+rz%SolverOutputState._prepare_for_removes, $1;Dabbbbbr-cfdjDrGfdtjjjD}t |jjdS)a Last part of the logic, common to addition and removal of packages. Originally, the legacy logic will also minimize the conflicts here by doing a pre-solve analysis, but so far we have opted for a different approach in libmamba: let the solver try, fail with conflicts, and annotate those as such so they are unconstrained. Now, this method only ensures that the pins do not cause conflicts. cPg|]"\}}|jjvt|#Sr3)rrqr2)rRrPrSr*s r+rz8SolverOutputState._prepare_for_solve..s>" " " dt.555 II555r-c6g|]}|vt|Sr3)r2)rRrSconflicting_and_pinneds r+rz8SolverOutputState._prepare_for_solve..s5555D 555r-)requested_specs pinned_specsrBN)rrrrr%rrCrrB)r*rCrs` @r+rz$SolverOutputState._prepare_for_solves" " " " "n2244" " "  " !$*d.E.OPPI 2 )3.5   r-c|jjrzjrsjD]R\}}jD]3}||r|j |n4S|j Sj j r8js1jD]\}}|jvrn|j Sjr6fdjD}|rt|dSdS)z} Operations that do not need a solver at all and might result in returning early are collected here. c,g|]\}}|jv|Sr3)rs)rRrPrSrs r+rz0SolverOutputState.early_exit..s0#tCM@Y@Y@Y@Y@Yr-N)rrrGrCrrrsrrurpoprrDr9r)r*rPrSrX not_installedrs @r+ early_exitzSolverOutputState.early_exitsg % ? )s/ )!m1133   d!m2244Fzz&)) ((...( (   9 -#/ -!m1133 - - ds},,E- ,, ? ;'*}':':'<'<M ;+M:::  ; ; ; ;r-solverSolverc  |j}|j|jd|jD]N\}}|j|}|r-|j|jkr|j ||dO|j j rt|j}i}|jD];\}}|jD]}||r|||<<|jr |D]}||=n|D] \}}|||< |jd|j|dnX|j jrq|jjsdt/|j|j} | } g} |jr=| D]9}|j|jvr|j|jvr| |j:nj| D]g}|jD]C} t9| }|j|jvr$d} |j |j|| D| |jh| D]]}|j|}|r|j ||d<|j|jd^n|jjrt=d }t/|j} |jD]a\}}| |}| |D]1}| |jt9|jd 2b|j!D]\}}||d d d |vrj|jd }d"|j#$dd ddz}| d t9d |||jd|jr$d}tK|&}n#tK|}d}tOj(dd5|)|j*|j+|j,||d-t\j/|j0|j1|j2|j3}d|D}d d d n #1swxYwY|jd|j|d|jd|j|dd|_4|j3rt/tK|j|j} | 3|jd|jd| j5Ddd Sd S)a2 These tasks are performed _after_ the solver has done its work. It essentially post-processes the ``records`` mapping. Parameters ---------- solver_cls The class used to instantiate the Solver. If not provided, defaults to the one specified in the context configuration. Notes ----- This method could be solver-agnostic but unfortunately ``--update-deps`` requires a second solve; that's why this method needs a solver class to be passed as an argument. z(User requested specs recorded to historyrz.Spec needs less strict constrains than historyz#Redefining records due to --no-depsz"Redefined records due to --no-depsz1Recording deps brought by --only-deps as explicitz1Restoring originally installed due to --only-depsz*Excluding from solution due to --only-depsupdate_deps_specsz New specs asked by --update-depsNz0Exclude pinned packages from --update-deps specsr.r)rPrz5Add original requested specs on top for --update-depsr3quietFrecursive_call_for_update_deps)rBchannelssubdirs specs_to_addspecs_to_removerJ)rDrErFrGrIci|] }|j| Sr3rOrWs r+rTz0SolverOutputState.post_solve..ysEEE66;EEEr-zRedefining due to --update-depszRedefined due to --update-depsPruningci|] }|j| Sr3rOrWs r+rTz0SolverOutputState.post_solve..s O O Of O O Or-Pruned)6rrrrCr%rrrrt strictnessrrrEr7dictrsrrrurrr8rDr;r+remove_youngest_descendant_nodes_with_specsrPappenddependsrrr"get_node_by_name all_ancestorsrqjoinrrlistkeysr _override __class__rBr r solve_final_staterr<rerFrGrIrir)r*rrrPrS history_specoriginal_stateonly_change_theserXr would_remove to_remove dependencyrrs new_specsancestorrr r rs r+ post_solvezSolverOutputState.post_solves"%  6`aaa***,,  JD$;??400L ,2I I I !!$'W"   $L  "#-00N " !m1133 9 9 d"l113399Fzz&))928)$/9 2---D&t,,-%6$;$;$=$=22LD&+1N4(( L  &K  L L L L  7[  \ \ \ \   (t 1D1Pt   3 3 5 5s}7K7K7M7MNNE!LLNNLI 2*22F{#-77FK3=#7#7#<#Raise an error if something is very wrong with the environmentaw Conda encountered an error with your environment. Please report an issue at https://github.com/conda/conda/issues. In your report, please include the output of 'conda info' and 'conda list' for the active environment, along with the command you invoked that resulted in this error. pkg_name: z spec: z# matches_for_spec: )indentz )r rrPr)rSrs r+rz2SolverOutputState._raise_incompatible_spec_recordssi   9   $,GA#>#>#>     r-)r.r/r0r1r5rrr2rrrorrrrrr$rrrrrr r& staticmethodrr3r-r+rrs22p489=9=6:7;- - - -- Y/0 - '#}"456 - gc9n56 - 73 >23- GCN34- - - - ^0\0\0\dDDXD^^X^ ZZXZ ; 73 >3J    a=ka=a=a=a=R ccc L;;;B}bh}b}b}b}b~  \   r-r)rBs99z"""""";;;;;;;;;;;;;;''''''!!!!!!========&&&&&&$$$$$$BBBBBBBB::::::------------SSSSSSSS!!!!!!((((((------111111......++++++++g+++,, " " " " " " " "qJqJqJqJqJqJqJqJh }  }  }  }  }  }  }  }  }  }  r-