o Zh]@s&UddlmZddlZddlZddlZddlmZmZddlm Z m Z m Z m Z m Z mZmZmZmZddlmZmZddlmZdd lmZmZmZmZmZergdd lmZmZm Z dd l!m"Z"m#Z#dd l$m%Z%d Z&de'd<d%ddZ(Gdddee e e fZ)Gdddee e e fZ*d&d#d$Z+dS)') annotationsN) TYPE_CHECKINGGeneric) CTKTRT DirectedGraph IterableViewIteratorMappingRequirementInformationStatebuild_iter_view)AbstractResolverResult) Criterion)InconsistentCandidateRequirementsConflictedResolutionImpossibleResolutionTooDeepResolverException) CollectionIterableMapping)AbstractProvider Preference) BaseReporterg?float_OPTIMISTIC_BACKJUMPING_RATIOstateState[RT, CT, KT]returnResult[RT, CT, KT]c s|j}dd|D}d|td<t}|ddh|jD]>\}}t|j||s/q"||vr8|||D]#}z|t|}Wn tyOYq(sz!_build_result..csi|] \}}|vr||qSr$r$r& connectedr$r*r+>s)mappinggraphcriteria) r.itemsr%r addr0_has_route_to_root iter_parentKeyErrorconnectr)r r.all_keysr/key criterionppkeyr$r,r* _build_result&s4       r<c@seZdZdZdBdd ZedCd d ZdDd dZdEddZdFddZ dGddZ dHd#d$Z dId'd(Z dJd*d+Z dKd.d/ZdDd0d1ZdDd2d3ZdLd6d7ZdMd9d:ZdNd?d@ZdAS)O 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. providerAbstractProvider[RT, CT, KT]reporterBaseReporter[RT, CT, KT]r"NonecCs(||_||_g|_t|_d|_d|_dSN)_p_r_statesr_optimistic_backjumping_ratio _save_statesZ_optimistic_start_round)selfr>r@r$r$r*__init__Ks  zResolution.__init__r!c Cs0z|jdWSty}ztd|d}~ww)Nr )rF IndexErrorAttributeError)rIer$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. rKNr.r0backtrack_causes)rFr r.copyr0rPappend)rIbaser r$r$r*_push_new_state`s  zResolution._push_new_stater0dict[KT, Criterion[RT, CT]] requirementrparent CT | Nonec Cs|jj||d|jj|d}||}|rt|j}ng}|jj|t|t d||git|t d||id}|rJt|j }| t||nt||g}tt|||d}|js`t||||<dS)N)rVrW)requirement_or_candidateiter_requirementincompatibilities identifier requirementsr[ candidates informationr[)rEadding_requirementrDidentifygetlistr[ find_matchesr operator methodcaller attrgetterrarRr rrr`r) rIr0rVrWr]r9r[matchesrar$r$r*_add_to_criterians>     zResolution._add_to_criteriaparentsCollection[KT]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|]}|jdusj|jvr|qSrC)rWrDrc)r'rarlrIr$r* s  z@Resolution._remove_information_from_criteria..)r1rr`rar[)rIr0rlr8r9r$rnr*!_remove_information_from_criterias   z,Resolution._remove_information_from_criterianamerrc Cs>|jj||jjt|jjtdt|jjtd|jjdS)Nr`ra)r] resolutionsr`rarP) rDget_preferencer r.r r0rgrirP)rIrqr$r$r*_get_preferenceszResolution._get_preferencer9Criterion[RT, CT]boolcsBzjj|Wn tyYdSwtfdd|DS)NFc3 |] }jj|dVqdS)rV candidateNrDis_satisfied_byr'r current_pinrIr$r*  z8Resolution._is_current_pin_satisfying..)r r.r5allrZ)rIrqr9r$r~r*_is_current_pin_satisfyings z%Resolution._is_current_pin_satisfyingryrcCs4|jj}|jj|dD] }|j|||dq |S)NryrW)r r0rQrDget_dependenciesrk)rIryr0rVr$r$r*_get_updated_criterias z Resolution._get_updated_criterialist[Criterion[RT, CT]]c sjj|}g}|jD]^z}Wn ty4}zj|j||jWYd}~q d}~wwt fdd| D}|sJt |jj djj |jj|djj|<gS|S)Nc3rwrxrzr|ryrIr$r*rrz7Resolution._attempt_to_pin_criterion..r)r r0r`rrrEZrejecting_candidater9rRrrZrpinningupdater.pop)rIrqr9causesr0rN satisfiedr$rr*_attempt_to_pin_criterions,       z$Resolution._attempt_to_pin_criterionincompatibilities_from_brokenlist[tuple[KT, list[CT]]]c Cs|D]R\}}|s qz|jj|}Wn tyYqw|jj|t|jjtdt|jjtd||id}t |}|s@dS| |j t |t |j|d|jj|<qdS)NrZr[r\Fr_T)r r0r5rDrfr rgrhrirextendr[rrera)rIrr(r[r9rjr`r$r$r*_patch_criterias<    zResolution._patch_criteriacCs$|jdurdd|jD|_dSdS)zCSave states for potential rollback if optimistic backjumping fails.NcSs0g|]}t|j|j|jdddqS)NrO)r r.rQr0rP)r'sr$r$r*ro!s z*Resolution._save_state..)rHrFrIr$r$r* _save_states  zResolution._save_statecCs"d|_|jr|j|_d|_dSdS)z3Rollback states and disable optimistic backjumping.gN)rGrHrFrr$r$r*_rollback_states*s  zResolution._rollback_statesr$list[RequirementInformation[RT, CT]]c s:tdd|Ddd|D}fdd|D}tjdkrjd=j} zj}|j\}}Wntt fyDt |d wj sM||vrMn(j r]j d ur]||vr] fd dj|D}||spn|jstnq(d d |jD}|||gf|} | rdStjdks d S)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|jVqdSrCrr'cr$r$r*rQsz'Resolution._backjump..css|]}|jVqdSrC)rVrr$r$r*rRsch|]}j|qSr$rDrcr|rr$r* Tsz'Resolution._backjump..rKTNcrr$r)r'drr$r*rws cSsg|] \}}|t|jfqSr$)rer[r&r$r$r*rosz(Resolution._backjump..F) itertoolschainlenrFr rr.popitemrLr5rrGrHrrDr isdisjointr0r1rRrTr) rIrZincompatible_reqsZincompatible_deps broken_staterqryZcurrent_dependenciesrsuccessr$rr* _backjump1sT        ( @zResolution._backjumpcriteroncCstdd|DS)z5Extract causes from list of criterion and deduplicatecSs"i|] }|jD]}t||qqSr$)rar%)r'rir$r$r*r+s"z.Resolution._extract_causes..)revalues)rIrr$r$r*_extract_causesszResolution._extract_causesr^ Iterable[RT] max_roundsintc sjrtdjttigdg_|D]!}z jjj |ddWqt y:}zt |j j |d}~wwd}d}t|D]#}jj|djrjdur|durr|}t||j}|dkrqqGn|dur|||krqGfddjj D}|sjjjdjStjj t|t|d krtjj|jjtjj t d tjj t d jj!d } n|} | std t| d krt"| j#d} n| d} $| } | rH%| } jj&| dz'| } Wnt yjrjrd}nYnwt(| o(jo(j}|r6jr6n,| jj!dd<| sGt jj!nfddjj D})jj |jj*|jdqGt+|)Nzalready resolvedrOr)indexrcs g|] \}}||s|qSr$rr'r8r9rr$r*ros  z&Resolution.resolve..)r rr`ra)Z identifiersrrr`rarPz-narrow_requirement_selection returned 0 names)r8)rTcs(h|]\}}|vr||s|qSr$rrZsatisfied_namesrIr$r*rs z%Resolution.resolve..)rr ),rF RuntimeErrorrEstartingr collections OrderedDictrkr r0rrr9rarTrangestarting_roundrGrHrrr1endingsetkeysrrerDZnarrow_requirement_selectionr.r rgrirPminrtrrresolving_conflictsrrvrp ending_roundr)rIr^rr}rNZoptimistic_rounds_cutoffZ"optimistic_backjumping_start_round round_indexunsatisfied_namesZnarrowed_unstatisfied_namesrqZfailure_criterionrrZfailed_optimistic_backjumpingZnewly_unsatisfied_namesr$rr*resolves             zResolution.resolveN)r>r?r@rAr"rB)r"r!)r"rB)r0rUrVrrWrXr"rB)r0rUrlrmr"rB)rqrr"r)rqrr9rur"rv)ryrr"rU)rqrr"r)rrr"rv)rrr"rv)rrr"r)r^rrrr"r!)__name__ __module__ __qualname____doc__rJpropertyr rTrkrprtrrrrrrrrrr$r$r$r*r=Ds$     ,    % #  fr=c@s"eZdZdZeZ d d d d Zd S)Resolverz3The thing that performs the actual resolution work.dr^rrrr"r#cCs$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>r@rr<)rIr^r resolutionr r$r$r*r3s zResolver.resolveN)r)r^rrrr"r#)rrrrrbase_exceptionrr$r$r$r*r.s rr0Mapping[KT, Criterion[RT, CT]]r8 KT | Noner7dict[int, KT | None]r-set[KT | None]rvc Cs||vrdS||vr dS|dusJ||D]/}z|t|}Wn ty+Yqw||vr8||dSt||||rG||dSqdS)NTF)r4r%r5r2r3)r0r8r7r-r:r;r$r$r*r3Xs&    r3)r r!r"r#) r0rr8rr7rr-rr"rv), __future__rrrrgtypingrrstructsrrrr r r r r rZabstractrrr9r exceptionsrrrrrcollections.abcrrr providersrr reportersrr__annotations__r<r=rr3r$r$r$r*s*,    m*