@(i$SrSSKJr SSKrSSKJr SSKJr SSKJ r SSK J r SSK J r Jr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJrJr SSKJr SSKJr SSK J!r! SSK"J#r# \(a$SSK$J%r% SSK&J'r' SSKJ(r( SSKJ)r) SSK*J+r+ SSK,J-r- SSK.J/r/J0r0 \Rb"S\235r3"SS5r4"SS5r5S!S jr6g)"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. ) annotationsN)MappingProxyType) TYPE_CHECKING) IndexedSet)NULL) DepsModifierUpdateModifier)context) paths_equal)Index) PrefixData)get_pinned_specs)PackagesNotFoundErrorSpecsConfigurationConflictError)History)Channel) MatchSpec) PrefixGraph)Iterable)PathLike)Any)Solver) PackageRecord)LibMambaIndexHelper) EnumAsBoolscompatible_specszconda.c \rSrSrSr\R \R\R\ R\ R\ R\ R\ RS.rSrS\ R\R SSSSSS4 S Sjjr\4S!S jjr\S"S j5r\S#S j5r\S$S j5r\S$S j5r\S$Sj5r\S$Sj5r\S$Sj5r\S$Sj5r\S$Sj5r\S%Sj5r\S%Sj5r\S%Sj5r \S%Sj5r!\S&Sj5r"\S&Sj5r#\S%Sj5r$\S%Sj5r%\S%Sj5r&\S%Sj5r'S'Sjr(S'Sjr)Sr*g)(SolverInputStateca$ 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_shortcutNFc Xl[XS9UlXl[ U5R 5Ul[U5V s0sHoRU _M sn Ul [RV s0sHoRU _M sn Ul [5Rn U V s0sHoRU _M sn Ul0UlUH&n [#U 5n XR U R'M( UR%SU5UlU(a3UR&[(R*:Xa[(R,UlUR%SU5UlUR%SU5UlUR%SU5UlUR%SU5UlXlXlUR:Vs0sHo[#U5_M snUlgs sn fs sn fs sn fs snf)N)interoperabilityupdate_modifier deps_modifier ignore_pinned force_removeforce_reinstall)prefixr _prefix_data_pip_interop_enabledrget_requested_specs_map_historyrname_pinnedr aggressive_update_packages_aggressive_updatesr system_packages_virtual _requestedr_default_to_context_if_null_update_modifierr r%r'_deps_modifier_ignore_pinned _force_remove_force_reinstall_prune_command_DO_NOT_REMOVE_NAMES_do_not_remove)selfr5 requestedr0r1r2r3r4prunecommandr7specvirtualrecordps S/data/cameron/miniconda/lib/python3.13/site-packages/conda_libmamba_solver/state.py__init__SolverInputState.__init__s &vU$8!??A 4DV4LM4LD 44LM @G@b@b#c@bIItO@b#c '));BC7f,7C DT?D)-OODII &!% @ @ !  T**n.M.MM$2$?$?D !">>P]^">>P]^!==nl[ $ @ @ !   9=8Q8QR8Q1)A,8QR5N#cD,SsG"6G',G,G1c`U[La [X15$URRX"5$)zTObtain default value from the context if value is set to NULL; otherwise leave as is)rgetattr _ENUM_STR_MAPget)rKr:valuer s rSrA,SolverInputState._default_to_context_if_nulls*).$ww%`Drr\c URS:H$)z- True if the used subcommand was ``remove``. removerr^s rS is_removingSolverInputState.is_removingErr\c,[UR5$)z 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 )rrBr^s rSr0 SolverInputState.update_modifierNs40011r\c,[UR5$)z 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 )rrCr^s rSr1SolverInputState.deps_modifier[s4..//r\cUR$N)rDr^s rSr2SolverInputState.ignore_pinnedjs"""r\cUR$r)rEr^s rSr3SolverInputState.force_removens!!!r\cUR$r)rFr^s rSr4 SolverInputState.force_reinstallrs$$$r\cUR$r)rGr^s rSrMSolverInputState.prunevs {{r\c#:# URR5HynURS5nU(dMUR(aGURR S5(a'[ URR S5S5nUv M{ g7f)z 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)rLvaluesget_exact_valueoriginal_spec_str startswithrsplit)rKrOrs rSchannels_from_specs$SolverInputState.channels_from_specs|sxNN))+D**95Gw))d.D.D.O.OPY.Z.Z%d&<&<&B&B4&H&KLG ,s 4BA!Bc## [[SS5=n(a[R OUc[[SS5nU(a[R"S5v gg7f)N_restore_free_channelrestore_free_channelz#https://repo.anaconda.com/pkgs/free)rWr custom_multichannelsrfrom_url)rKrs rSmaybe_free_channel#SolverInputState.maybe_free_channelsQg'>E E7 E  ( ( _g'=tDG ""#HI I sAA!)r=rHrCrJrFrEr9rDr;r7r6rGr@rBr?r5)r5zstr | bytes | PathLikerLz Iterable[str | MatchSpec] | Noner0zUpdateModifier | Noner1zDepsModifier | Noner2 bool | Noner3rr4rrMrrNz str | Noner7r)returnr)rr )rzdict[str, PackageRecord]rzdict[str, MatchSpec])rbool)rr)rzIterable[Channel])+__name__ __module__ __qualname____firstlineno____doc__rr!r"r#r r$r%r&r'r(rXrIrTr rApropertyr_rfrirlrPrqrzr}rLrrrrr0r1r2r3r4rMrr__static_attributes__r-r\rSrrcs(V ''''!++&4&O&O*;;%11&33$// M791?1L1L-9-A-A%)$)',"",0+S&+S4+S/ +S + +S # +S"+S%+S+S+S*+SZ@Ga!!XX// . .EE::&&&5511** )) )) )) 2 2 0 0##""%% Jr\rc\rSrSrSrSSSSSS.SSjjr\SSj5r\SSj5r\SSj5r \SS j5r SS jr SS jr SS jr S rg)SolverOutputStateia 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. records Dict of package names to ``PackageRecord`` objects. If not provided, it will be initialized from the ``installed`` records in ``solver_input_state``. for_history Dict 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 Dict 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. pins Packages that ended up being pinned. Mostly used for reporting and debugging. Deprecated. 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)records for_historyneutered conflictspinscXlU=(d [UR5UlU=(d [UR5UlU=(d 0UlU=(d 0UlU=(d 0Ulgr) solver_input_staterbrfrrLrrrr)rKrrrrrrs rSrTSolverOutputState.__init__s]5G181^DASA]A]<^ 1<1bEWEaEa@b.6n" /8B*.*" r\cn[[URR55R5$)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()``. )rrrrgraphr^s rScurrent_solution"SolverOutputState.current_solutions' +dll&9&9&;<BBCCr\cHURn0nSHCn[[X5R5[SS9HupEUR XE5 M ME SHDn[X5R5H$upGUR XGR 55 M& MF U$)z Merge all possible sources of input package specs, sorted by their input category and strictness. It's just meant to be an enumeration of all possible inputs, not a ready-to-use list of specs for a solver. )rLrlrirqT)keyreverse)rfrP)rrcrWresort_by_spec_strictnessrw to_match_spec)rKsisspecs_by_strictnessgroupr:rO record_grouprQs rSspecsSolverOutputState.specss%%  E %#))++  $..t:   5L ' : @ @ B #..t5I5I5KL!C5#"r\cURR5VVs0sHupURS5(aMX_M! snn$s snnf)z Specs that are _not_ virtual. __rrerrKr:rOs rS real_specsSolverOutputState.real_specss= .2ZZ-=-=-?]-?zttW[G\  -?]]] AAcURR5VVs0sHupURS5(dMX_M! snn$s snnf)z Specs that are virtual. rrrs rS virtual_specsSolverOutputState.virtual_specss= .2ZZ-=-=-?Y-?zt4??SWCX  -?YYYrc^URnUR(aUR(a URn/nURR 5HsunmUR R5H>nTRU5(dMUR(aWRU5 M` URT5 Mu U(a[U5nSUl UeUR(aW$gURR(auURR 5HKunmXAR ;a g[U4SjUR R555(aMK g UR$g)z^ Operations that do not need a solver and might result in returning early are collected here. Fc3F># UHnTRU5v M g7fr)match).0rQrOs rS /SolverOutputState.early_exit..+sS;SolverOutputState.check_for_pin_conflicts..Qs QRQWQWr\)r)requested_specs pinned_specsr5FN)rsetrL intersectionrlrfrYis_name_only_specrrrcrerrr5r) rKindexrrequested_and_pinnedr:rLpinrfrrs rScheck_for_pin_conflicts)SolverOutputState.check_for_pin_conflicts3s&%%"3==1>>szzJ(D d+I**T"C ))$/I&&9Y__Y=W=W'3/?@@&,CJJ,<,<,>%? %? 695J5JS]]&&t1PSS%? 6$*3==+?+?+AGW$X!-:: #( )) s":E!c 4URnURRUR5 URR 5Haup4UR RU5nU(dM)URU5(aMA[X5RS9URU'Mc URR(a[UR5n0nURR 5HBup4UR R!5HnURU5(dMXWU'M! MD UR"(a UHnXc M OUR 5H up5XVU'M UR R%5 UR RU5 GOURR&(GaUR(R*(Gd[-UR R!5URR!55nUR/5n /n UR"(a[U HTnUR0UR;aUR0UR;aM9U R3UR05 MV OvU HpnUR4HBn [U 5nUR0UR6;dM*X@RUR0'MD U R3UR05 Mr U HQnURRU5n U (aXR U'M5UR R9US5 MS GOUR(R*(Ga0n [-UR R!55nURR 5HOup4UR;U5nUR=U5H$n[UR05XR0'M& MQ UR>R 5Hup4U R9US5 M SU ;aLURSnSRAURRCS5SS5S-n[SUS9U S'U RUR5 UR"(aSn[EU RG55nOU R!55nSn[HRJ"S S 5 URMURNURPURRUUS S 9RU[VRXURZUR\UR^UR`S 9nUVs0sHoUR0U_M nnSSS5 UR R%5 UR RW5 URR%5 URRU 5 S Ul1UR`(a[-[EUR R!55[EURR!555nURa5 UR R%5 UR RURdVs0sHoUR0U_M sn5 ggs snf!,(df  GNP=fs snf)a 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. )versionNrt.z.*)r:rr-quietFrecursive_call_for_update_deps)r5channelssubdirs specs_to_addspecs_to_removerN)r0r1r2r3rM)3rrrrLrirerrYrrrrr1r"rbrfrrclearr#r0r&r+remove_youngest_descendant_nodes_with_specsr:rdependsrpopget_node_by_name all_ancestorsrljoinrlistkeysr _override __class__r5rrsolve_final_stater r'rCr2r3rMrGr)rKsolverrr:rOrQoriginal_stateonly_change_theser would_remove to_remove dependencyrf new_specsancestorrrrrs rS post_solveSolverOutputState.post_solveXsj"%%  .++++-JD\\%%d+Fvdjj00&/nn&M d#.    $ $ "#--0N " !mm113 "ll113Fzz&))28$/44 -D&,.%6$;$;$=LD+14(%> LL   LL   /    ( ( (1D1D1P1P1P  3 3 5s}}7K7K7MNE!LLNLI*F{{#--7FKK3==,,TYY7 '5 $$V[[1 +"MM--d3 )2LL&LL$$T40 " , , ,I 3 3 56E!mm113 //5 % 3 3F ;H/8/GImm,!<4 "jj..0  dD)19$x0((6>>#7#7#EEW6;;.WE%3( LL   LL   (    " " $    # #I .CJ 99T\\%8%8%: ;T#--BVBVBX=YZE KKM LL   LL  5;; O;f!4; O P F%32F!Ps%$A>\"[>8\\>\ \)rrrrrr) rrrzdict[str, PackageRecord] | Nonerdict[str, MatchSpec] | Nonerrrrrr)rzIndexedSet[PackageRecord]r)rz IndexedSet[PackageRecord] | None)rrrNone)rrrr)rrrrrrTrrrrrrrrrr-r\rSrrs0l48370415,05-51 5 1 5 . 5/5*5"DD##2^^ ZZ '-R#JnQr\rc(Uup[USS5U4$)zJ Helper function to sort a list of (key, value) tuples by spec strictness strictnessr)rW)key_value_tupler:rOs rSrr s!JD 4q )4 //r\)rztuple[str, MatchSpec]rztuple[int, str])7r __future__rloggingtypesrtypingrboltons.setutilsr conda.auxlibrconda.base.constantsrr conda.base.contextr conda.common.pathr conda.core.indexr conda.core.prefix_datar conda.core.solverconda.exceptionsrr conda.historyrconda.models.channelrconda.models.match_specrconda.models.prefix_graphrcollections.abcrosrrrconda.models.recordsrrrutilsrr getLoggerrlogrrrr-r\rSr7s9x#" '=&)"--S!(-1('2*0 & +,pJpJf pQpQf 0r\