o h]@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_states_optimistic_start_round)selfr>r@r$r$r*__init__Ks  zResolution.__init__r!c Cs0z|jdWSty}ztd|d}~ww)Nr )rF IndexErrorAttributeError)rJer$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. rLNr.r0backtrack_causes)rFr r.copyr0rQappend)rJbaser 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)rWrX)requirement_or_candidateiter_requirementincompatibilities identifier requirementsr\ candidates informationr\)rEadding_requirementrDidentifygetlistr\ find_matchesr operator methodcaller attrgetterrbrSr rrrar) rJr0rWrXr^r9r\matchesrbr$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)rXrDrd)r'rbrmrJr$r* s  z@Resolution._remove_information_from_criteria..)r1rrarbr\)rJr0rmr8r9r$ror*!_remove_information_from_criterias   z,Resolution._remove_information_from_criterianamerrc Cs>|jj||jjt|jjtdt|jjtd|jjdS)Nrarb)r^ resolutionsrarbrQ) rDget_preferencer r.r r0rhrjrQ)rJrrr$r$r*_get_preferenceszResolution._get_preferencer9Criterion[RT, CT]boolcsBzjj|Wn tyYdSwtfdd|DS)NFc3 |] }jj|dVqdS)rW candidateNrDis_satisfied_byr'r current_pinrJr$r*  z8Resolution._is_current_pin_satisfying..)r r.r5allr[)rJrrr9r$rr*_is_current_pin_satisfyings z%Resolution._is_current_pin_satisfyingrzrcCs4|jj}|jj|dD] }|j|||dq |S)NrzrX)r r0rRrDget_dependenciesrl)rJrzr0rWr$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)Nc3rxryr{r}rzrJr$r*rrz7Resolution._attempt_to_pin_criterion..r)r r0rarrrErejecting_candidater9rSrr[rpinningupdater.pop)rJrrr9causesr0rO 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)Nr[r\r]Fr`T)r r0r5rDrgr rhrirjrextendr\rrfrb)rJrr(r\r9rkrar$r$r*_patch_criterias<    zResolution._patch_criteriacCs$|jdurdd|jD|_dSdS)zCSave states for potential rollback if optimistic backjumping fails.NcSs0g|]}t|j|j|jdddqS)NrP)r r.rRr0rQ)r'sr$r$r*rp!s z*Resolution._save_state..)rHrFrJr$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)rWrr$r$r*rRsch|]}j|qSr$rDrdr}rr$r* Tsz'Resolution._backjump..rLTNcrr$r)r'drr$r*rws cSsg|] \}}|t|jfqSr$)rfr\r&r$r$r*rpsz(Resolution._backjump..F) itertoolschainlenrFr rr.popitemrMr5rrGrHrrDr isdisjointr0r1rSrUr) rJrincompatible_reqsincompatible_deps broken_staterrrzcurrent_dependenciesrsuccessr$rr* _backjump1sT        ( @zResolution._backjumpcriteroncCstdd|DS)z5Extract causes from list of criterion and deduplicatecSs"i|] }|jD]}t||qqSr$)rbr%)r'rir$r$r*r+s"z.Resolution._extract_causes..)rfvalues)rJrr$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 resolvedrPr)indexrcs g|] \}}||s|qSr$rr'r8r9rr$r*rps  z&Resolution.resolve..)r rrarb) identifiersrsrarbrQz-narrow_requirement_selection returned 0 names)r8)rTcs(h|]\}}|vr||s|qSr$rrsatisfied_namesrJr$r*rs z%Resolution.resolve..)rr ),rF RuntimeErrorrEstartingr collections OrderedDictrlr r0rrr9rbrUrangestarting_roundrGrHrrr1endingsetkeysrrfrDnarrow_requirement_selectionr.r rhrjrQminrurrresolving_conflictsrrwrq ending_roundr)rJr_rr~rOoptimistic_rounds_cutoff"optimistic_backjumping_start_round round_indexunsatisfied_namesnarrowed_unstatisfied_namesrrfailure_criterionrrfailed_optimistic_backjumpingnewly_unsatisfied_namesr$rr*resolves             zResolution.resolveN)r>r?r@rAr"rB)r"r!)r"rB)r0rVrWrrXrYr"rB)r0rVrmrnr"rB)rrrr"r)rrrr9rvr"rw)rzrr"rV)rrrr"r)rrr"rw)rrr"rw)rrr"r)r_rrrr"r!)__name__ __module__ __qualname____doc__rKpropertyr rUrlrqrurrrrrrrrrr$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<)rJr_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]rwc 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"rw), __future__rrrrhtypingrrstructsrrrr r r r r rabstractrrr9r exceptionsrrrrrcollections.abcrrr providersrr reportersrr__annotations__r<r=rr3r$r$r$r*s*,    m*