+ 2j0Rt^RIHt^RIt^RIt^RIt^RIt^RIHt^RI H t H t ^RI H t HtHt^RIHt^RIHtHtHtHt^RIHtHt^R IHt^R IHtHt^R IH t H!t!H"t"^R I#H$t$H%t%^R I&H't'^RI(H)t)^RI*H+t+^RI,H-t-^RI.H/t/^RI0H1t1H2t2H3t3H4t4H5t5H6t6H7t7H8t8H9t9H:t:H;t;Ht>H?t?^RI@HAtA^RIBHCtCHDtDHEtE^RIFHGtGHHtHHItIHJtJHKtK^RILHMtMHNtNHOtOHPtPHQtQHRtRHStSHTtTHUtUHVtVHWtW^RIXHYtYHZtZH[t[H\t\H]t]H^t^H_t_]'d^RI`HataHbtbHctc^RIdHete^RIfHgtg.ROth]P!]j4tk]l]l]m]m3,R 3,tn!R!R]4to!R"R#]]mR$3,4tp] !R%R%R&7!R'R44tq] !R%R%R&7!R(R)44tr] !R%R%R&7!R*R44ts] !R+R44tt] !R,R44tuR-RR.RR/R0R1RR2RR3RR4R0R5RR6R/ R7R8lltvRR-RR.RR9RR:RR5RR;R%Rllltw] R?R@l4tx^ ty^tzRARBlt{RCRDlt|RERFlt}RGRHlt~RIRJltRKRLltRMRNltR-RR3RRORRPRQ/RRRSlltRTRUltRVRWlt] !R%R%R&7!RXRY44t] !R%R%R&7!RZR[44tR\R]ltR^R_ltR`RaltRbRcltRdReltRRfRglltRRhRilltRjRkltRlRmltRnRoltRpRqltRrRsltRtRultRvRwltRxRyltRzR{ltR|R}ltR~RltRRRlltRRltRRltRRltRRltRRltRRlt] !R%R%R&7!RR44t] !R%R%R&7!RR44tRRltRRltRRltRRltRRlt!RR]4tRRRR/RRlltRRltRRltRRltRRltR#)aResolve a project's dependencies for the environments it targets. One engine serves every project. ``[tool.nab.matrix]`` declares many environments and a bare project declares none (the host is the target), but either way :func:`~nab_python.config.plan_targets` hands back a list of :class:`~nab_python.target.ResolveTarget` and each one gets a single-environment resolve against a shared :class:`~nab_python.fetch.FetchCoordinator`, so metadata is fetched once across them. A declared conflict is the one place a resolve can produce more than one result for an environment, and it turns on what the selection reaches, not on how many environments the project targets. Directly co-selecting two members of an exclusive set *forks*: each member gets its own resolve and its pins carry a membership clause, so one lock serves both selections. A selection that reaches two members only transitively (an umbrella extra or group) has no fork to carry the second, so it is *refused*. Both hold whether or not a matrix is declared. ) annotationsN) defaultdict)contextmanagersuppress) dataclassfieldreplace)Path) TYPE_CHECKINGAny NamedTupleProtocol)ARCHIVE_BUCKET VCS_BUCKET)ResolutionError)ResolverResolverObserver)IncompatibilityIncompatibilityCauseRootRequirement)dependency_marker_holdsmembership_set_in_marker) admit_vcs_url)Marker) VersionRange) Requirementcanonicalize_name) ConfigError ConflictFork ConflictKindConflictSelectionError ConflictSetNabProjectConfigconfigured_group_namesconflict_forksindex_cache_floors_from_configindex_routes_from_config plan_targetsread_pyproject_configvalidate_conflict_exclusionsvalidate_conflict_minimumswith_python_override)FetchCoordinator) LockInput TargetLockbuild_target_lock)ListingFilterCacheProviderResolutionStrategy join_extra split_extra) expand_extra_requirementsexpand_group_includesexpand_self_extrasraise_for_unsatisfiableread_pyproject_build_requiresread_pyproject_dependenciesread_pyproject_groupsread_pyproject_name$read_pyproject_optional_dependenciesresolve_groups_to_requirementsself_extra_markers)UNBOUNDABLE_MARKER_VARIABLESNonIntervalMarkerError ResolveTargetenvironment_declarationmarker_variablesmicro_boundary_pointsslices_from_points)IteratorMappingSequence)AsyncHttpTransport)VersionInstallContexts ProgressSink ResolveFork ResolveResult TargetResult.c2]tRt^~tRtRRltRRltRtR#)rNaWhat the engine reports resolve progress to; the CLI implements it. ``on_fetch`` fires once per package listing fetched (from the fetcher thread); ``on_pin`` reports the current count of decided packages (from the resolving thread). Both are best-effort display hooks. cV^8dQhRR/#returnNone)formats"]/home/user/billing-ledger-validation/.venv/lib/python3.14/site-packages/nab_python/resolve.py __annotate__ProgressSink.__annotate__s@@$@c R#)z1Record that one package listing has been fetched.NrXselfs&rZon_fetchProgressSink.on_fetchr]c V^8dQhRRRR/#)rUdecidedintrVrWrX)rYs"rZr[r\sEEcEdEr]c R#)z6Record the current count of decided (pinned) packages.NrX)r`res&&rZon_pinProgressSink.on_pinrcr]rXN)__name__ __module__ __qualname____firstlineno____doc__rarh__static_attributes__rXr]rZrNrN~s@EEr]c>]tRt^tRtRRltRRltRRltRtR #) _ResolveObserveraLog resolver decisions at DEBUG and drive an optional progress sink. A decision level is the count of packages currently decided, so it is the live pinned gauge; a backjump lowers it, keeping the count honest under backtracking. Logging is unconditional (the log level gates it, so ``-vv`` surfaces the pin trace); ``sink`` is present only while a progress line is being rendered. c V^8dQhRRRR/#)rUsinkProgressSink | NonerVrWrX)rYs"rZr[_ResolveObserver.__annotate__s0Tr]c WnR#N_sink)r`rss&&rZ__init___ResolveObserver.__init__s r]c(V^8dQhRRRRRRRR/#) rUpackagestrversionrLlevelrfrVrWrX)rYs"rZr[rus(%%3%%%%r]c \PRW4VPeVPPV4R#R#)z pinned %s %sN_loggerdebugryrh)r`r}rrs&&&&rZ on_decision_ResolveObserver.on_decisions1 ng7 :: ! JJ  e $ "r]c$V^8dQhRRRRRR/#)rU from_levelrfto_levelrVrWrX)rYs"rZr[rus!((c(S(T(r]c \PRW4VPeVPPV4R#R#)zbackjumped from level %d to %dNr)r`rrs&&&rZ on_backjump_ResolveObserver.on_backjumps2 6 M :: ! JJ  h ' "r]rxN) rjrkrlrmrnrzrrrorXr]rZrqrqs% ((r]rqrLT)frozenslotscT]tRt^t$RtR tR]R&]!]R7t R]R&Rt R]R &R t R #) rMaA fork's requirements, split back into the contexts PEP 751 installs. ``project`` is the project's own dependencies, and ``selectors`` holds one requirement list per active extra and group, keyed by its ``(kind, name)`` member. The lock writer walks the resolved graph from each of them, so each package is gated on the contexts that reach it (see :attr:`~nab_python.lockfile.TargetLock.package_gates`) and a default install leaves out what only a selection brings. The fork's own ``selection`` is one of those selectors, so a package it shares with another active selection names both members and installs for either. ``project`` is the project's own dependencies *as this fork resolved them*, empty in a fork a declared conflict excluded them from. ``name_project`` is set when ``[tool.nab].base-group`` names the project's own dependencies. It is a lock-wide fact rather than a per-fork one: the name has to mean the same thing in every lock it appears in, so the roots are walked even with nothing selected. tuple[Requirement, ...]projectdefault_factoryz1Mapping[tuple[str, str], tuple[Requirement, ...]] selectorsFbool name_projectrXN) rjrkrlrmrnr__annotations__rdictrrrorXr]rZrMrMs6,(*G $)CHDI@L$r]c0]tRt^t$RtR]R&R]R&RtR#)_ConfiguredContextzAn install context ``[tool.nab]`` configures rather than a run selects. ``name`` is ``None`` for the project's own dependencies when no ``base-group`` names them. Unnamed they cannot be a conflict member, so every fork carries them. str | Nonenamer requirementsrXNrjrkrlrmrnrrorXr]rZrrs ))r]rc>]tRt^t$RtR]R&R]R&RtR]R&R tR#) rOaA conflict fork's resolver input: a selection and its requirements. ``selection`` is the conflicting members active in this fork, empty for an unforked resolve; ``requirements`` are the requirements folded for it: the configured contexts this fork carries plus the groups and extras the selection activates. Each fork runs against every target, with its ``selection`` stamped onto each so the pins land under a distinct label and a membership-gated marker. ``contexts`` is that same requirement list split into the install contexts the lock has to distinguish; ``None`` for a caller that resolves a bare requirement list and has no project to split it into, which leaves every package unconditional. ztuple[tuple[str, str], ...] selectionrrNInstallContexts | NonecontextsrX)rjrkrlrmrnrrrorXr]rZrOrOs  +*))'+H$+r]c]tRt^t$RtR]R&R]R&]!]R7tR]R&R t R ]R &] !4t R ]R &R t R]R&^t R]R&^tR]R&^tR]R&^tR]R&^tR]R&^tR]R&RtR]R&RtR #)rQa,One target's resolve: its pins, or why it has none. ``lock`` is what this target contributes to the lockfile, and is present exactly when the resolve succeeded. ``consulted`` is every marker the resolve read (root, constraint, and dependency), which is what the lock declares its environment from. rCtargetrsuccessrdict[str, Version]pinsNzResolutionError | Noneerrorfrozenset[Marker] consultedzTargetLock | Nonelockrf decisionsrounds conflicts backjumpsmetadata_fetcheddistributions_seengfloat wall_timerX)rjrkrlrmrnrrrrr frozensetrrrrrrrrrrorXr]rZrQrQs  M$T:D :$(E !(#,;I ."D "IsFCOIsIscIur]c]tRtRt$RtR]R&]!]R7tR]R&]!]R7t R]R&]!] R7t R ]R &] R R l4t ] R Rl4tRRltRRltRtR#)rPaThe finished resolve: one :class:`TargetResult` per target per fork. ``base_results`` and ``env_base_names`` are populated only when conflict forks ran: they record what a no-member resolve of each environment produced, which is how the lock writer tells a base dependency from one that only a member requires. A failed base pass leaves ``env_base_names`` incomplete, so it counts against :attr:`success`. ztuple[ResolveTarget, ...]targetsrlist[TargetResult]target_results base_resultsz"dict[EnvSignature, frozenset[str]]env_base_namescV^8dQhRR/#)rUrVrrX)rYs"rZr[ResolveResult.__annotate__s;;;r]c \;QJd&RVP4F 'dK R# R#!RVP44#)z4Whether every target, and every base pass, resolved.c38"TFqPxK R#5irw)r).0trs& rZ (ResolveResult.success..s:(9"::(9FT)all every_resultr_s&rZrResolveResult.successs9s:(9(9:ss:s:s:(9(9:::r]cV^8dQhRR/#)rUrVztuple[TargetResult, ...]rX)rYs"rZr[rs::6:r]c 8.VPOVPO5#)z3Every per-target resolve, the base passes included.)rrr_s&rZrResolveResult.every_results :$$9t'8'899r]cV^8dQhRR/#rTrX)rYs"rZr[rs4r]c `VPFpVPfKVPh R#)zRe-raise the first target's :class:`ResolutionError`, if any. For a caller with no per-target reporting of its own (a build-env resolve, say), a failed target is just a failed resolve. N)rr)r`rs& rZraise_for_failureResolveResult.raise_for_failures' ##Bxx#hh$r]cV^8dQhRR/#)rUrVz dict[str, list[tuple[str, str]]]rX)rYs"rZr[r%s  = r]c 6\\4pVPFppVP'gKVPP 4F;wr4W,P \V4VPP34K= Kr \V4#)zCollapse the per-target pins into ``{package: [(version, label)]}``. The labels are target ids, not PEP 508 markers; the lockfile writer is what turns them into markers. ) rlistrrritemsappendr~rlabelr)r`outrr}rs& rZ merged_pinsResolveResult.merged_pins%so 8C47H%%B:::$&GGMMO  ##S\299??$CD%4& Cyr]rXN)rjrkrlrmrnrrrrrrrpropertyrrrrrorXr]rZrPrPst'&).t)DN&D',T'BL$B9>t9TN6T ;;::  r]config cache_dirofflineFpython_versiongroupsextrasbuild_requirementsresolution_strategyprogresscHV^8dQhRRRRRRRRR R R R R RRRRR RRRRRR/ #)rUpathr transportrKrNabProjectConfig | Noner Path | Nonerrrrr Sequence[str]rrrResolutionStrategy | NonerrtrVrPrX)rYs"rZr[r[4sc c c !c  $ c  c  c c  c  c c 3c "c c r]c Vf \V4pV'd)V'g V'dRp \V 4h\V4p\W%4p\ V4p V'd \ V4ML\ \V4\V4\V4\V4VPe \V4M.R7p \WbPVP4p\!VV VV \#V4VR7wpp\%T\'VP(4TT\+V4\-V4V e V P.MRR7;_uu_4p\1VV VVVVV V R7uuRRR4# +'giR#;i)ayResolve the project at ``path`` for every environment it targets. ``config`` defaults to :func:`read_pyproject_config(path)`. The caller supplies ``transport`` so the HTTP library choice stays outside nab-python. ``cache_dir`` and ``offline`` are runtime overrides from the CLI; ``python_version`` applies :func:`~nab_python.config.with_python_override`, moving the resolve target onto that Python and leaving the rest of the environment alone. ``groups`` and ``extras`` name PEP 735 groups and ``[project.optional-dependencies]`` keys to fold in; ``resolution_strategy`` overrides ``config.resolution`` when set. ``build_requirements`` resolves ``[build-system].requires`` instead of the project's dependencies, for a lock of the environment the project is built in rather than the one it runs in. Neither ``groups`` nor ``extras`` mean anything there, so passing either raises. A target that cannot be resolved is a failed :class:`TargetResult`, not an exception, so a matrix reports every target that failed rather than only the first. Everything else (an unreadable pyproject, a conflicting selection, an unsupported source) raises. Nz>a build-requirements resolve has no groups or extras to select) dependenciesroptional project_namebuild_requires)rr)indexesrr index_routesindex_cache_floorsra)rrforksbase_requirementsrr)r) ValueErrorconfig_for_build_requirementsr,r(_tables_for_build_requires_ProjectTablesr;r<r>r= build_groupr:active_group_namesdefault_groups base_group _plan_forkstupler-rrr'r&raresolve_with_coordinator)rrrrrrrrrrrmsgrtableseffective_groupsrr coordinators&&$$$$$$$$$ rZresolve_for_targetsr4sdL~&t, VRCS/ !.v6 !& 9F6"G  #4( 4T:(.9$?,T2%%1.d3   (*%%v'8'8 + V}  E  V^^$-f59&A&.&:""   '  / 3      s E  E1 rralign_across_targets preferencescHV^8dQhRRRRRRRRR R R R R RRRRRRRRRRR/ #)rUrr-rSequence[ResolveTarget]rSequence[Requirement]rrrrrzSequence[ResolveFork] | NonerSequence[Requirement] | NonerrrrrMapping[str, Version] | NonerrtrVrPrX)rYs"rZr[r[s> > !> $> (> $ >  >  (> 4> 3> > .> "> > r]c VeTM \4p \WK4;_uu_4p \TT T TVeTM V PV R7p Ve \ V4M\ R\ V44.pV PUu.uFp\V4NK pp\\ V4VVV V V4uuRRR4#uupi +'giR#;i)aResolve ``targets`` against an already-open coordinator. Splitting this from :func:`resolve_for_targets` lets a caller (and every test) drive the engine from requirements it holds, reusing one coordinator across resolves and skipping the pyproject read. With ``forks`` every target is resolved once per fork, each fork's ``selection`` stamped onto the target; without them the resolve runs once per target against ``requirements``. ``align_across_targets`` threads each target's pins forward as preferences for the next, so a package the matrix does not force apart keeps one version across targets. ``preferences`` seeds that, e.g. from a previous lock. ``base_requirements`` are the no-member requirements (the project deps plus any non-conflicting selection). When given, a final base pass resolves them per target so the lock writer can tell a true base dependency from one required by every member; pass it only when conflict forks ran. N)rr source_rootalign resolutionrrX) r# _source_root_EngineSettingsr rrOr constraintsr_resolve_with_micro_narrowing)rrrrrrrrrrr effectiver settings fork_listtextrs&&&$$$$$$$$ rZrrsF!,2B2DI i + +{"##&'2$))  !,DK;r5CV3W2X 6?5J5JK5JT{4(5J K, M       ' , +"L# , + +sAB79B2 B72B77 C c$V^8dQhRRRRRR/#)rUrrrr#rVzIterator[Path | None]rX)rYs"rZr[r[s$$4r]c#"Vf%VP'gVP'gVxR#\P!RRR7;_uu_4p\ V4xRRR4R# +'giR#;i5i)zYield the directory a declared VCS or archive source materialises under. With caching off there is no cache root, but the source still has to be materialised to read its version and dependencies, so the run gets a temporary directory instead. Nz nab-sources-T)prefixignore_cleanup_errors) vcs_sourcesarchive_sourcestempfileTemporaryDirectoryr )rrscratchs&& rZrrsdV%7%7%76;Q;Q;Q  $ $T   7m    s'A=A=&A=A) A=) A: 4 A=c4V^8dQhRRRRRRRRR R R R R R/#rUrrrSequence[ResolveFork]rrrrrr rrrVrPrX)rYs"rZr[r[sN66 $6$6'6 6 . 6 4 66r]c |\WW#WE4pVUu.uFp.NK ppTp \\4Fjp\WV 4p V fV u#T p\ WRR7U U u0uFwrV 'gK\ V 4kK p p p \ VVVVVVVV4p\WW4p Kl R\ R2p\V4huupiuup p i)a>Resolve ``targets``, then split any minor a marker cut and re-resolve. A consulted marker can cut a minor's micro line (``python_full_version < "3.10.2"``). Resolving the minor once at its synthesized ``.0`` declares the whole minor by how ``.0`` read the clause, excluding the real interpreters on the other side. Resolving one target per micro slice instead lets each slice declare its own environment row and pins. The split points come from the markers a resolve consulted, so a boundary reachable only above an earlier split is not visible until that slice has been resolved. The loop is a fixpoint: it re-splits and re-resolves until a pass reveals no new boundary. Only a minor that split is re-resolved; every target no marker cut (host targets among them, since they name a real micro) keeps its first-pass result. Tstrictz9environment micro-boundary splitting did not converge in z passes) _resolve_passesrange_MAX_MICRO_SPLIT_PASSES_grow_micro_pointszip env_signature_resolve_slices_merge_micro_resultsr)rrrrrrresult_pointscombinedgrownr target_points split_sigs slice_resultrs&&&&&& rZrrs0K;F07"7w!2wF"7H * +"7H= =O*-WT)J )J% "M& !)J  '          (R),, # $G - # 7#8 s B3 B8*B8c<V^8dQhRRRRRRRRR R R R R RRRRR/ #)rUrrr/Sequence[Sequence[Version]]rr!rrrrrr rr first_passrPrVrX)rYs"rZr[r[4sm@@ $@ '@%@' @  @ . @4@@@r]c v\WRR7UU u.uFwrV 'd \W4M.NK p pp \T;'g/4p .p \V4EFwrVPV \ V4,V ^,\ V4,p\WRR7FwppV'g\ V V.VPR7p K)VUu.uF2pVP'dVPVP4MTNK4 pp\VVPVVV VP4pV PV4\ V VVPR7p K EK V UUu.uFpVFpVNK K ppp\TYcYE;'g/4wpp\\!V4V VVR7#uup piuupiuuppi)aUResolve every split target's slices, one pass per fork. A fork's pass walks the whole matrix in order: a split target has its slices resolved, and an unsplit target folds its first-pass pins in where it sits rather than resolving a second time. Alignment therefore threads through the slices in matrix order, as it does in the first pass. Tr#r rrrr)r)rGr enumeraterlen_threaded_preferencesr rwith_selection _run_passrrextend _base_passrPr)rr/rrrrrr7rr2sliced accumulatedresultsindexfork fork_first target_slices first_resultt fork_slices pass_resultsgroup all_slicesrrs&&&&&&&& rZr+r+4s&&)%F%F !F6C61J%F  {((b)K"$G + .. CL EAIW#= ,/v$+O 'M< 3,x~~ '&A59NNN  0I& %!! L NN< (/\K+,P ,>"(7A!!J7#-%H>O>OR$ L. j!!%  U($8s F* F0#!F0!F5c(V^8dQhRRRRRRRR/#) rUrrr/r6r-rPrVzlist[list[Version]] | NonerX)rYs"rZr[r[ws0&& $& '& & &r]c\\4pVPF>pV\VP4;;,\VP 4,uu&K@ .pRp\ WRR7Fwrx\V4p \Wx4F@p VP\V 4\44p V P\W{44KB \V 4p V \V48wdRpVPV 4K V'dV#R#)aDReturn ``points`` grown by the boundaries ``result`` consulted, or None. None means no minor gained a split point: the fixpoint has settled. Each target's boundaries are gathered from every slice it currently has, so a boundary a marker consults only above an earlier split is picked up once that slice has been resolved. FTr#N)rsetrr*rrr)rGgetupdaterFsortedrr) rr/r-consulted_by_sigrr1changedrr2foundrBrordereds &&& rZr(r(ws9DC8H!!ryy12c",,6GG2""$EG!$WT!BM"(?F(,,]6-BCEJI LL.vA B@- d=) )G W"C5%%r]c ,V^8dQhRRRRRRRRRR/#) rUrrr-rPr4r3zset[EnvSignature]rVrX)rYs"rZr[r[s: $  "   r]c aRV3RllpVPP4UUu/uFwrVVS9gKWVbK pppVPVP4\;QJd.V3RlV4FNK 5M!V3RlV44p\ .VOVP O5V!VP 4\VP 4,V!VP4\VP4,VR7#uuppi)aFold ``slice_result`` back over the first-pass ``result``. A target that split is dropped from ``result`` (its ``.0`` entry and its base pass) and its slices are taken from ``slice_result`` instead; every unsplit target keeps its first-pass entry, so it is never resolved again. c V^8dQhRRRR/#)rUrDSequence[TargetResult]rVrrX)rYs"rZr[*_merge_micro_results..__annotate__s TT,T1CTr]cj<VUu.uF!p\VP4S9gKVNK# up#uupirw)r*r)rDrr3s& rZkept"_merge_micro_results..kepts-$SWr bii(@ (RWSSSs00c3L<"TFp\V4S9gKVxK R#5irw)r*)rrJr3s& rZr'_merge_micro_results..sMw!-*:**LAAws$ $r:) rrrSrrPrrrr) rr-r4r3r_signamesrunsplits &&&f rZr,r,sTT !//5577JC j   7 ,556eMwMeeMwMMG 1'1L001F112T,:U:U5VV&--.l6O6O1PP%  s DDc4V^8dQhRRRRRRRRR R R R R R/#r rX)rYs"rZr[r[sN(( $($('( ( . ( 4 ((r]c \T;'g/4p.pVFpVU u.uF1qP'dV PVP4MT NK3 p p \V VPVVVVP 4p VP V 4\WkVPR7pK \YY#T;'g/4wr\\V4VV V R7#uup i)zResolve every fork against every target, plus the base pass. The fork loop threads each target's pins forward across the whole run; the base pass, when given, records the no-member pins per environment. r9r:) rrr>r?rrr@r=r rArPr)rrrrrrrCrDrFrJ fork_targetsrLrrs&&&&&& rZr%r%s{((b)K"$GOV OV!A  T^^ ,A Ew  !        MM   |$+ X^^ "$.K;;L;L"$ L g!%  ' s7Cc 0V^8dQhRRRRRRRRR R R R /#) rUrrrrrrrrrMapping[str, Version]rVz=tuple[list[TargetResult], dict[EnvSignature, frozenset[str]]]rX)rYs"rZr[r[sE # # $ #3 #' # # ' # C #r]cPVf./3#\\V4WW44p/pVF~pVP'd5\RVP44V\ VP 4&KI\PRVP PVP4K WV3#)zResolve the no-member requirements per target, if there are any. The pass names the deps that install regardless of which member is chosen, so the writer keeps the membership clause on a dep required only by members. c38"TFp\V4xK R#5irwrrrs& rZr_base_pass..sA4;D!$''Grz)Base attribution skipped for tuple %s: %s) r?rrrrr*rrwarningrr)rrrrrrDrrs&&&&& rZrArAs 2v  W (xG:.s-"D  !24!8J!F "s( ()rrfromkeys)rrrpolicys&&f rZrrsPU"UU"F 11&12 33r]dependency_groups created_bynabc 0V^8dQhRRRRRRRRRR R R /#) rUr-rPrrrrrwrxr~rVr.rX)rYs"rZr[r[sF55 5 $5  5 % 5  55r]cdVeTM \4p/p/p.pVPFp V PfKV PWiPP&\ V P4p W9d(\ 4Wz&VPV P4Wz;;,V P,uu&K \V\VP4\W4VPV\V4\V4VPVP VP"VP$R7 #)aAssemble the lock input from a finished resolve. Every target that resolved contributes its pins, its forward dependency edges, and the environment it declares (see :func:`_declared_environments`). A target that failed contributes nothing, so callers that want the whole matrix represented check ``result.success`` first. ``extras`` and ``dependency_groups`` are this run's selection, which the lock records at the top level; ``default-groups``, the declared conflicts, and ``base-group`` are project policy and come from ``config``. ) rr environmentsrequires_pythonrxrrwrrrr)r#rrrrr*rQrrr.rr_declared_environmentsr}rrrrr) r-rrrwrxrrr declaringr signatures &$$$$ rZbuild_lock_inputrs*!,2B2DI%'G13I%'I## 77? #%77  "")),  %#&5I   RYY ' ,$ F112+IA!11V} 12 //%%''))  r]c V^8dQhRRRR/#)rUrrCrV EnvSignaturerX)rYs"rZr[r[Ps44-4L4r]cZ\\VPP444#)z2Return ``target``'s environment as a hashable key.)rrT marker_envr)rs&rZr*r*Ps! ))//12 33r]c$V^8dQhRRRRRR/#)rUrrrz"Mapping[EnvSignature, set[Marker]]rVz list[Marker]rX)rYs"rZr[r[Us&66&6166r]c t\4pVP4F'pVFpV\\V44,pK K) \ V\ ,4pV'd&\ PRRPV44VFrpVPR8XdK\4pV\V4,FpV\\V44,pK RV9gK]\ PR4M VUu.uF'p\\Wa\V4,44NK) up#uupi)aBuild the lock's PEP 751 ``environments``, one per environment. The pins hold for the environments the resolve targeted, so the lock says so: every dependency whose marker was False on a target was dropped there, and an installer that answers one of those markers differently needs a different package set. Each declaration is built from the markers that target's resolve actually read (see :func:`~nab_python.target.environment_declaration`). A marker on an axis the lock cannot bound (see :data:`~nab_python.target.UNBOUNDABLE_MARKER_VARIABLES`) is reported: the lock stays open on it, so an installer whose kernel differs will still accept the lock, with the dep that marker gated missing. A marker on ``implementation_version`` under a non-CPython target is reported the same way (see :func:`~nab_python.target.unboundable_variables`): the value there is synthetic, so the lock leaves the axis open. zA marker in this resolve consults %s, which names the resolving machine's kernel build; the lockfile cannot declare it, so an installer whose value differs will still accept this lock and miss the dependencies that marker gates., cpythonimplementation_versiona2A marker in this resolve consults implementation_version on a non-CPython target; the value nab uses there is the Python level, not the interpreter's release, so the lockfile leaves that axis open and an installer whose value differs will still accept this lock and miss the dependencies that marker gates.) rQvaluesrEr~rTrArrojoinimplementationr*rrD)rr variablesmarkersmarker unboundablerconsulted_namess&& rZr~r~Us*%I##%F )#f+6 6I&%AABK 8 IIk "    I - $'E f 566F /F < >r]rc`]tRtRt$RtR]R&R]R&R]R&R ]R &]!]R 7tR]R &R t R#)riz0The pyproject tables a resolve reads, read once.list[Requirement]r/Mapping[str, Sequence[str | Mapping[str, str]]]rMapping[str, Sequence[str]]rrrrrrXN) rjrkrlrmrnrrrrrorXr]rZrrs2:## ;;))(-d(CN%C:r]rc$V^8dQhRRRRRR/#)rUrr#rrrVz9tuple[_ConfiguredContext, tuple[_ConfiguredContext, ...]]rX)rYs"rZr[r[s$ &4>r]c\VP\VP44pVPe+\VP\VP 443MRpW#3#)zSplit the configured install contexts into the project's and the rest. The project's own dependencies are always a context, named or not. The build requirements are one only when ``build-group`` names them, which is also the only time they were read. rX)rrrrrr)rrrrs&& rZ_configured_contextsrsb!!2!2E&:M:M4NOG    ) F..f6K6K0L MO   r]c(V^8dQhRRRRRRRR/#) rUrFrrrrSequence[_ConfiguredContext]rVz>tuple[tuple[Requirement, ...], tuple[_ConfiguredContext, ...]]rX)rYs"rZr[r[s1      , D r]ca\;QJd.V3RlV4FNK 5M!V3RlV44pVPeVPSP9dVPV3#RV3#)zReturn the configured contexts ``fork`` resolves, project first. An unnamed context cannot be a conflict member, so every fork carries it; a named one is carried only by the fork that chose it. c3`<"TF#qPSP9gKVxK% R#5irw)ractive_configured)rcrFs& rZr_carried_by..s"My!FFd6L6L,LAAys. .rX)rrrr)rFrrcarriedsf&& rZ _carried_byrsYeMyMeeMyMMG||w||t/E/EE##W,, w;r]c V^8dQhRRRR/#)rUrr rVrrX)rYs"rZr[r[s  T n r]c2\\V4//RR7#)zRead ``path`` as a project whose dependencies are its build requirements. ``[build-system].requires`` is one flat list, so the group and extra tables are empty, and the project name with them: it is read only to expand self-referencing extras. N)rrrr)rr:)rs&rZrrs" 248  r]c V^8dQhRRRR/#)rUrr#rVrX)rYs"rZr[r[s*:?Or]c"\VRRRRR7#)a:Return ``config`` with the settings a build-requirements lock cannot use. ``default-groups`` and the conflicts declared over groups and extras describe a selection ``[build-system].requires`` does not have, and ``base-group`` names the project's own dependencies, which a build lock holds none of. Left in they fail the run rather than narrow it: :func:`_tables_for_build_requires` supplies no group or extra table for them to resolve against. ``build-group`` goes too: a lock whose roots already are the build requirements has no second context to gate them behind. N)rrrrrX)r)rs&rZrrs    r]c(V^8dQhRRRRRRRR/#)rUrCrrDr\r rrVrX)rYs"rZr[r[s0  #  #     r]cV'gV#VF2pVP'gKVPVP4K4 V#)zBFold a pass's pins into the preferences the next pass starts from.)rrSr)rCrDr rs&&$ rZr=r=s:  :::   rww ' r]c4V^8dQhRRRRRRRRRR R R R R /#)rUrrrrrrrrrjrrrVrrX)rYs"rZr[r[sN $''  '  % r]c .p\V4pVF9p\WW#Wu4p VPV 4\Wy.VPR7pK; V#)aWResolve every target in ``targets`` once, in order. With alignment on, each target's pins are threaded forward as preferences for the next, so the pins stay aligned across targets wherever the environments admit it. ``contexts`` splits ``requirements`` into the install contexts the lock gates its packages on; see :class:`InstallContexts`. r9)r_resolve_one_targetrr=r ) rrrrrrrDrCrrs &&&&&& rZr?r?sU"#%G{#K +  r+KX^^T  Nr]c4V^8dQhRRRRRRRRRR R R R R /#)rUrrCrrrrrrrjrrrVrQrX)rYs"rZr[r["sWnn n'n'n n ' n % nnr]cVPpVPp\VVVVPR7wrp \VVVRVPR7Pp \Y4TPp \TP3/RTbRT bR T bR T bR TPbR TPbR TPbRTPbRTPbRTP bRTP"bR\%TP&4;'gRbR\%TP(4;'gRbRT eT \*, MRbR\%TP,4;'gRbRT eT \., MRbRTbRTP0bRTP2bR\5RT 44bR\7T4bRTP8bp\;TP<4p\?TT\@RTPBR7p\DPGR TPH4\JPL!4pTPOYR!7pTPQ4UUu/uFwpp\ST4^,eKTTbK! ppp\UYT4\JPL!4T, p\DP[R%\]T4TPHTTP^P`TP^Pb4\eYW4wpp\ R+RTR"R&R'TR(\gYT4R)\iTTTTPPjTTTR*7R$T/\YTT4B# \ dp \ TRT R7uRp ? #Rp ? ii;iuuppi \ dMp \WY4\ R+RTR"RR#T R$\JPL!4T, /\YTT4BuRp ? #Rp ? ii;i),z2Run one single-environment resolve for ``target``.) environmentwarned constraint)rkindrF)rrrNrroot_requirementsr root_extrasuploaded_prior_to dist_policy build_policypackage_overridesindex_overridestrust_unverified_sdist_deps vcs_config local_sourcesr vcs_cache_dirrarchive_cache_dir build_configdecision_orderrdirect_packagesc3R"TFp\V4^,eKVxK R#5i)N)r5rms& rZr&_resolve_one_target..Xs"" 2Tk$6G6JDD2s' 'rr0)observer range_type root_version format_rangez resolving %s)rrrrzHresolved %d packages for %s in %.2fs (%d distributions seen, %d fetched)Trrr)r resolved_keys base_rootsselector_rootsrX)6rr_build_resolver_inputsrrangesrrQ_extend_constraints_to_proxiesr r2rrrrrrrvcsrrrrrrrr rrrrqrrrrrrrtime monotonicresolverr5_raise_for_source_python_augment_resolution_error _target_statsinfor<statsrr_install_context_roots_consulted_markersr0r)rrrrrrrrrresolver_requirementsrresolver_constraintsexcr providerrresolverstartrawkvrelapsedrrs&&&&&& rZrr"s*__F##KE@V  #// A =+ 6  #//  & ##7E&&K0)    !22 &&((!22..%+$F$F::6//088D++,443>2IkJ.t V334<<!$-8,CK. (%()*,,+,%//-."" 2"  /4%56&::7H:  1 12H'/** (H MM.&,,/ NN E  0S!$JA Aq0A1J 48nn&G LLR D  ))'' "8!NJ     %X[I      ((00!)    ( + K E65DDE`K  !#0    nn&.  Hh/    sUAM &%M9 M3)M30M9 M0 M+%M0+M03M99 OAO O Oc$V^8dQhRRRRRR/#)rUrrrMapping[str, str]rVzJtuple[frozenset[str] | None, dict[tuple[str, str], frozenset[str]] | None]rX)rYs"rZr[r[s$$3DOr]c Ve%VP'gVP'gR#\VPV4VPP 4UUu/uFwr#V\W14bK upp3#uuppi)ahReturn the lock writer's install-context roots for one target. ``(None, None)`` when nothing needs attributing, which leaves every package unconditional: no selection to name, and no name for the project's own dependencies either. A requirement whose marker this target's environment fails is dropped, exactly as the resolve dropped it, so it gates nothing. )NN)rr _root_keysrr)rrmemberrs&& rZrrs~ 2 2 2h6K6K6K8##[1)1(:(:(@(@(B (B$ J|9 9(B   sA9c$V^8dQhRRRRRR/#)rUrrrrrVzfrozenset[str]rX)rYs"rZr[r[s$'6Gr]c@a\4pVFpVPe\VPV4'gK/\\ VP 44oVP S4VPV3RlVP44K \V4#)aReturn the resolver keys ``requirements`` names directly. The same shape :func:`_build_resolver_inputs` feeds the resolver: a canonical name per requirement, plus a ``name[extra]`` proxy key per requested extra, with marker-excluded requirements dropped. c3<<"TFp\SV4xK R#5irw)r4)rextrars& rZr_root_keys..sDJtU++s) rQrrr~rraddrSrr)rrkeysreqrs&& @rZrrs|UD :: !*A JJ + +  $SXX./  DDD T?r]c(V^8dQhRRRRRRRR/#)rUrr2rrrrVrrX)rYs"rZr[r[s0   ' '   r]c\VP4p\P!W4F.pVPfKVP VP4K0 \ V4#)zEvery PEP 508 marker this resolve read. The provider records the markers it read off the dependency graph; the root requirements and constraints are collected here, since their markers are evaluated before the provider exists. )rQconsulted_markers itertoolschainrrr)rrrrrs&&& rZrrsNH../I|9 :: ! MM#** %: Y r]c$V^8dQhRRRRRR/#)rUrzResolver[str, Version]rr2rVzdict[str, int]rX)rYs"rZr[r[s$  $ 08  r]c RVPPRVPPRVPPRVPPRVPP RVPP /#)zFReturn the resolver and provider counters for a :class:`TargetResult`.rrrrrr)rrrrrrr)rrs&&rZrrsh (..''X^^--X^^--X^^--HNN;;hnn??  r]c4V^8dQhRRRRRRRRR R R R R R /#)rUrr rrrr#rrrrqrrVz2tuple[list[ResolveFork], list[Requirement] | None]rX)rYs"rZr[r[sW\$\$ \$ \$ \$% \$  \$ \$8\$r]cN\V4p\W!4wrxVP'd^\VPVPVP V4\ VPVV.\VP V4OVOV4\WEVPV4p .p \4p V EF0p VP'd=\VPVV P.V POV PO5V4\V P4^8dXV PV 9dGV PV P4\!\#VP V PV4V4\%WV4wrV P'\)V P*\-\/WWVR74\1V \3WWR7VP4RJR7R74EK3 Rp\V 4^8d1\7V ^,4p\%VWx4wpp\/WVVVR7pW3#)a|Plan the resolves a selection needs, and the base pass they need. An engaged conflict forks whether or not a matrix is declared: one resolve per choice of member, each carrying its own requirements, with the member stamped onto the selection so its pins land under a membership-gated marker. The exclusion check below still refuses a selection that reaches two members of a set without directly selecting either (an umbrella extra or group), since a fork can only carry a directly-selected member. The second element is the no-member requirement list, needed only when the plan actually forked; see :func:`resolve_with_coordinator`. )rr)rN)rrr)rrr)r$rr _validate_conflict_members_existrr_check_conflict_minimumsr7r%rQ_check_conflict_exclusions active_extras active_groupsrr<r_check_group_disjointness_group_requirements_by_grouprrrOrr_fork_requirementsrM_selector_requirementsr _base_fork)rrrrrr configuredproject_contextselector_contextsplanrscanned_group_selectionsrFrrr base_fork base_project base_carrieds&&&&$$ rZrrs,(/J)=f)M&O (   foov}}j  !      H#FMM6: HZ H    &&*:*:J GD!E69U     &  "">$$$>t'='=>   "" #a '""*BB $ ( ();); < %,V]]DOP .."&dw )#4d"(!2!2$!>   +T 4y1}tAw' %0 & " l/ )\\   ##r]c ,V^8dQhRRRRRRRRR R /#) rUrr rrrFrrrrVz.dict[tuple[str, str], tuple[Requirement, ...]]rX)rYs"rZr[r[=s:"" " " " + " 4 "r]c/pVF6pVPV\PPVP3&K8 VP FIp\P P\\V443p\\W.V44WG&KK VPFTp\PP\\V443p\\VPV.V44WG&KV V#)aESplit a fork's active extras and groups into one requirement list each. The lock writer walks the resolved graph from each of them to gate the packages only that extra or group reaches. A member of the fork's own ``selection`` is a selector like any other: a package it shares with another active selection has to name both, or the lock carries only the other one's clause and an install that selects the member alone misses the package. A group named in ``default-groups`` is here like any other: PEP 751 seeds ``dependency_groups`` from ``default-groups`` when the installer selects none, so the gate still holds for a default install. A configured context is a selector no run selects, and only a fork that carries it gets one: a fork that did not resolve the build requirements must not claim an install context it never walked. )rr GROUPvaluerrEXTRAr~rr_extra_requirementsr_group_requirementsr) rrrFrrcontextrrrMs &&&$ rZrr=s2ACI>E>R>R <%%++W\\:;##$$**C0A%0H,IJ!"5fgt"LM $##$$**C0A%0H,IJ!"5fmmeWd"ST $ r]c 0V^8dQhRRRRRRRRR R R R /#) rUrr rrrFrrrrrrVrrX)rYs"rZr[r[bsD    #  , r]c\V4pVFpVPVP4K VP\VPVP V44VP\ WPV44V#)alFold one fork's contexts, groups and extras into one requirement list. Each fork resolves a different slice of the selection (one member per engaged conflict set), so its requirement list is built separately rather than shared. ``project`` and ``selectors`` are the configured contexts this fork carries, empty where a declared conflict put one in another fork. )rr@rrrrrr)rrrFrrrrs&&&$$ rZrrbso =LG001+FMM4;M;MtTU+F4F4FMN r]c V^8dQhRRRR/#)rU referencerrVrX)rYs"rZr[r[zs,<r]ca\VP4o\;QJd!.V3RlVP4FNK 5M!V3RlVP44p\;QJd!.V3RlVP4FNK 5M!V3RlVP44p\;QJd!.V3RlVP 4FNK 5M!V3RlVP 44p\ RVVVR7#)a%Return the no-member fork: a reference fork minus its chosen members. Every fork shares the same non-conflicting base selection, so any fork's active sets with its own chosen members removed recover that base. Resolving it names the deps that install regardless of which member is selected. c3n<"TF*p\PPV3S9gK&VxK, R#5irw)r rr)rechosens& rZr_base_fork..3(A    $ $a ( 6 (#5 5c3n<"TF*p\PPV3S9gK&VxK, R#5irwr rrrgrs& rZrr r!r"c3n<"TF*p\PPV3S9gK&VxK, R#5irwr$r%s& rZrr s3,A    $ $a ( 6 ,r")rrrrrX)rQrrrrrr)r rest_extras rest_groupsrest_configuredrs& @rZrrzs$$ %F%((%%((K %((%%((K e,,ee,,O !!)  r]c(V^8dQhRRRRRRRR/#) rUrrselectedrrr rVrrX)rYs"rZr[r[s0<< ;<< < ?%d+?,=C,=D$,=CLG! "**F$*KK<3E3E$EL= "3.10.4"`` answers for the whole minor by how that floor reads it, and a member reached only above the boundary is never seen. One slice per boundary reads the closure where each answer holds. )r@rrrG_tileable_points)rr@rrrrBs&&& rZ_conflict_check_targetsrCs]!&2E2EWG F(1A&1RSF S   s'Ac$V^8dQhRRRRRR/#)rUrrCrzSequence[Marker]rVz list[Version]rX)rYs"rZr[r[s"  ] 5E - r]c \4pVF>p\\4;_uu_4VP\ W.44RRR4K@ \ V4# +'giK^;i)afReturn the boundaries the tileable ``markers`` cut ``target``'s minor at. The self-extra closure is walked without an environment, so it carries markers from branches this target never reaches; one of those that cannot tile the minor is skipped rather than raised on. A marker a resolve does consult still raises, in :func:`_resolve_with_micro_narrowing`. N)rQrrBrSrFrT)rrr/rs&& rZrBrBsU5F , - - MM/A B. - &>. - -s A A+ c 0V^8dQhRRRRRRRRRR R R /#) rUrr5rrr@rrplannedrrVrWrX)rYs"rZr[r[sLCC$C C#C! C % C  Cr]c\WV4pVF;p\VPVPW&P4p\ WV4K= R# \ dp\YT4ThRp?ii;i)aRun the require-one minimums check per target, marker-aware. A member reached only through a marker-gated self reference is active only on the targets whose environment satisfies that marker, so the check expands the self-extra closure against each environment the ``planned`` targets cover (see :func:`_conflict_check_targets`). An environment on which no member is active fails the policy even when another one satisfies it. N)rCr8rrrr+r!_named_for_target) rrr@rrGrrrrs &&&&& rZrrsn &fwGG* OOV00/CTCT  C &y O  & C#C9s B Cs A A- A((A-c 0V^8dQhRRRRRRRRRR R R /#) rUrr5rrrrrrGrrVrWrX)rYs"rZr[r[,sLCC$C C!C! C % C  Cr]c \VPV4p\WV4pVF;p\VPVP W'P 4p\WV4K= R# \dp \YT4T hRp ? ii;i)aRun the at-most-one exclusion check per target, marker-aware. A self reference reaches its extra only where its marker holds, so the self-extra closure is expanded against each environment the ``planned`` targets cover (see :func:`_conflict_check_targets`). Members reached under disjoint markers never share an environment and pass; two that co-activate on one fail. This runs once per fork, where each fork holds at most one member of an engaged set, so it only catches co-selection an umbrella extra or group reaches transitively: a member not directly selected cannot be assigned to a fork, so ``conflict_forks`` leaves it in the shared base where two of them meet. Directly co-selecting two members forks instead of raising here. N) r7rrCr8rrrr*r!rI) rrrrrGexpanded_groupsrrexpanded_extrasrs &&&&& rZrr,s~,,FMM=IO%fWEG, OOV00-ARAR  C (_ U  & C#C9s B Cs A&& B1 A>>Bc(V^8dQhRRRRRRRR/#)rUrr!rrCrrrVrX)rYs"rZr[r[Ns6CC C C%C Cr]c\\V4^8XdV#\V RVP R24#)z>Name the offending tuple, when there is more than one to name.z (tuple ))r<r!r)rrrs&&&rZrIrINs1  7|q !SE&,,q"A BBr]c$V^8dQhRRRRRR/#)rUrrrrrVz4tuple[dict[str, VersionRange], dict[str, list[str]]]rX)rYs"rZr[r[Ys$#2C9r]c/p\\4pVFpVPe\VPV4'gK/VPeK?\ \ VP44pVPV\P!44pVP'dVPP4M\P!RR7pWg,W%&W5,P\ V44K W#3#)aFold one group's direct requirements into per-package ranges. Mirrors :func:`_build_resolver_inputs` (marker filtering, canonicalisation, intersection); URL requirements are skipped. Also returns the requirement strings per package, for the conflict message. Fadmit_arbitrary)rrrrurlr~rrrRrfull specifierto_ranger)rrrsourcesrrpreviousterms&& rZ_group_package_rangesr\Ys')F$/$5G :: !*A JJ + +   77  $SXX./ ::dL$5$5$78}}} MM " " $""59    SX&'( ?r]c:]tRtRt$RtR]R&R]R&R]R&RtR#) _SelfEmptyGroupi{z?One group whose own requirements on a package leave no version.r~rMr}reqsrXNrrXr]rZr^r^{sI J L Ir]r^cN]tRtRt$RtR]R&R]R&R]R&R]R&R]R&R tR #) _GroupConflictiz~One direct group-vs-group conflict on a single package. Group names are stored sorted so the conflict has a stable identity. r~ left_group right_groupr}left_req right_reqrXNrrXr]rZraras# O LMNr]rac$V^8dQhRRRRRR/#)rU per_groupMapping[str, list[Requirement]]rrrVzlist[_SelfEmptyGroup]rX)rYs"rZr[r[s&."r]caaa.p\V4F?o\VS,V4wooVPVVV3Rl\S444KA V#)zwReturn the groups whose own requirements on a package leave no version. The result is sorted by ``(group, package)``. c 3<"TFDpSV,P'gK\SVRPSV,4R7xKF R#5i)r)rMr}r_N)is_emptyr^r)rr}rMrrYs& rZr*_find_self_empty_groups..sL *g''  OYYww/0   *s A,A)rTr\r@)rgr self_emptyrMrrYs&& @@@rZ_find_self_empty_groupsrnsW)+J "/ %0@+N "&>   # r]c$V^8dQhRRRRRR/#)rUrgrhrrrVzlist[_GroupConflict]rX)rYs"rZr[r[s&//./"//r]c j\\4p\V4Fcp\W,V4wrEVP 4F8wrgVP 'dKW&,P W7WV,34K: Ke .pVP 4Fwri\P!V ^4FhwrV wrpV wpppV V,P 'gK+VP \V VVRPV4RPV4R74Kj K VPRR7V#)aReturn the direct group-vs-group conflicts under ``environment``. Only direct conflicts are caught; one that emerges through a shared transitive dependency falls through to the resolver. A group that already leaves no version on a package is left out of the pairing, since no other group can be the cause; it is reported by name from :func:`_find_self_empty_groups` instead. The result is sorted by ``(left_group, right_group, package)``. r)rbrcr}rdrecHVPVPVP3#rwrbrcr}rs&rZ'_find_group_conflicts..s!,, qyy!Ir]key) rrrTr\rrkrr combinationsrarsort)rgr requirersrMrrYr} package_ranger group_rangesleftrightrb left_range left_sourcesrc right_range right_sourcess&& rZ_find_group_conflictsrs" D "/ 0@+N&,lln "G%%%   % %uW=M&N O'5#')I!*!2$11,BKD37 0JL6; 3Km[(222  "#-$/ '!%.s177AII2Fr]rvzDependency group z! has conflicting requirements on r..cHVPVPVP3#rwrrrss&rZrtrsq||Q]]AII>r]zDependency groups z and z conflict on z: group z requires z but group z; )rrQrnrrrrrTrrrMr}r_rbrcrdrerr) rgrrmaffectedremptyconflictclauseswheres && rZrrs3>c2BJ/:3/?H,Y8I8IJE   ! !&,, /K-i9J9JKH   " "6<< 0L hG (FGZ.8 /  r%**Q 8 H >X/9 !4!4 78$$'}X5E5E4HP)),Jx7H7H6IJ$$'z(2D2D1EQ H  $))G, --r]c$V^8dQhRRRRRR/#)rUrrrrrVrWrX)rYs"rZr[r[s!;Tr]c\VP4pRV9d\V4'gR#\V4pW19dR#VPV4\P RV4R#)aWarn when a dropped root requirement tests an extra/group membership. A root marker testing ``extra``, ``extras``, or ``dependency_groups`` evaluates False at resolve time (root activates no extra or group), so the dep would otherwise be dropped silently. ``warned`` carries the requirements already reported in this run, so one mistaken requirement is reported once rather than once per target per fork. zextra ==NzRoot requirement %r tests an extra or dependency-group membership marker; the dep is dropped because root activates no extra or group at resolve time. For an extra, use pkg[extra] (extras-of-package).)r~rrrrro)rr marker_textrs&& rZ_warn_dropped_root_markerrs[cjj/K$-Ek-R-R s8D ~ JJt OO M r]c:]tRtRt$RtR]R&R]R&R]R&R tR #) _ResolverInputsi'zFWhat one set of root requirements gives the resolver and the provider.z(list[RootRequirement[str, VersionRange]]rootsdict[str, VersionRange]rset[tuple[str, str]]rrXNrrXr]rZrr'sP 33 ##  r]rr requirementrc 0V^8dQhRRRRRRRRR R R R /#) rUrrrr#rrrr~rzset[str] | NonerVrrX)rYs"rZr[r[/sTKFKF'KF KF# KF  KF  KFKFr]c .p/p\4pVf \4MTpVEFp VR8Xd#V P'dRV 2p \V 4hV Pe*\ V PV4'g\ W4KdV P eK\V P VP4RV RV P RV P 2p \V 4h\\V P44p VPV \P!44p V P 'dV P P#4M\P!RR7p W,Wk&VP%\'W\V 444\)V P4F{p\+W4pW9dA\P!RR7pVWo&VP%\'VV\V 444\-V4wppVfQhVP/V V34K} EK VR8XdS\1\24pVF/pVVP4,P%VP64K1 \9VVVR7\;WVV4#) aCConvert PEP 508 requirements to the resolver's input shape. Requirements whose PEP 508 marker evaluates to ``False`` under ``environment`` are skipped, matching pip/uv's root-requirement handling. A direct-URL or VCS requirement is refused by :func:`admit_vcs_url`; resolving one is not implemented. Each surviving requirement becomes its own :class:`~nab_resolver.types.RootRequirement`, tagged with the string the user wrote, so a failure names the requirements rather than their intersection. ``ranges`` folds the same requirements per package for the provider, which asks about one package at a time. ``kind`` is ``"requirement"`` or ``"constraint"``. A constraint may not carry extras, and the returned extras set is empty for one. Constraints do not become root clauses, so an empty constraint intersection is still caught here by :func:`raise_for_unsatisfiable` rather than by the solver. ``warned`` is the run's set of already-reported extra/group root markers (see :func:`_warn_dropped_root_marker`); a caller that does not share one gets a fresh set, so it warns per call. rz Constraints cannot have extras: zVCS z: admitted by policy but resolver path is not implemented: z @ FrS)r)rQrrrrrrUrrrNotImplementedErrorr~rrRrrVrWrXrrrTr4r5rrrr}originr9r)rrrrrrrralready_warnedrrrrZr[r extra_keyproxyr.normalized_extrarYroots&&$$$ rZrr/s/<79E57(+K$nSU&N < CJJJ4SE:Cc" " :: !*A JJ + +  &c :  77  #''6:: .tf!!$ #cggY8 &c* *$SXX./(,,T<3D3D3FG}}} MM " " $""59 '/o# _TS:;CJJ'E"4/I5$))%@38%0 _Ys3xHI"-i"8 A#/ // OOT#34 5(3H |/:4/@D DLL ! ( ( 5 5wTJ 5 EEr]c$V^8dQhRRRRRR/#)rUrrrrrVrWrX)rYs"rZr[r[}s&>>(>%> >r]cdVF)wr#VPV4pVfKW@\W#4&K+ R#)azCopy each base package's constraint onto its extras proxies. The resolver keys constraints by the package it is deciding, and an extras proxy decides under its own ``name[extra]`` key, so the base's constraint does not otherwise reach it. Sharing the key also keeps the proxy on the constraint-attribution path, so a constraint that leaves it nothing is named in the failure. N)rRr4)rrrrrs&& rZrr}s1#  __T*  !3= 4/ 0#r]c(V^8dQhRRRRRRRR/#) rUrr2rrCrrjrVrWrX)rYs"rZr[r[s0''' ' ' 'r]c VPP4VPP4,VPP4,pV'gR#VP 4FwrE\ V4pWc9dKVP We3,PpVfK<VPV4'dKUV RV RV RVP RVP 2 p\V4h R#)a-Reject a local, VCS, or archive pin whose Requires-Python excludes ``target``. Index candidates are filtered by Requires-Python while listing and again from their fetched metadata; local, VCS, and archive sources skip both, so a source that rejects the resolve target could otherwise reach the lock. N z requires Python z but the z resolve targets Python ) rrrrrrmetadata_cacher}admits_requires_pythonrpython_full_versionr) rrrmanagedrr normalizedspecrs &&& rZrrs ##%    # # % &  " " ' ' ) *  &t,  $ && '<=MM  F$A$A$$G$G,ay(9$@LL>!9&:T:T9UW "#& &&r]c$V^8dQhRRRRRR/#)rUrrrr2rVrWrX)rYs"rZr[r[s!  ? h 4 r]cVPfR#.p\4p\VP4F-pWC9dK VPV4VP V4K/ .pVF0pVP V4pVfKVP V RV 24K2 V'gR#\ V4pVR,RPV4,pV3VnR#)abAppend per-package no-versions diagnostics to ``exc`` in-place. Walks the derivation tree carried on the exception, collects every package a rejection clause names (see :func:`_walk_no_versions_packages`), and looks up the provider-side reason for each. When at least one reason is available, rewrites the exception's args so that ``str(exc)`` surfaces the diagnostics alongside the original derivation tree. Best-effort: reasons are keyed by package name and outlive the ask that recorded them, so a package whose earlier ask found no version keeps its hint even when the tree names it over a later range. Nr.z Diagnostics: - z - ) incompatibilityrQ_walk_no_versions_packagesrrget_no_versions_reasonr~rargs) rrpackagesseenr}hintsreasonbase augmenteds && rZrrs "HUD-c.A.AB ?   C E009   LLG9Bvh/ 0  s8D//(--2FFI|CHr]c V^8dQhRRRR/#)rUrzIncompatibility[Any, Any]rVz list[str]rX)rYs"rZr[r[s--.--r]c.p\4pV.pV'EdVP4p\V4V9dK+VP\V44VP\ P JdJVPF8pVPp\V\4'gK'VPV4K: MVP\ PJd\VP4\8XdVP^,P4'dlVP^,P4'dEVP^,Pp\V\4'dVPV4VP eVPVP 4VP"fEKVPVP"4EKV#)aReturn the packages a no-versions diagnostic may name. NO_VERSIONS clauses name every package they carry. Look-ahead grouped clauses (DEPENDENCY cause, two positive terms) name their candidate: a widened union covering the whole listing conflicts by propagation, with no second ``choose_version`` ask to raise a NO_VERSIONS clause. The caller drops packages with no recorded reason. The walk is iterative: the tree gains a level per conflict, so a deeply backtracked resolve overflows the recursion limit. )rQpopidrcauser NO_VERSIONStermsr} isinstancer~r DEPENDENCYr<_GROUPED_CLAUSE_TERMS is_positive cause_right cause_left)rrseen_idsstacknoder[pkgs& rZrrsGCH.=->E %yy{ d8x   RX ::-99 9 llc3''JJsO# JJ.99 9DJJ#88 1 ))++ 1 ))++**Q-''C#s## 3    ' LL)) * ?? & LL ) Jr]) rMrNrOrPrQrrrrrrX)rXrw)rn __future__rrloggingrr collectionsr contextlibrr dataclassesrrrpathlibr typingr r r r nab_index.cacherrnab_resolver.errorsrnab_resolver.resolverrrnab_resolver.typesrrr_conflict_kindrr_vcs_admissionr_vendor.packaging.markersr_vendor.packaging.rangesr_vendor.packaging.requirementsr_vendor.packaging.utilsrrrrr r!r"r#r$r%r&r'r(r)r*r+r,fetchr-lockfiler.r/r0rr1r2r3r4r5requirements_filer6r7r8r9r:r;r<r=r>r?r@rrArBrCrDrErFrGcollections.abcrHrIrJnab_index.transportrK_vendor.packaging.versionrL__all__ getLoggerrjrrr~rrNrqrMrrOrQrPrrrr'rrr+r(r,r%rArrr*r~rrrrrrr=r?rrrrrrrrrrrrrrCrBrrrIr\r^rarnrrrrrrrrrrrXr]rZrsT(# #/11;;6/< N)-276"$>>    ;;62    H %U38_c)*  E8 E('Y7(0 $d#$< $d# * *$ * $d#,,$,*  0 00 0fc '+ c " c  c "&c c c  %c 6:c %)c L> '+ > " > +/> 7;> 6:> "&> 15> %)> > B26r@F&<>(V #F4,5'+5 5 (* 5  5p4 6r $d#??$?( $d# : :$ :$  * 8nb,* $ \$~"J0@<(UU,@* C6CDCD $d#$ $d#  $ ./d8*.Z0!j!KF  KF # KF\>$'> F-r]