a bai^@s8UddlmZddlZddlZddlZddlmZmZddlm Z m Z m Z m Z m Z mZmZmZmZddlmZmZddlmZdd lmZmZmZmZmZerdd lmZmZm Z dd l!m"Z"m#Z#dd l$m%Z%d Z&de'd<dddddZ(Gdddee e e fZ)Gdddee e e fZ*dddddddd Z+dS)!) annotationsN) TYPE_CHECKINGGeneric) CTKTRT DirectedGraph IterableViewIteratorMappingRequirementInformationStatebuild_iter_view)AbstractResolverResult) Criterion)InconsistentCandidateRequirementsConflictedResolutionImpossibleResolutionTooDeepResolverException) CollectionIterableMapping)AbstractProvider Preference) BaseReporterg?float_OPTIMISTIC_BACKJUMPING_RATIOState[RT, CT, KT]Result[RT, CT, KT])statereturnc s|j}dd|D}d|td<t}|ddh|jD]\}}t|j||s^qD||vrp|||D]J}z|t|}WntyYqxYn0||vr||| ||qxqDt fdd|D||jdS)NcSsi|]\}}t||qS)id.0kvr$r$e/var/www/html/SiteWeb/venv/lib/python3.9/site-packages/pip/_vendor/resolvelib/resolvers/resolution.py (z!_build_result..csi|]\}}|vr||qSr$r$r& connectedr$r*r+>r,)mappinggraphcriteria) r/itemsr%r addr1_has_route_to_root iter_parentKeyErrorconnectr)r"r/all_keysr0key criterionppkeyr$r-r* _build_result&s0       r=c@seZdZdZddddddZedd d d Zdd d d ZdddddddZddddddZ dddddZ ddddd d!Z d"dd#d$d%Z dd&dd'd(Z d)dd*d+d,Zdd d-d.Zdd d/d0Zd1dd2d3d4Zd&d1d5d6d7Zd8d9dd:d;d<Zd=S)> ResolutionzStateful resolution object. This is designed as a one-off object that holds information to kick start the resolution process, and holds the results afterwards. zAbstractProvider[RT, CT, KT]zBaseReporter[RT, CT, KT]None)providerreporterr#cCs(||_||_g|_t|_d|_d|_dSN)_p_r_statesr_optimistic_backjumping_ratio _save_statesZ_optimistic_start_round)selfr@rAr$r$r*__init__Ks zResolution.__init__r )r#c Cs@z |jdWSty:}ztd|WYd}~n d}~00dS)Nr")rE IndexErrorAttributeError)rHer$r$r*r"Ys zResolution.statecCs>|jd}t|j|j|jddd}|j|dS)zPush a new state into history. This new state will be used to hold resolution results of the next coming round. rJNr/r1backtrack_causes)rEr r/copyr1rOappend)rHbaser"r$r$r*_push_new_state`s  zResolution._push_new_statezdict[KT, Criterion[RT, CT]]rz CT | None)r1 requirementparentr#c Cs|jj||d|jj|d}||}|r8t|j}ng}|jj|t|t d||git|t d||id}|rt|j }| t||n t||g}tt|||d}|jst||||<dS)N)rTrU)requirement_or_candidateiter_requirementincompatibilities identifier requirementsrX candidates informationrX)rDadding_requirementrCidentifygetlistrX find_matchesr operator methodcaller attrgetterr^rQr rrr]r) rHr1rTrUrZr:rXmatchesr^r$r$r*_add_to_criterians>    zResolution._add_to_criteriazCollection[KT])r1parentsr#csDsdS|D].\}}t|jfdd|jD|j||<qdS)aWRemove information from parents of criteria. Concretely, removes all values from each criterion's ``information`` field that have one of ``parents`` as provider of the requirement. :param criteria: The criteria to update. :param parents: Identifiers for which to remove information from all criteria. Ncs,g|]$}|jdus$j|jvr|qSrB)rUrCr`)r'r^rirHr$r* s z@Resolution._remove_information_from_criteria..)r2rr]r^rX)rHr1rir9r:r$rjr*!_remove_information_from_criterias  z,Resolution._remove_information_from_criteriarr)namer#c Cs>|jj||jjt|jjtdt|jjtd|jjdS)Nr]r^)rZ resolutionsr]r^rO) rCget_preferencer"r/r r1rdrfrO)rHrmr$r$r*_get_preferenceszResolution._get_preferencezCriterion[RT, CT]bool)rmr:r#csBzjj|Wnty$YdS0tfdd|DS)NFc3s|]}jj|dVqdS)rT candidateNrCis_satisfied_byr'r current_pinrHr$r* sz8Resolution._is_current_pin_satisfying..)r"r/r6allrW)rHrmr:r$rxr*_is_current_pin_satisfyings z%Resolution._is_current_pin_satisfyingr)rsr#cCs4|jj}|jj|dD]}|j|||dq|S)NrsrU)r"r1rPrCget_dependenciesrh)rHrsr1rTr$r$r*_get_updated_criterias z Resolution._get_updated_criteriazlist[Criterion[RT, CT]]c sjj|}g}|jD]ȉz}WnLtyt}z4j|j||jWYd}~qWYd}~n d}~00t fdd| D}|st |jj djj |jj|djj|<gS|S)Nc3s|]}jj|dVqdSrrrtrvrsrHr$r*rzsz7Resolution._attempt_to_pin_criterion..r})r"r1r]rrrDZrejecting_candidater:rQr{rWrpinningupdater/pop)rHrmr:causesr1rM satisfiedr$rr*_attempt_to_pin_criterions(   "  z$Resolution._attempt_to_pin_criterionzlist[tuple[KT, list[CT]]])incompatibilities_from_brokenr#c Cs|D]\}}|sqz|jj|}Wnty8YqYn0|jj|t|jjtdt|jjtd||id}t |}|sdS| |j t |t |j|d|jj|<qdS)NrWrXrYFr\T)r"r1r6rCrcr rdrerfrextendrXrrbr^)rHrr(rXr:rgr]r$r$r*_patch_criterias:     zResolution._patch_criteriacCs |jdurdd|jD|_dS)zCSave states for potential rollback if optimistic backjumping fails.NcSs0g|](}t|j|j|jdddqS)NrN)r r/rPr1rO)r'sr$r$r*rk!s  z*Resolution._save_state..)rGrErHr$r$r* _save_states zResolution._save_statecCsd|_|jr|j|_d|_dS)z3Rollback states and disable optimistic backjumping.gN)rFrGrErr$r$r*_rollback_states*szResolution._rollback_statesz$list[RequirementInformation[RT, CT]])rr#c sNtdd|Ddd|D}fdd|D}tjdkrJjd=j}zj}|j\}}Wn tt fyt |dYn0j s||vrq j rj dur||vr fd dj|D}||sq |jsq tjd krPt |qPd d |jD}|||gf|} | r2d Sq2dS)a2Perform backjumping. When we enter here, the stack is like this:: [ state Z ] [ state Y ] [ state X ] .... earlier states are irrelevant. 1. No pins worked for Z, so it does not have a pin. 2. We want to reset state Y to unpinned, and pin another candidate. 3. State X holds what state Y was before the pin, but does not have the incompatibility information gathered in state Y. Each iteration of the loop will: 1. Identify Z. The incompatibility is not always caused by the latest state. For example, given three requirements A, B and C, with dependencies A1, B1 and C1, where A1 and B1 are incompatible: the last state might be related to C, so we want to discard the previous state. 2. Discard Z. 3. Discard Y but remember its incompatibility information gathered previously, and the failure we're dealing with right now. 4. Push a new state Y' based on X, and apply the incompatibility information from Y to Y'. 5a. If this causes Y' to conflict, we need to backtrack again. Make Y' the new Z and go back to step 2. 5b. If the incompatibilities apply cleanly, end backtracking. css|]}|jdur|jVqdSrBr~r'cr$r$r*rzQr,z'Resolution._backjump..css|] }|jVqdSrB)rTrr$r$r*rzRr,csh|]}j|qSr$rCr`rvrr$r* Tr,z'Resolution._backjump..rJNcsh|]}j|qSr$r)r'drr$r*rwsrcSsg|]\}}|t|jfqSr$)rbrXr&r$r$r*rksz(Resolution._backjump..TF) itertoolschainlenrEr"rr/popitemrKr6rrFrGrrCr isdisjointr1r2rQrSr) rHrZincompatible_reqsZincompatible_deps broken_statermrsZcurrent_dependenciesrsuccessr$rr* _backjump1sV        zResolution._backjump)criteronr#cCstdd|DS)z5Extract causes from list of criterion and deduplicatecSs"i|]}|jD]}t||qqSr$)r^r%)r'rir$r$r*r+r,z.Resolution._extract_causes..)rbvalues)rHrr$r$r*_extract_causesszResolution._extract_causes Iterable[RT]intr[ max_roundsr#c sjrtdjttigdg_|D]P}zjjj |ddWq2t y}zt |j j |WYd}~q2d}~00q2d}d}t|D]V}jj|djrjdur|dur|}t||j}|dkrqn"|dur|||krqfddjj D}|sRjjjdjStjj t|t|d krtjj|jjtjj t d tjj t d jj!d } n|} | std t| d krt"| j#d} n| d} $| } | r%| } jj&| dz'| } Wn,t yVjrPjrPd}nYn0t(| onjonj}|rjrn"| jj!dd<| st jj!n4fddjj D})jj |jj*|jdqt+|dS)Nzalready resolvedrNr~)indexrcs g|]\}}||s|qSr$r|r'r9r:rr$r*rks z&Resolution.resolve..)r"rr]r^)Z identifiersrnr]r^rOz-narrow_requirement_selection returned 0 names)r9)rTcs(h|] \}}|vr||s|qSr$rrZsatisfied_namesrHr$r*r"s z%Resolution.resolve..)rr"),rE RuntimeErrorrDstartingr collections OrderedDictrhr"r1rrr:r^rSrangestarting_roundrFrGrrr2endingsetkeysrrbrCZnarrow_requirement_selectionr/r rdrfrOminrprrZresolving_conflictsrrqrl ending_roundr)rHr[rrwrMZoptimistic_rounds_cutoffZ"optimistic_backjumping_start_round round_indexZunsatisfied_namesZnarrowed_unstatisfied_namesrmZfailure_criterionrrZfailed_optimistic_backjumpingZnewly_unsatisfied_namesr$rr*resolves &          zResolution.resolveN)__name__ __module__ __qualname____doc__rIpropertyr"rSrhrlrpr|rrrrrrrrr$r$r$r*r>Ds", %# kr>c@s(eZdZdZeZd ddddddZd S) Resolverz3The thing that performs the actual resolution work.drrr!rcCs$t|j|j}|j||d}t|S)aTake a collection of constraints, spit out the resolution result. The return value is a representation to the final resolution result. It is a tuple subclass with three public members: * `mapping`: A dict of resolved candidates. Each key is an identifier of a requirement (as returned by the provider's `identify` method), and the value is the resolved candidate. * `graph`: A `DirectedGraph` instance representing the dependency tree. The vertices are keys of `mapping`, and each edge represents *why* a particular package is included. A special vertex `None` is included to represent parents of user-supplied requirements. * `criteria`: A dict of "criteria" that hold detailed information on how edges in the graph are derived. Each key is an identifier of a requirement, and the value is a `Criterion` instance. The following exceptions may be raised if a resolution cannot be found: * `ResolutionImpossible`: A resolution cannot be found for the given combination of requirements. The `causes` attribute of the exception is a list of (requirement, parent), giving the requirements that could not be satisfied. * `ResolutionTooDeep`: The dependency tree is too deeply nested and the resolver gave up. This is usually caused by a circular dependency, but you can try to resolve this by increasing the `max_rounds` argument. )r)r>r@rArr=)rHr[r resolutionr"r$r$r*r8s zResolver.resolveN)r)rrrrrbase_exceptionrr$r$r$r*r3srzMapping[KT, Criterion[RT, CT]]z KT | Nonezdict[int, KT | None]zset[KT | None]rq)r1r9r8r.r#c Cs||vr dS||vrdS|dus$J||D]b}z|t|}WntyZYq0Yn0||vrt||dSt||||r0||dSq0dS)NTF)r5r%r6r3r4)r1r9r8r.r;r<r$r$r*r4]s"     r4), __future__rrrrdtypingrrstructsrrrr r r r r rZabstractrrr:r exceptionsrrrrrcollections.abcrrr providersrr reportersrr__annotations__r=r>rr4r$r$r$r*s(,    r*