+ 2ja0t$Rt^RIHt^RIt^RIHtHt^RIH t H t ^RI H t ^RI Ht^RIHt^RIHtHtHt^RIt^R IHt^R IHtHt^R IHt^R IHtHtH t H!t!^R I"H#t#H$t$H%t%H&t&H't'H(t(H)t)^RI*H+t+^RI,H-t-^RI.H/t/^RI0H1t1H2t2^RI3H4t4^RI5H6t6^RI7H8t8^RI9H:t:]'d%^RI;Ht>^RI;H?t@^RIAHBtBHCtCHDtDHEtEHFtF^RIGHHtH.ROtIRtJR]KR&RtLR]KR &R!tMR]KR"&]N!4tOR ]KR#&] !R$R$R%7!R&R'44tP] !R$R$R%7!R(R)44tQ] !R$R$R%7!R*R+44tRR,R-ltSR.R/ltT!R0R]U4tV!R1R]U4tWR2R/R3R4lltXR5R/R6R7lltYR5R/R8R9lltZR:R;lt[R<R=lt\R>R?lt]R@RAlt^RRBR/RCRDlllt_RERFlt`RGRHltaRIRJltbRRKRLlltcRMRNltdRRORPllteRQRRltfRSRTltgRURVlthRWRXltiRYRZltjR[R\ltkR]R^ltlR_R`ltmRaRbltnRcRdltoReRfltpRgRhltqRiRjltrRkRlltsRmRnlttRoRpltuRqRrltvRsRtltwRuRvltx]N!43RwRxlltyRyRzltzR{R|lt{R}R~lt|RRlt}RRlt~RRltRRltRRltRRltR#)alPEP 751 ``pylock.toml`` emission. Owns ``write_lock`` and ``build_pylock`` plus the :class:`LockInput` -> :class:`Pylock` shape conversion. The targets a resolve ran against collapse into one or more ``Package`` entries per name, with a marker attached when they disagree; the emit-time disjointness validation lives in :mod:`nab_python._lockfile.disjointness`. ) annotationsN)Counter defaultdict) dataclassreplace)reduce)product)Path) TYPE_CHECKINGAny TypeAlias)atomic_write_text) KIND_GROUPMARKER_VARIABLE_FOR_KINDMarker) DecisionStoreIntractableMarkerSet MarkerSetUnserializableMarkerSet)PackagePackageArchivePackageDirectory PackageSdist PackageVcs PackageWheelPylock) SpecifierSetcanonicalize_name)Version)conflict_exclusion_groupsconflict_member_groups)require_artifact_hashes)validate_marker_coverage)validate_marker_disjointness BASE_MEMBER)IterableMappingSequence)Set) LockInputPinShape SdistArtifact TargetLock WheelArtifact) ResolveTargetDivergentBaseDependencyErrorUnsoundSimplificationErrortuple[tuple[str, str], ...]r _EnvSignaturezfrozenset[tuple[str, str]]_Membersztuple[_EnvSignature, _Members]_ForkKey _NO_MEMBERST)frozenslotscX]tRt^Qt$RtR]R&R]R&R]R&R]R &R ]R &R ]R &RtR#) _ForkAxesaRThe declared conflict sets a lock's forks vary along. ``exclusion_groups`` are the ``(kind, name)`` member sets an install context may activate at most one member of, restricted to the members the resolve forked over (:func:`_forked_exclusion_groups`). ``forks`` indexes every target by its environment and its selection, which is how :func:`_project_fork` walks one set's members with the other sets held fixed. ``markers`` is each fork's unprojected selection marker, which does not vary by package, and ``gates`` each fork's :attr:`~nab_python.lockfile.TargetLock.package_gates` as sets. (tuple[AbstractSet[tuple[str, str]], ...]exclusion_groupszMapping[_ForkKey, str]forksMapping[str, TargetLock]targetsMapping[str, _EnvSignature]env_signatureszMapping[str, str]markersz"Mapping[tuple[str, str], _Members]gatesN__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__rFf/home/user/billing-ledger-validation/.venv/lib/python3.14/site-packages/nab_python/_lockfile/pylock.pyr<r<Qs- ?> !! %%//  --rOr<c0]tRt^gt$RtR]R&R]R&RtR#) _GatedMarkerzlThe environments one gate selects a package in. ``marker`` is ``None`` when the gate holds on all of them. Marker | Nonemarkerr4gaterFNrGrFrOrPrRrRgs  %%rOrRc0]tRt^rt$RtR]R&R]R&RtR#) _ProjectionzOne package's marker shape at one fork. ``dropped`` are the selection members whose clauses fall away, and ``gate`` is the membership gate that stands in for the fork's own once they do (:func:`_merged_fork_gate`). r6droppedrUrFNrGrFrOrPrWrWrs NrOrWc$V^8dQhRRRRRR/#)rAr@rCrBreturnzdict[_ForkKey, str]rF)formats"rP __annotate__r]s&   % /  rOcVP4UUu/uF-wr#W,\VPP43VbK/ upp#uuppi)zIndex every target by its environment and its selection. A conflict-forked environment holds one target per point of the cartesian product across the engaged sets, so this is the lookup that answers "which fork agrees with this one everywhere but here". )items frozensettarget selection)rArClabellocks&& rP _fork_indexresM#==? *KE   $++*?*? @A5H*  s3A c$V^8dQhRRRRRR/#)rZr>&Sequence[AbstractSet[tuple[str, str]]]rAr@r[r=rF)r\s"rPr]r]s&??<? %?.?rOca\RVP444o\;QJd.V3RlV4FNK 5#!V3RlV44#)a<Restrict each declared conflict set to the members a fork selects. A set forks only over the members the run selected, so a declared member the selection omits has no fork for :func:`_project_fork` to swap in and no place in the lock's ``extras`` or ``dependency-groups`` arrays for an install context to activate. c3\"TF"qPPFq"xK K$ R#5iN)rarb).0rdmembers& rP +_forked_exclusion_groups..s%+4++:O:O:O+s*,c34<"TF qS,xK R#5irjrF)rkgroupforkeds& rPrmrns>-=E-=s)r`valuestuple)r>rArqs&&@rP_forked_exclusion_groupsrtsI">>+F 5>-=>5>5>-=> >>rOc]tRt^tRtRtR#)r3zA simplified per-package marker disagrees with the original over the universe. Checked on the serialised and reparsed bytes at emission, so a mismatch is a bug in the algebra and emission refuses rather than ship a marker that would install differently. rFNrHrIrJrKrLrNrFrOrPr3r3srOc]tRt^tRtRtR#)r2aRAn environment's conflict forks disagree on a base dependency's pin. A base dependency present in every fork of an environment drops its membership clause so it installs even when no conflicting member is selected, which requires the forks to agree on one (version, source). When they diverge, every candidate entry keeps a membership clause, so nothing would fire in the no-member install context and the dependency would silently not install. Surface the divergence with the offending package and per-fork pins so the producer can reconcile the forks rather than commit an incomplete lock. rFNrvrFrOrPr2r2s rO output_pathc$V^8dQhRRRRRR/#)rZ lock_inputr,rxzstr | os.PathLike[str] | Noner[strrF)r\s"rPr]r]s(/ rOcVe\V4PMRp\WR7pVe\\V4V4V#)aSerialise ``lock_input`` to PEP 751 TOML text. Returns the TOML text. When ``output_path`` is provided, also writes it there; the caller chooses the path (PEP 751 does not mandate one). The write is staged and renamed into place, so a failed write leaves any existing file intact. Directory, wheel and sdist paths are written relative to ``output_path``'s parent so the lockfile stays portable between machines (PEP 751 records those paths relative to the lock file). With no ``output_path`` the current directory is the base. Nlock_dir)r parent render_lockr )rzrxr~texts&$ rP write_lockrs?",7+BtK ''H z 5D${+T2 KrOr~c$V^8dQhRRRRRR/#)rZrzr,r~ Path | Noner[r{rF)r\s"rPr]r]s! 1 1I 1K 13 1rOc\V4\WR7pVP4\P!\ VP 444#)aXSerialise ``lock_input`` to PEP 751 TOML text without writing a file. ``lock_dir`` is the directory the lock will live in; directory, wheel and sdist paths are emitted relative to it so the lock stays portable. Defaults to the current directory. Used by ``write_lock`` and by ``nab lock --locked`` to render the would-be lock for comparison. r})r# build_pylockvalidatetomli_wdumpsdictto_dict)rzr~pylocks&$ rPrrs;J' * 8F OO ==fnn./ 00rOc$V^8dQhRRRRRR/#)rZrzr,r~rr[rrF)r\s"rPr]r]s&DDYD[DFDrOc ^RIHp\V4pVeTM\P!4P 4p\ VP4p\V4p\4p\WWEV4pVP\R7\VVPVPVP V\#VP4R7\%VP&P)4Uu.uFqP*NK upVP,VR7VP.eRVP.P14/MRp \3\5V4\7VP,4;'gRVP8'd\;VP84MRVP'dA\6;QJd.RVP4FNK 5M!RVP44MR\=VP>VP@VPB4\=VPDVPD'g VP@MR4VPFVV R7 #uupi) aBuild a :class:`Pylock` from the input shape. The resolver-side data structures have already been simplified when this function runs. The remaining work is shape conversion: ``Pin`` -> ``Package``, plus marker attachment from the per-target map. ``lock_dir`` is the directory the lockfile will be written to; local-directory, wheel and sdist paths are emitted relative to it so the lockfile is portable. It defaults to the current working directory when the caller has no path in mind (e.g. stdout). ) LOCK_VERSIONNkey) environmentsextrasgroupsexclusive_groupsdeclared_groups)rstorenabc38"TFp\V4xK R#5irjr)rkes& rPrmbuild_pylock..sB0A1#A&&0A) lock_versionrrequires_pythonrdependency_groupsdefault_groups created_bypackagestool)$lockfiler_name_base_groupr cwdresolver! conflicts_emission_universer_build_packagessort_package_sort_keyr% marker_envsr active_groupsr"r$rArrrar provenanceto_blockrr rsrr _group_arrayr base_group build_grouprr) rzr~rbaser>universerpackage_recordsrdrs &$ rPrrs(!*-J ,H$((* E E GD01E1EF!*-H OE%*eO./ ++  '').z/C/CD !+!3!3!:!:!<=!<!<=,,  ,  %%..01  \*:223;;t))) 33 4    EB 0A0ABEEB 0A0AB B&  ( (  ! !  " " $  % %)3)B)B)BJ ! ! (( 1  >s+Ic V^8dQhRRRR/#)rZrzr,r[rF)r\s"rPr]r]$s000y0rOcaVPp\V3oVPP4UUUUu/uFwr#T\ TVP P4UUu/uFIwrEVf\ V9gKT\;QJd.V3RlV4FNK 5M!V3RlV44bKK uppR7bK ppppp\ WR7#uuppiuuppppi)a1Return ``lock_input`` with the base member named, or cut from every gate. The builder records :data:`~nab_python.lockfile.BASE_MEMBER` on every package the project's own dependencies reach. With ``base-group`` unset there is no name to give it, so those packages lose their gate and stay unconditional. c3B<"TFpV\8XdSMTxK R#5irjr&)rk gate_memberrls& rPrm#_name_base_group..2s$'+ *[8FkI'+s) package_gates)rA)rrrAr_rrr'rs)rznamercrdgatedrUrArls& @rPrr$s  D$ F&--335 6KE w  $(#5#5#;#;#=  $>KE#{$'> uu'+uu'+$>   6  : // s#+C C 8 C +C / C C c$V^8dQhRRRRRR/#)rZr Sequence[str] configuredz str | Noner[ztuple[str, ...] | NonerF)r\s"rPr]r]?s$   (2  rOc\PRV44pVF pVfK RV\\V44&K" \ V4;'gR#)a'Render one of the lock's group arrays, or ``None`` when it is empty. Every name is canonicalized here and deduplicated in order. Which arrays a ``configured`` name belongs in is the caller's decision: ``build-group`` joins ``dependency-groups`` alone, and ``base-group`` joins it too, since an installer that offers only those names would otherwise never reach it. ``base-group`` joins ``default-groups`` only when the project declares none of its own, because a declared ``default-groups`` replaces the default selection rather than extending it. c3J"TFp\\V44xK R#5irj)r{r)rkrps& rPrm_group_array..MsLVE#/677Vs!#N)rfromkeysr{rrs)rrnamesrs&* rPrr?sQ MMLVL LE  26E#'-. / <  4rOc$V^8dQhRRRRRR/#)rZrazstr | os.PathLike[str]r~r r[r{rF)r\s"rPr]r]Ts"  3 t  rOc\PPW4p\ V4P 4# \d\P!T4pL %+D\ 2\cVSM\ 22 2s A,rc ,V^8dQhRRRRRRRRR R /#) rZpinr-rTrSr~r rrr[rrF)r\s"rPr]r]{sAKK K K K . K  KrOc a^RIHpHpHpHp\ W4'Ed\ \VP4\VP4TTVP'd\VP4MRVPVP'd\VPSR7MR\ ;QJd0.V3Rl\#VP$\&R74FNK 5M)!V3Rl\#VP$\&R744;'gRR7#\ W4'dX\ \VP4RVV\)\+VP,S4VP.VP0R7R7#\ W4'dd\ \VP4RVV\3VP4VP6VP8VP0VP:R 7R 7#\ W4'dj\ \VP4\VP4VV\=VP>\AVPB4VP0R 7R 7#R V: 2p\EV4h)rZ ArchivePinIndexPinLocalPinVcsPinNr}c3><"TFp\VSR7xK R#5i)r}N)_wheel_to_package)rkwr~s& rPrm"_pin_to_package..s"@A"!h77@sr)rversionrTrrindexsdistwheels)reditable subdirectory)rrrTr directory)typeurl commit_idrrequested_revision)rrrTrvcs)rhashesr)rrrTrarchiveunknown pin shape: )#rrrrr isinstancerrrr rrrrr_sdist_to_packagersrr_wheel_sort_keyrrrrrrvcs_type bare_repo_urlrrrrrr TypeError) rrTr~rrrrrmsgs &&d$ rP_pin_to_packager{sBA#  "388,CKK(%585H5H5H S001d))CF999!#))h?RV5 @55 @!  $#  "388,%&%chh9 --  #"388,%\\%%-- --# #9   #"""388,CKK(%"GGCJJ' --   w 'C C.rOc$V^8dQhRRRRRR/#)rZwheelr0r~r r[rrF)r\s"rPr]r]s!],rOc VPem\VP\VPP 4V4VP \ \VP44VPR7#\VPVPVP \ \VP44VPR7#)aConvert a wheel artefact to its PEP 751 ``packages.wheels`` entry. A wheel from a local find-links directory carries its on-disk ``local_path``; it is written as a ``path`` relative to the lock file so the lockfile stays portable. A remote wheel records its ``url`` verbatim. rrsizer upload_timerrrrr) local_pathrfilenamerrrrrrrr)rr~s&$rPrrs #!%"2"2":":". s9DS,,..DsFT) rrfull from_markerallrrunionempty)rzmrows uninhabiteds& rPrrs  " " "~~.8.E.E F.EI ! !! $.ED Fc9D9ccc9D99 ~~ )//4): ;; G  sCC7C C,+C,c ,V^8dQhRRRRRRRRR R/#) rZrawrSwithinrrr{rDecisionStore | Noner[rF)r\s"rPr]r]s:'' ' ' ' '  'rOcVfR#\P!V4PWR7pVP4pVfRM \ V4pVf\P !4M\P!V4pVfRM \ V4p\WW4p T 'g"T RT: R\ T4: R2p \T 4hT# \\3dTu#i;i)aReturn ``raw`` in its shortest form equivalent over ``within``. ``None`` passes through, and a set full over the universe serialises back to ``None``. The simplified set is serialised, reparsed, and checked equivalent to ``raw`` over ``within``; a mismatch raises :class:`UnsoundSimplificationError`. Simplification is only a compaction, so every way the algebra can decline to answer ships ``raw`` instead: :class:`IntractableMarkerSet` when a decision overruns the cell budget or the marker nests past the stack, and :class:`UnserializableMarkerSet` when the simplified set has no marker spelling, which is what a marker selecting nothing inside ``within`` collapses to. N)rrz no markerz: emitted marker z is not equivalent to z over the declared environments) rrsimplifyto_marker_stringrrr{_sound_within_universerrr3) rrrr simplifiedrrebuiltemittedshownsoundrs &&&& rP_finalize_markerr&s( { **3/888T **,,$F4L 'INN Y5J5J75S  ' CL&sVC f%eY/C|: < )-- N !"9 : sBCCCc 0V^8dQhRRRRRRRRR R R R/#) rZrrSrrrr{memodict[str, Marker | None]rrr[rF)r\s"rPr]r]<sD    #     rOc\VfR#\V4pWS9d\WW$4W5&W5,#)z:func:`_finalize_marker` memoised for the span of one lock. ``within`` is fixed for a whole build, so two packages carrying the same raw marker have the same shortest form, and a universal lock repeats one platform or python gate across many packages. N)r{r&)rrrr(rrs&&&&& rP_finalize_cachedr+<s0 { c(C $S$> 9rOc ,V^8dQhRRRRRRRRRR /#) rZrrr#rrrrr[boolrF)r\s"rPr]r]QsA V V  V  V  V V  VrOcP\P!V4PWVR7#)aWhether ``emitted`` and ``raw`` agree on every environment in ``within``. ``emitted`` is what the lock ships: the reparsed marker bytes, or :meth:`MarkerSet.full` when no marker field is emitted. Decided per universe row, under the same budget as the operator it checks. )r)rrequivalent_within)rr#rrs&&&&rPr r Qs%   % 7 7u 7 UUrOc 0V^8dQhRRRRRRRRR R R R /#) rZrzr,r~r r>rgrrrrr[z list[Package]rF)r\s"rPr]r]`sLiiii=i i  i  irOc.pVPp\V4p\V4p\VP 44p \ WhWP 4p VP4U U u/uFwrV \V 4bK p p p /p\W&4p\T\Wh4TTVP4UUu/uFwppV\VPV4bK uppVP4UUUUu/uF8wppVPP4FwppVV3\V4bK K: uppppR7p\!VWV 4pV P4Fwwp p\#V W{,VVV V 4VFUwpp\%V VV V VV4p\'VW;W4pVP)\+\-V4VV\/V VV4R74KW Ky V#uup p iuuppiuuppppi)awCollapse the per-target pins into Package entries with markers. For each canonical package name: * Group targets by (version, source-shape). * Emit a Package per group; the marker is the OR of the matching targets' markers. When the group's targets cover every target the resolve ran against, the package is unconditional and the marker is omitted, which is every package of a lock with one target. * Within a group, the artefact sets (wheels and sdist) are unioned across the contributing targets so target-specific wheels (e.g. cp310-manylinux vs cp311-macos) survive. Each emitted marker is finalised to its shortest form equivalent over the declared environments (:func:`_finalize_marker`). A package carries the gate of every install context that reaches it, which with ``[tool.nab].base-group`` set includes the project's own dependencies. See :func:`_build_marker`. A conflict fork injects a membership clause into every target's marker, including the forks' base dependencies. A base dependency present in every fork of an environment must install regardless of which member is selected, so for that environment it contributes the membership-free env-only marker rather than the OR of the per-fork membership markers. A package is recognised as a base dependency through ``lock_input.env_base_names``: a dep required by every member but not by the base is absent from that set, so it keeps the membership clause and does not install when no member is selected. See :class:`LockInput.env_base_names` for the missing-signature contract. The base-name set is first closed under the emitted dependency edges (:func:`_close_base_names`) so a transitive dep the forks pull in through a base dep counts as base too. Forks of one environment that disagree on a base dependency's pin raise :class:`DivergentBaseDependencyError` instead of emitting a lock whose no-member context misses it. )r>r?rArCrDrE)r~r)rA_group_by_name_env_signatures_countrr_close_base_namesenv_base_namesr__group_pins_by_pinrtr<re_selection_markerrarr`_fork_projections_check_base_fork_agreement _build_marker_finalize_partsappendr_merge_pins_in_groupr)rzr~r>rroutrAby_namerCenv_fork_counts base_namescanonical_name per_target pin_groups shortened forked_groupsrcrdrrUaxes projectionsrpinsrpartsrTs&&&&& rPrr`sXC  GW%G$W-N^2245O"2K2KJ +2--/*9 &N *:66*9+-I,-=GM &'2% '}} . t $T[[-@ @. '}} . t"00668 d5M9T? *8 .  D $D*zRK","2"2"4"   #      #LD&! E%UHiWF JJ(.%!4^VW!U  ##5: Jk  s'G3#G.>Gc V^8dQhRRRR/#)rZrAr@r[zdict[str, dict[str, PinShape]]rF)r\s"rPr]r]s %#rOc\\4pVP4F<wr#VPP4FwrEWQ\ V4,V&K K> V#)zDPivot ``{label: TargetLock}`` to ``{canonical name: {label: pin}}``.)rrr_rJr)rAr?rcrdraw_namers& rPr2r2sQ2=T1BC}} !YY__.MH69!(+ ,U 3/' JrOc V^8dQhRRRR/#)rZrDzdict[str, PinShape]r[&list[tuple[list[PinShape], list[str]]]rF)r\s"rPr]r]s!!#!+!rOc/p\V4F^pW,p\V4pWA9d..3W&W,^,PV4W,^,PV4K` \VP 44#)zBucket targets by pin discriminator, keeping every pin. Walked in sorted label order so the output is independent of dict insertion order. )r_pin_discriminatorr=listrr)rDby_keyrcrrs& rPr7r7sv=?F # %  r(FK Ac" Ae$ $    rOc V^8dQhRRRR/#)rZrr-r[rsrF)r\s"rPr]r]sHrOcL^RIHpHpHpHp\ W4'dRVP VP3#\ W4'd:RVP VPVPVP;'gR3#\ W4'd:RVPVPVPVP;'gR3#\ W4'd:RVP VPVPVP;'gR3#RV: 2p\!V4h)zFReturn a hashable key that identifies the source + version of ``pin``.rrlocalrrr)rrrrrrrrrrrrrrepo_urlrrr)rrrrrrs& rPrRrRsAA#  cii00#    KK HH LL    " "   #  LL MM LL    " "   #""3;;S=M=M=S=SQSTT w 'C C.rOc V^8dQhRRRR/#)rZrJzlist[PinShape]r[r-rF)r\s"rPr]r] s**~*(*rOc ^RIHpV^,p\W!4'gV#/pVPp\ 4pRpVFp\Wq4'gQhVP FpVP VPV4K! VfVPe VPpVPfRpKuVPVP4K V'g%\V4^8Xd\\V44MRp V!VPVPVPV\!\#VP%4\&R74V R7#)aCombine pins sharing a discriminator into one with unioned artefacts. For :class:`IndexPin`, accumulates every distinct wheel filename across the contributing targets and keeps the first non-``None`` sdist. ``requires_python`` survives only when every target carried the same value and none was unconstrained, matching :func:`_common_requires_python`'s rule. Non-IndexPin shapes are already fully discriminated, so the first pin is returned unchanged. )rFNTr)rrrrrr)rrrrrr setdefaultrraddlennextiterrrrrsrrrr) rJrhead seen_wheelsrrequires_python_setany_unconstrainedrrrs & rPr>r> s"$ 7D d % % ,.K JJE$'E#((((ZZE  " "5>>5 9 =SYY2IIE    & $   # #C$7$7 8!S)<%=%B T% &'   YY jjVK..0oFG'  rOc ,V^8dQhRRRRRRRRR R /#) rZrAr@rC)Mapping[str, tuple[tuple[str, str], ...]]rA)Mapping[tuple[tuple[str, str], ...], int]r64Mapping[tuple[tuple[str, str], ...], frozenset[str]]r[z1dict[tuple[tuple[str, str], ...], frozenset[str]]rF)r\s"rPr]r]7s;&& %&=&?&I & 7 &rOcV'g \V4#\WV4p/pVP4FwrgVPV/4p\ V4p \ V4p V 'dTVPV P 4R4F-p W9gK V PV 4V PV 4K/ K[\V 4WV&K V#)aClose each env's base-name set under the emitted dependency edges. ``env_base_names`` records the names an independent base pass resolved, at that pass's versions, which emission discards in favour of the conflict-fork versions. When the forks pin a base dependency lower than the base pass did, its emitted transitive closure differs: a package the forks pull in through the base dep is missing from ``env_base_names`` and would keep its membership clause, so it drops out of the no-member install context even though the base dep that requires it installs there. Following the base (unconditional) edges present in every fork of the environment restores the closure, keeping the no-member context closed under the lock's own dependency graph. Preserves the missing-signature contract: only signatures present in ``env_base_names`` appear in the result, so an env with no base pass stays absent and its base status stays unknowable. rF) r_shared_fork_edgesr_rrrSpopr]r=r`) rArCrAr6sharedclosed signaturer adjacency reachablestackrs &&&& rPr5r57s. N##  IF@BF)//1 JJy"- I T  }}UYY["5'MM#&LL%6&i02 MrOc(V^8dQhRRRRRRRR/#) rZrAr@rCrfrArgr[z7dict[tuple[tuple[str, str], ...], dict[str, list[str]]]rF)r\s"rPr]r]`s0 %=?= rOc\\4pVP4FiwrEW1V,,pVPP4F7wrx\P V4Fp WgV 3;;,^, uu&K K9 Kk /p VP4F[wrW+,p \\ 4p VP4F'wwrypW8XgKW,PV 4K) WV &K] V #)aPer-env adjacency of the base edges present in every fork of the env. Walks ``base_dependencies`` (a package's unconditional edges), never the extra-folded ``dependencies``, so a dep a conflict member pulls in through an extra is not an edge here even when every fork activates that extra. A base edge only some forks carry (a base dep pinned to a version whose deps differ) is dropped too. Following these edges thus never promotes a member-only dep to base. )rrr_base_dependenciesrrrSr=)rArCrA edge_countsrcrdcountersourcerrrlrncountroseens&&& rPrjrj`s G}} U34 2288:LF}}T* $)$+;' GIF)//1 *1 %0 ? %0 I %0 %0rOcaa \\4p\S4F!pWcV,,PV4K# VP 4Fwr\ V 4WH,8dKWP V\449dK=\V 4o \V 3RlV44p WV,8dKlRPV3RlV 44p V RV R2p \V 4h R#)a~Reject a base dep whose forks within one env pin it differently. The env-only collapse in :func:`_build_marker` needs a single (version, source) group spanning every fork of the environment. Divergent pins split the forks across groups, so every entry would keep its membership clause and none would fire when no member is selected: the base dependency would silently not install. c3R<"TFwr\V3RlV44xK R#5i)c38<"TFqS9gK ^xK R#5i)NrF)rkrcin_envs& rPrm7_check_base_fork_agreement...s?|e|s N)sum)rk_ group_labelsrs& rPrm-_check_base_fork_agreement..s( #) ?|? ? ?#)$'z, c3R<"TFq RSV,P 2xK R#5i)z -> N)r)rkrcrDs& rPrmrs(XQWG4 5(9(A(A'BCQWrzN: the conflict forks of one environment pin this base dependency differently (zL); no lockfile entry would install it when no conflicting member is selectedN) rrSrr=r_r^rr`rmaxjoinr2)rrDrrCrAr6by_envrcrnrwidestr?rrs&f&&&& @rPr:r:s CNdBSF #e$%,,U3$#\\^ v;3 3  )))Y[A A V #)   Y/ /  XQWXXf((-w/A A +3//%,rOc4V^8dQhRRRRRRRRR R R R R R/#)rZrr{rrrArgr6rhrHr<rI%Mapping[tuple[str, str], _Projection]r[ztuple[_GatedMarker, ...]rF)r\s"rPr]r]sXoo o o?oI o  o 7 oorOc aVPp\\4pVF+pWtPV,,P V4K- VUu/uF%qWh,P P VR4bK' upo\\4p .p \V4\V48p VP4EFDwr\W W#4p\V Uu0uFp\Wh,SV,4kK up4^8Hp\V 4W,,8;'dTpWm^,,PpV'dKV'dC\V3RlV 44pV V,P \VP44KV'dI\V3RlV 44pV'd,V V,P \VP44V P!R\#WEW 444Rp EKG \$;QJd".RV P44FNK 5M!RV P444pV 'dV\'\)V 4R43, pV 'gV#\+V 4R08Xd\'RR43#\V 4^8Xd \'R\-\/V 4443#V#uupiuupi)a Return the marker selecting ``labels``, split by gate. For each environment the package appears in, the contribution is the membership-free env-only marker when the package is present in every fork of that env AND ``env_base_names`` lists it as a base dep there; otherwise the contribution is the OR of the per-fork membership-carrying markers. The result is the OR of those contributions, or ``None`` when the package covers every target AND every env collapsed to its env-only marker, which is every package of a single-target lock. A dep required by every member of an ``at-most-one`` set but not by the base is absent from ``env_base_names``, so it keeps the membership OR and does not install when no member is selected. An environment with no base-name set (no conflict fork ran) leaves the gate open. A membership contribution carries the fork's positive selection AND the negation of every co-member of the conflict sets it selects from (``"cpu" in extras and "gpu" not in extras``), so the forks are mutually exclusive in the marker itself: a PEP 751 consumer that never reads ``[tool.nab].conflicts`` still installs at most one fork. See :func:`_selection_marker`. The selection is projected per package first: a conflict set the package does not vary over contributes no clause, so with two sets engaged a dep reached through one of them names only that one and still installs for a selection that leaves the other set empty. See :func:`_fork_projections`. The projection makes several forks render the same contribution, which is emitted once. A package carries the gate of every install context that reaches it (see :attr:`~nab_python.lockfile.TargetLock.package_gates`), joined by ``and`` onto each contribution. A fork whose gate names its own selection needs no gate: its marker already asserts that member. An env collapses only when its forks agree on the rest of the gate, and the collapsed entry carries their union, so a package one fork reaches through its own member and another through a non-conflicting extra installs for either. When the package covers every target, every env collapsed, and every env gates it the same way, the env clauses are dropped and the gate stands alone: a selection is a property of the install context, not of the platform, so ``"cli" in extras`` is the whole marker. c36<"TFpSV,xK R#5irjrFrkrcrEs& rPrm _build_marker..!GJ5%,,Jc36<"TFpSV,xK R#5irjrFrs& rPrmrrrc38"TFp\V4xK R#5irjr)rkrs& rPrmrs P 4LLPrFc3P"TFwr\\V4V4xK R#5irj)rR _or_markers)rkrUrs& rPrmr s)"1 D [.55"1s$&NrF)rArrSrCr=rrr^r__is_base _shared_gatera _merge_gatesrenvironment_marker_string _common_gateextend_fork_contributionsrsrRrrr_r`)rrrAr6rHrIrArrcby_gateloose unconditionalrn env_labelsis_base agreed_gate collapsesramergedrlrKrEs&&&&&& @rPr;r;sXhllGBMdBSF""5)*11%8MS SF5GN0044T2> >F SE GRRVFWGEK3w</M!' 4OL TgneEl;T U    O'AAMMg !}%,, !!GJ!GGF FO " "6$*H*H#I J  !!GJ!GGF&&vd.L.L'MN  +DtP   7"0: E")--/EE")--/ E  ,{512688   7|tT2&(( 7|qT4W #6799 Lm TUs +K"K c ,V^8dQhRRRRRRRRR R /#) rZrHr<rIrrr{rrr[z list[str]rF)r\s"rPr]r]s: 6    rOc /pVFpVPV,PpWV3,pVP'gVPV,M\ W`P VP4p\ VP4VP, p RV\V\WP44&K \V4#)a7Render one environment's per-fork markers, projected and deduped. Each fork drops the clauses of the conflict sets the package does not vary over (:func:`_fork_projections`), which leaves the forks of a dropped set rendering the same text; the duplicates are folded into one contribution, in first-seen order. N) rArarXrDr8r>r`rb _with_gate _fork_gaterUrS) rHrIrrryrcra projectionrkepts &&&& rPrrsDe$++ u- %%% LL "6+@+@*BTBTU ))*Z-?-??DHZj? @A :rOc ,V^8dQhRRRRRRRRR R /#) rZrHr<rEz8Mapping[str, Sequence[tuple[list[PinShape], list[str]]]]rAMapping[_EnvSignature, int]r6&Mapping[_EnvSignature, frozenset[str]]r[z"dict[tuple[str, str], _Projection]rF)r\s"rPr]r]7s:33 3H313; 3 ( 3rOc>aa/p/pVP4FGwopVF;wrx\V4p \VV3RlV44p VFp WSV 3&WSV 3&K K= KI VU u/uF:q\SPV ^,,PP4bK< p p /p\ V4pV'dVFJwop \ SSV V SV 3,VSV 3,\SSPV ,W#4R7VSV 3&KL V P4UU Uu/uF)wwpp pVV 3V\SWVVV 3,4,bK+ pp ppVP4U Uu0uFwp pVW,8wgKV kK pp pTp KV#uup iuupp piuupp i)aReturn, per (package, fork), the selection clauses its marker can drop. Every fork starts free to drop its whole selection and :func:`_project_fork` keeps only what the fork space justifies. The dependency edges then narrow it: an entry that fires where one of its own dependencies does not is a lock that cannot be installed, so a package keeps every member its dependencies at that fork keep. The allowances only shrink, so the loop settles. c3<"TF;pSPV,PPSR4FpVxK K= R#5i)NrF)rArr)rkpeerrrHrs& rPrm$_fork_projections..KsA!"D<<-::>>tRHCH"sAA)r) r_r`rArarbr _project_forkrrC_dependency_drops)rHrErAr6same_pinedgesrrrrpdeclaredrcrlimitsrIstalerlimitnarrowedsf&&& ` rPr9r97s79H35E"((* fIAf%E !"!H  (-u%%-dEk"  +PX Xx9T\\#a&188BBCCxF X68K ME  KD%'4tU{#u% $--e4o (Ke $!)/  )7$ uu5M5k%e :LMN N(6  (0~~'7P'7e5FK;O'7P -Y Qs&AF !/F'F>Fc ,V^8dQhRRRRRRRRR R /#) rZrHr<rIrrcr{rAbstractSet[str]r[r6rF)r\s"rPr]r]ms: 6    rOc\VPV,PP4pVF1pVP WR34pYFe VP M\ ,pK3 V#)aReturn the members every dependency an entry declares drops at one fork. :func:`_dependency_entries` unions the edges over the entry's forks, so an edge only one fork has still rides on the whole entry; a fork that does not carry that dependency at all can drop nothing. )r`rArarbrrXr8)rHrIrcrrlrrs&&&& rPrrmsYt||E*11;; *$$KO MrOc4V^8dQhRRRRRRRRRR R R R R /#)rZrHr<rr{rcrr6rrrr-r[rWrF)r\s"rPr]r]sN=&=& =& =& =&  =&  =&=&=&rOc VPPW3\4p\VPV,P P 4pVPV,p\4p Tp .p VPFp W,V,p \V 4^8wdK$.V OV Np\P!V!pW, p\RV4!Uu.uFpVV\V4,3NK ppVUu.uF)pVVP9gKVPV,NK+ pp\V4\V48wgVPV4'gK\WVV4pVfKTp W,p Tp K V'g+V 'g#Wy, 'g\\4V4#\W4#uupiuupi)aUReturn the clauses one fork's entry for ``name`` can drop. A conflict set is irrelevant to a package when swapping the fork's member of that set for any other member, every other set held fixed, leaves the package at the same pin reached the same way. Conjoining such a set's clauses narrows the entry to the forks that vary something the package does not depend on, so a selection naming a member of one set alone matches no entry and the package silently does not install. Sets are folded in one at a time and each candidate is checked over the whole sub-cube of the sets folded in so far rather than one axis at a time. Two axes that are each flat through this fork can still meet at a fork with a different pin; dropping both would leave two entries of one package overlapping, and the forks have to stay mutually exclusive in the marker itself. c38"TFp\V4xK R#5irj)r)rkmemberss& rPrm _project_fork..s!Kg&//r)rErr8r`rArarbrCr>r^rrr? issuperset_merged_fork_gaterW)rHrrcrrrown_gaterbrnrXrUvaryingrprl candidateerasedheldswapkeysrpeersrs&&&&&$ rPrrs4zz~~tm[9H$,,u-44>>?I##E*I! G D24G&&"U* v;!  %g%u% ""I.! !K!KL Ly. /L  -1FDSC4::4ECDF u:T "(*=*=e*D*D "4uf= > +'4 4 (;(;9;11 w %%) GsF=:GGc ,V^8dQhRRRRRRRRR R /#) rZrHr<rr{rrrr6r[z_Members | NonerF)r\s"rPr]r]s:       rOc(aVUu/uF$qDVPPW3\4bK& pp\VP 4Uu0uFp\ V4kK up4^8wdR#WR^,,S, p\ V3RlVP 444pVP4FJwrFWgV\VPV,PP4,,8wgKIR# Wx,#uupiuupi)aReturn the gate the sub-cube's forks share, or ``None`` when they do not. Dropping a set replaces the fork's own gate with one that holds at every point of the sub-cube: the part naming nothing in the dropped sets, plus every dropped member that reaches the package in the forks that select it. The forks share such a gate only when each one's is exactly that, so a member that reaches the package under one fork of the other dropped sets but not another refuses the drop rather than guessing which way the projected entry should fire. Nc3D<"TFqS,Fq"xK K R#5irjrF)rkrUrlrs& rPrm$_merged_fork_gate..sV>4v f >s ) rErr8r^rrr-r`r_rrArarb) rHrrrrrErUresidualcarrieds &&&f rPrrs JO O4::>>4, < <E O  5<<> 2>4DJ> 23q81X'HV5<<>VVGkkm  wT\\$-?-F-F-P-P)QQR R$   P 3s *D  Dc ,V^8dQhRRRRRRRRR R /#) rZrr{rnr5rArr6rr[r-rF)r\s"rPr]r]s: 1;   rOcJVPV4pVf W!,^8H#W9#)aSay whether an environment's base pass reached ``name``. When no base pass ran for the env (the signature is missing), treat the dep as base only if no fork ran either; with forks but no base attribution, base status is unknowable and the safe answer is to keep the membership OR. )r)rrnrAr6rBs&&&& rPrrs1 ##I.J)Q..  rOc$V^8dQhRRRRRR/#)rZrdr/rUr4r[rF)r\s"rPr]r]s) A A  A7 A  ArOc\\\V4\VPP4, 44#)zReturn the part of a gate the fork's own selection does not supply. Two forks of one environment gate a package the same way when these agree; each fork's own member necessarily differs, and :func:`_merge_gates` folds it back in. )rsrrrarb)rdrUs&&rPrrs, D C (=(=$>>? @@rOc$V^8dQhRRRRRR/#)rZrAbstractSet[tuple[str, str]]rUr[r4rF)r\s"rPr]r]s$   & .J   rOcJW,'dR#\\V44#)aIReturn the gate to conjoin onto one fork's own membership marker. A gate that names a member the fork's marker still asserts is already satisfied there, so it drops whole rather than narrowing the fork's marker to the gate's other selections. A member whose clause the projection dropped asserts nothing, so it does not count. rF)rsr)rrUs&&rPrrs {{  rOc V^8dQhRRRR/#rZrE%Iterable[tuple[tuple[str, str], ...]]r[r4rF)r\s"rPr]r]s ' ' 0 '  'rOcRpVF$pVf \V4MV\V4,pK& \\T;'gR44#)zReturn the members every fork of one environment gates a package on. A gate is a disjunction, so a member every fork names implies every fork's gate: the package is reached under that member whichever fork the install context selects. NrFrrsr)rEcommonrUs& rPrrsA+/F$nT&3t92D  "% &&rOc V^8dQhRRRR/#rrF)r\s"rPr]r]s ! ! 0 !  !rOc\4pVF!pV'gRu#V\V4,pK# \\V44#)zOR the per-fork gates of one collapsing environment into one gate. A fork with an empty gate installs the package whenever its own member is selected, so the merged gate is empty too. rFr)rErrUs& rPrrs<$'5FI#d)   rOc(V^8dQhRRRRRRRR/#) rZrar1r>rgrXrr[r{rF)r\s"rPr]r]-s0## #<#*# #rOc\VP4\V4, p\4pVF"pWS,'gKWEV, ,pK$ VPp\V4F!wrx\V,p VRV RV 2, pK# \V4F!wrx\V,p VRV RV 2, pK# V#)aReturn the fork's per-package marker with its co-members negated. Conjoins ``'name' in `` for every member of the selection onto the target's environment marker, then ``'name' not in `` for every other member of every conflict set the selection draws from, so at most one fork installs. With no ``dropped`` members this is the target's :attr:`~nab_python.target.ResolveTarget.marker_string` plus the negations, and a selection drawing from no exclusion group is ``marker_string`` unchanged. ``dropped`` are the members of conflict sets the package does not vary over (:func:`_project_fork`); both their positive clause and their set's negations fall away, since a set nothing is kept from is no longer drawn from. z and "" in z " not in )rrbrrr) rar>rXselected co_membersrprTkindrvariables &&& rPr8r8-s*6##$s7|3H'*uJ!    (* *J" - -FX& +D1F4&hZ00'Z( +D1F4& (44) MrOc V^8dQhRRRR/#)rZrUSequence[tuple[str, str]]r[r{rF)r\s"rPr]r]Ss  0 S rOcDRPR\V444#)zRender a package's membership gate as a PEP 508 clause. Each ``(kind, name)`` member becomes ``'name' in extras`` or ``'name' in dependency_groups``; a package two selections reach disjoins them, since either one installs it.  or c3L"TFwrRV R\V, 2xK R#5i)"rN)r)rkrrs& rPrm_gate_clause..Zs)JVJD!D6/567,s"$)rr)rUs&rP _gate_clauserSs' ;;JPQU, rOc 0V^8dQhRRRRRRRRR R R R /#) rZrKzSequence[_GatedMarker]rrrr{r(r)rrr[rSrF)r\s"rPr]r]_sLQQ !QQ Q # Q  Q  QrOcv.pVFjp\VPWW44pVP'gVfR#VPV4KFVP\ WvP44Kl \ V4^8Xd#V^,P'g V^,#\\ V4WW44#)aNSimplify each gate's environments, then the marker they assemble into. Simplifying the whole marker in one pass walks a cell space the membership variables multiply. Each gate's environments carry no membership variable, so they shrink first, and the marker they assemble into is small by the time the second pass canonicalises it. N)r+rTrUr= _gated_markerr^r)rKrrr(r assembledpartr!s&&&&& rPr<r<_s!I%dkk84O yyy!   Z ( z99=> 5zQuQx}}}| K 2HD PPrOc$V^8dQhRRRRRR/#)rZrTrSrUrr[rrF)r\s"rPr]r]}s"33-3/H3V3rOcdVf\\V44#\\RV R2V44#)zConjoin a gate onto the simplified environments it selects in. With no environments the gate is the whole marker. Otherwise they are parenthesised, since they may disjoin and ``and`` binds tighter. ())rrr)rTrUs&&rPrr}s3 ~l4()) *q]D1 22rOc$V^8dQhRRRRRR/#)rZrTr{rUrr[rF)r\s"rPr]r]s"$$s$";$$rOcfV'gV#\V4p\V4^8dRV R2pV RV 2#)z>AND a package's membership gate onto the marker of one target.rrz and )rr^)rTrUclauses&& rPrrs=  $ F 4y1}VHAXU6( ##rOc V^8dQhRRRR/#)rZrAr@r[z&dict[str, tuple[tuple[str, str], ...]]rF)r\s"rPr]r]s   % + rOc VP4UUu/uF<wrV\\VPPP444bK> upp#uuppi)zMap each target label to a hashable signature of its environment. Two labels share an environment (they differ only by conflict-fork selection) when their marker environments are equal, so the sorted items form a stable, hashable key. )r_rsrra marker_env)rArcrds& rPr3r3sS#==? *KE uVDKK2288:;<<*  sAAc V^8dQhRRRR/#)rZ signaturesrr[z&dict[tuple[tuple[str, str], ...], int]rF)r\s"rPr]r]s5+rOc^\\4pVFpW;;,^, uu&K V#)z6Count how many forks each environment signature spans.)rint)rcountsrns& rPr4r4s,=Hr5rjr:r;rr9rrrrrrrrr8rr<rrr3r4rrr)rs@rPr&sU# ,*00.A. 87/F,.6;;2' 9 y82)26)6! X# $d#..$.* $d#&&$& $d#  $   ?" : 260 1$ 1D4DN06 * (3&K 15 KK\2,<4'T* ViX!&@*Z&RD%0Pod63l&=&@@& A  ' !&-6K#L Q<3$  &J rO