+ 2ja0t$Rt^RIHt^RIt^RIHtHtHtH t ^RI H t H t H t ^RIHt^RIHtHtHt^RIHt^RIHtHt^R IHt^R IHtHt^R IH t H!t!^R IH"t"H#t#H$t$H%t%]'d ^R I&H't'^RIH(t(.ROt)].]]*]+3,3,t,RRRRRRRRR/R RRRRRR!RR/R"RR#RR$RR%RR/R&RR#RR$RRRR/R'RR(RR)RR*RR+/R,RR(RR)RR-RR+/R.RRRRRR/RR/R0RRRRRR1RR//t-R2].R&R3R4R5R6R3/R7R4R8R6R7//t/R2].R&Rt0R9].R:&R3R;R7R&R;t2R?t3^t4^t5Rt6R9].R&]7!0Rm4t8RB].R&]7!R@RA04t9RB].R&RCRDlt:Rt;R9].RE&Rtz9)\s*(?P===|==|!=|<=|>=|~=|<|>|not\s+in|in)\s*(?P)c V^8dQhRRRR/#)rQ marker_textstrrSrNrT)rUs"rVrWrW sAA#A.ArXc.\V4\,#)aReturn the PEP 508 environment variables ``marker_text`` names. Parses the marker and reads the variables its operands name, keeping only the PEP 508 environment variables: the set variables ``extra`` / ``extras`` / ``dependency_groups`` are not lock-environment axes (a lock cannot pin them), so they drop out. A quoted name on the right of a variable comparison (``sys_platform == "python_version"``) is a value the marker compares against, not a variable it reads, and is not returned; but packaging reads the right operand of a literal-only comparison (``"3.9" == "python_version"``) as an environment key, so that name is returned. The result is an over-approximation of semantic support: a tautology such as ``python_version >= "0"`` still reports ``python_version``. Over-declaring narrows the lock, which is the safe direction to be wrong in. Every call site passes a serialised :class:`Marker`; an input that is not a valid marker raises :class:`InvalidMarker`. )rr)ras&rVmarker_variablesrd s( + &)@ @@rXc$V^8dQhRRRRRR/#)rQrRr# consultedIterable[Marker]rSrbrT)rUs"rVrWrW s#2!2!M2!>N2!SV2!rXc\VUu0uFp\V4kK up4p\4pVFpV\V4,pK \ \ 4pVP 'dVPR4V\V4, \V4, p.VO\V\\4, 4OpVU u.uFq RVPV , R2NK p p V PVP4RV9d4VPR8Xd#V PRVP44RPV 4#uupiuup i)aRender the PEP 751 ``environments`` marker for ``target``. Declares :data:`_ALWAYS_DECLARED`, ``implementation_name`` when the target names a non-default interpreter (see :attr:`ResolveTarget.declares_implementation`), and every variable the ``consulted`` markers named. The resolve dropped every dependency whose marker was False here, so a lock that let an installer answer one of those variables differently would miss deps; the declaration refuses it. Most variables are declared by value (a ``platform_system`` marker pins the OS). The :data:`_BY_CONSTRAINT` variables (``python_full_version``, and ``implementation_version`` on CPython) are not, since pinning the micro release would refuse the interpreters the resolve ran for. A minor target is a micro interval: a consulted marker that splits it (see :func:`micro_boundary_points`) leaves each slice its :attr:`~ResolveTarget.micro_clauses` bounds and the row emits those, while an unsplit minor emits none and stays a plain ``python_version`` row. On CPython ``implementation_version`` tracks ``python_full_version``, so a marker consulting it gets the same bounds mirrored onto its name. The variables :func:`unboundable_variables` names are dropped: the kernel axes always, and ``implementation_version`` on a non-CPython target (its value there is the Python level, not the interpreter's release), so a dep gated on that axis may be missed at install. rB == ""rZr?c3F"TFpVPRR4xK R#5i)python_full_versionrZN)r ).0clauses& rV *environment_declaration..Ns' . NN02J K K.s! and )sortedrbsetrdlistr^declares_implementationappendr]_BY_CONSTRAINT marker_envextend micro_clausesr[join) rRrfmarkertexts variablestextalwaysby_valuenamesnameclausess && rVenvironment_declarationr s.4 i8iFCKi8 9E%I%d++ " #F %%% +,3v;&)>v)FFH >f >vh^)<<= >EDIJEDuV..t45Q7EGJ NN6''(9,1F1F)1S  ..   <<  19Ks E!Ec V^8dQhRRRR/#)rQrRr#rSrbrT)rUs"rVrWrWUs!!-!C!rXcN\\\4,p\VPP 44UUu.uFwr#W!9gK V RV R2NK pppVP 'g VPRVP R24RPV4#uuppi)aLRender the environment a target resolved for, on its whole declared range. Pins every boundable environment axis to the target's value. A minor interval leaves the micro release open, so python_version pins the whole minor; a whole target (host, or a python-patches micro pin) adds the concrete python_full_version it resolved at. rirjzpython_full_version == "rq) r rsrwrrrxitemsis_minor_intervalrvrlr{)rRskiprvaluers& rVdeclared_range_markerrUs (#n*= =D"&"3"3"9"9";<*rXcrVPRRR4wrpVRPVP44V3#)zEReturn one clause's operands and its operator, whitespace normalized.lhsoprhs )groupr{split)rrrrs& rV _clause_partsrhs4::eT51LCS $c ))rX<>===!=>z<=_MIRRORED_OPERATORc]tRtRtRtRtR#)r"iaA consulted version marker cannot tile a minor interval. A minor target stands for every micro of its minor, and each consulted ``python_full_version`` (or, on CPython, ``implementation_version``) comparison has to partition that interval so every real interpreter reads it the same way its slice does. A membership (``in``/``not in``), a verbatim ``===``, a non-version string comparison, a comparison against another variable, a pre- or post-release version literal that would carve a slice off a real micro, or a literal PEP 440 refuses under the operator it is written with (``< "3.12.*"``, ``~= "3"``) cannot be tiled, so the resolve stops loudly rather than pin the whole minor to one synthetic answer. rTN)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rTrXrVr"r"s rXc$V^8dQhRRRRRR/#)rQpartsrrRr#rSr"rT)rUs"rVrWrWs$    )6  rXc PVwr#p\RV RV RV RVP R2 4#)zABuild the crash for a clause that cannot tile ``target``'s minor.zconsulted marker clause rz cannot tile the z minor interval: no micro boundary the lock can render comes from a python_full_version membership, a verbatim ===, a comparison against a variable, a pre- or post-release comparison, or a literal the operator cannot spell as a version bound)r"label)rrRrrrs&& rV _non_intervalrsGLCS ! "3%qAcU3 LL>E E rXc$V^8dQhRRRRRR/#)rQrRr#pointszSequence[Version]rSlist[ResolveTarget]rT)rUs"rVrWrWs$!! !#4!!rXc V'gV.#\VP R24pV.VOpR.VOp.VORNp.p\W4VRR7Fvwrxp .p VeV PR\ V4 R24V eV PRV R24VPVP \ V4\V 444Kx V#)aPartition ``target``'s minor into one slice per micro interval. ``points`` are the in-minor releases the micro line is cut at (see :func:`micro_boundary_points`), sorted ascending. They partition ``[{minor}.0, inf)`` into intervals; each interval becomes ``target`` moved onto its lower-bound release, carrying the python_full_version bounds that fence it off (see :meth:`ResolveTarget.with_micro_slice`). Every marker answers unambiguously at an interval's lower bound, so that release is where the slice resolves. Each slice declares its own environment row and pins, so a marker that genuinely splits the micros is honoured per slice rather than lifted onto the whole minor. Returns ``[target]`` unchanged when ``points`` is empty: nothing cut the minor, so the whole minor resolves at once. .0NT)strictzpython_full_version >= "rjzpython_full_version < ")rpython_versionziprv_dev0with_micro_slicerbtuple) rRrfloorrepslowersuppersslicesreplowhighrs && rVslices_from_pointsrs$ x v,,-R0 1E  F D$(?6?F#2V?T?F"$FdF4@$ ? NN5eCj\C D   NN4TF!< = f--c#hgGH A MrXc V^8dQhRRRR/#)rQversionrrSrbrT)rUs"rVrWrWs + +7 +s +rXc0\\V R244#)aReturn the ``.dev0`` boundary form of a release ``version``. The canonical disjoint and exhaustive split pair at a boundary ``X`` is ``< "X"`` on the lower side and ``>= "X.dev0"`` on the upper: a verbatim ``< "X"`` / ``>= "X"`` pair leaves a gap at prereleases of ``X`` (packaging carries a ``< X`` upper as ``X.dev0``), so the ``>=`` lower edge is snapped to ``X.dev0`` to meet the adjacent ``< "X"`` exactly. The suffix is a syntactic form on a packaging-parsed version, validated by re-parsing. z.dev0)rbr)rs&rVrrs w'%() **rXc V^8dQhRRRR/#rPrT)rUs"rVrWrWs . .} . .rXcVVPR8Xd\RR04#\R04#)aRReturn the version variables whose comparisons split ``target``. Always ``python_full_version``. On CPython ``implementation_version`` tracks it, so a comparison on it mints the same boundary; on other implementations its value is synthetic (:func:`unboundable_variables`), so it is never split and its markers stay a known limitation. r?rlrZ)r[ frozensetr\s&rV_scanned_version_variablesrs3 )/1IJKK +, --rXc$V^8dQhRRRRRR/#)rQrRr#rfrgrSz list[Version]rT)rUs"rVrWrWs$** *&6**rXc VP'g.#\VP4PR\p\VP R24p\ V4p\ 4p\V\R7FMp\P\V44F(pVP\\V4WBW044K* KO \V4#)a Return the in-minor releases ``consulted`` cuts ``target``'s minor at. A minor target stands for every micro of its minor (its ``python_full_version`` is the synthesized ``{minor}.0`` floor). A consulted marker comparing ``python_full_version`` against a literal inside the minor (``python_full_version < "3.10.2"``) needs different package sets on each side, so the release it flips at is a point the micro line is split on (see :func:`slices_from_points`). On CPython ``implementation_version`` tracks ``python_full_version``, so a comparison on it mints the same boundary. The per-operator boundary comes from the edges of the range's :meth:`~packaging.ranges.VersionRange.release_intervals`: ``<``/``>=`` at the literal, ``<=``/``>`` at the release just after it, and ``==``/``!=``/``~=``/``== V.*`` at each edge of the region they name. A boundary outside the minor or at its floor cuts nothing. An operator that cannot tile the interval raises :class:`NonIntervalMarkerError` (see there); with the whole-minor pin gone, an untileable marker stops the resolve loudly. A whole target (a host, or a python-patches pin) is not an interval and is never cut. Markers are scanned in text order, so the clause a crash names is the same every run even when ``consulted`` is unordered. Nr)key)rrrrelease_PYTHON_VERSION_PARTSrrsrrrb_MARKER_CLAUSE_REfinditerupdate_clause_boundary_pointsr)rRrf minor_releaserscannedrr|rs&& rVmicro_boundary_pointsrs8  # # # F112::;QrXc 0V^8dQhRRRRRRRRR R R R /#) rQrrrrNrtuple[int, ...]rrrRr#rSz set[Version]rT)rUs"rVrWrWsD'' ' '#'  '  '  'rXc \WV4pVf \4#VwrgpVP'd V\9gVP'd3V\ 9d(\ WV4'd \W4h\4#VP4P\4p V U U U u0uF+wrW3Fp V fK \ WV4'gKV kK! K- up p p #uup p p i)a(Return the in-minor release boundaries one clause cuts the minor at. Empty when the clause names no scanned version variable, or its boundaries fall outside the minor or at its floor. Raises :class:`NonIntervalMarkerError` when the clause names a scanned variable but cannot tile the interval. ) _clause_interval_literalrs is_prerelease_AT_LITERAL_OPERATORSis_postrelease_POST_AT_LITERAL_OPERATORS _in_minorrto_rangerelease_intervals_PYTHON_FULL_VERSION_PARTS) rrrrrRparsedr specifierr intervalslowerupperedges &&&&& rVrrs&ef =F ~u #B7"(="=2)C#C WU 3 3. .u ""$667QRI& %LEND  !*$u E " %  s*C =C  C c(V^8dQhRRRRRRRR/#)rQpointrrrrrSboolrT)rUs"rVrWrWDs)  W _ W QU rXcVPVP8H;'d#VPR\V8H;'dW8#)zWhether ``point`` is an interior micro of the minor above its floor. An epoch sorts above every version of a lower one, so a boundary with a different epoch is outside the minor whatever its release says: ``1!3.12.4`` is not in ``[3.12.0, 3.13.0)``. N)epochrr)rrrs&&&rVrrDsG  u{{"   MM00 1] B   MrXc(V^8dQhRRRRRRRR/#) rQrrrrNrRr#rSz(tuple[str, SpecifierSet, Version] | NonerT)rUs"rVrWrWRs,'"'" '"*8'"BO'"-'"rXcVwr4pW19dTpM1WQ9d*Tp\PV4pVf \W4hTpMR#V\9gVP R4'g \W4hVP R4pVP R4p \V 4p \V V 24p YKT 3# \\3d\Y4Rhi;i)a)Return ``(op, specifier, version)`` for a version-boundary clause. ``None`` when the clause names no scanned version variable. Raises :class:`NonIntervalMarkerError` when it names one but cannot tile an interval. A literal-first clause has an ordered or symmetric operator mirrored back to variable-on-left form; ``~=``/``===`` and the membership operators cannot be mirrored, so a literal-first one of those is untileable. The specifier is built here rather than by the caller because PEP 508 accepts literals PEP 440 refuses under the operator they are written with. A ``.*`` suffix is a specifier only under ``==``/``!=``, and ``~=`` needs two release components, so ``< "3.12.*"`` and ``~= "3"`` are valid markers with no specifier form; building it is what tells them from the clauses that have one. Nrjz.*) rgetr_NON_INTERVAL_OPERATORS startswithstrip removesuffixrrrr) rrrRrrrliteralmirroredrawbaserrs &&& rVrrRs$LCS ~ %))"-  . .  $$G,>,>s,C,CE** -- C   D !D5$- B4u.  ' !! , -5E*45s B..C c V^8dQhRRRR/#)rQ env_sourceEnvironmentSourcerSrIrT)rUs"rVrWrW|s Y Y! Y YrXcV!4P4UUu/uFwr\V\4'gKWbK! upp#uuppi)zReturn the host's PEP 508 marker environment as a plain string dict. ``default_environment`` returns a TypedDict whose ``.items()`` view widens the values to ``object``, so rebuild it as ``dict[str, str]`` the callers can overlay onto. )r isinstancerb)rrrs& rVhost_environmentr|s9*4););)= X)=:3ESVAWJCJ)= XX Xs AAc V^8dQhRRRR/#)rQrrbrSrIrT)rUs"rVrWrWsBBCBNBrXc\V4pTPpRPR.TO^N5R\44p\ T4\ 8dTpMrTP'dTP R2MRpRPR.TO^N^N5R\ 44p\T4\ TP4RpT T T 2pR TR T/# \dRT: R2p\T4Rhi;i) aMap an explicit Python version to its PEP 508 marker keys. ``python_version`` is padded to two components and ``python_full_version`` to three so patch-precision markers evaluate the same here as in the universal matrix. Raises ``InvalidVersion`` if the input is not a version. zpython_version z is not a valid versionN.c38"TFp\V4xK R#5iNrbrmparts& rVro*python_axis_environment..sQ+P4SYY+P!c38"TFp\V4xK R#5irrrs& rVrors "O$CII"Orrrl) rrrr{rlenrrrb base_version) rrmsgrminorfullrpaddedsuffixs & rVpython_axis_environmentr s,(nnG HHQ=W=a=9O:O+PQ QE 7|11'-lll6<<." "2G"2Q"2"23N4N"O  VS!4!4578) e%:D AA! ,11HIS!t+,s C C+c$V^8dQhRRRRRR/#)rQ environmentrIoverlayMapping[str, str]rSNonerT)rUs"rVrWrWs$*; rXc&VPR4;'gVPR4pVfVPV4R#\V4pVPR4R8Xd VR,VR&VPV4VPV4R#)awMerge ``overlay`` into ``environment``, keeping the python axis in sync. When the overlay moves only ``python_version`` (or only ``python_full_version``) the untouched key would keep the host patch level and the two would describe different interpreters. Re-derive both from whichever axis key the overlay supplies (``python_full_version`` wins when both are present), so an overlay of ``python_version`` ``3.8`` yields ``python_full_version`` ``3.8.0`` like the universal matrix. On CPython ``implementation_version`` equals ``python_full_version``, so move it with the axis; other implementations version separately and keep their host value unless the overlay sets it. Non-axis keys the overlay sets are kept verbatim; the ``python_version``/``python_full_version`` pair is always the derived one, so a patch-precision ``python_version`` (e.g. ``3.10.5``) normalizes to major.minor. rlrNrBr?rZ)rrr )rrsourceaxiss&& rVapply_python_axis_overlayrs$[[. / P P7;;?O3PF ~7# "6 *D,-:045J0K ,-wtrXT)frozenc]tRtRt$RtR]R&]!RR7tR]R&]!RR7tR ]R &]!RR7t R ]R &RFt R ]R&]!RRR7t R]R&]!RRR7t R ]R&]!RRR7t R ]R&]!RRR7tR ]R&]!RFRR7tR]R&RRlt]RRl4t]RRl4t]RR l4t]R!R"l4t]R#R$l4tR%R&lt]R'R(l4t]R)R*l4t]R+R,l4tR-R.lt]R/R0l4t]R1R2l4t]R3R4l4tR5R6ltR7R8lt R9R:lt!]"R;]#R<]$PJ/R=R>ll4t&]"R;]#R<]$PJ/R?R@ll4t']"RARBRCRRR/RDREll4t(RFt)R#)Gr#ia+One environment a resolve runs against: markers, wheel tags, a name. ``label`` names the target (``host``, ``py312-linux_x86_64``) and is the key a universal lock records its pins under, so it carries every axis that makes one target differ from another, including the conflict-fork ``selection``. ``selection`` is the conflict-fork this target belongs to: the ``(kind, name)`` members (``kind`` is ``"extra"`` or ``"group"``) active in this fork's resolve, empty for an unforked one. When set, it adds a ``'name' in extras`` / ``'name' in dependency_groups`` clause to :attr:`marker_string`; the lockfile emitter builds the per-package marker from the members themselves, keeping only the sets the package varies over and negating their co-members. ``platform_spec`` is set on a declared (matrix) target and names the tag knobs it was expanded from; a host target has none. ``multi_implementation`` says the matrix models more than one implementation, which pins ``implementation_name`` on :attr:`environment_marker_string` so the CPython and PyPy entries for one python/platform stay mutually exclusive. ``tags_faithful`` says :attr:`tags` still describes the machine :attr:`marker_env` does. Only :meth:`with_marker_overrides` can break that, and a provider given such a target filters no wheel by tag: see there. rbrF)comparerrxrrr host_faithfultuple[tuple[str, str], ...] selectionN)defaultrzPlatformSpec | None platform_specmulti_implementationT tags_faithfulconcrete_microrErzcV^8dQhRR/#)rQrSrrT)rUs"rVrWResolveTarget.__annotate__s++t+rXc \VP4R# \d1pRTP: RTP: R2p\ T4ThRp?ii;i)aReject a python the resolve cannot compare Requires-Python against. Every candidate's ``Requires-Python`` is tested against this target, so an unparseable version has to fail here, naming itself, rather than as an ``InvalidVersion`` raised per candidate deep in the listing. ztarget z names python_full_version z , which is not a PEP 440 versionN)rrlrr ValueError)selfexcrs& rV __post_init__ResolveTarget.__post_init__s] + D,, - +$**(,,//OQ S/s *  +s A+AAcV^8dQhRR/#rQrSrbrT)rUs"rVrWr#s111rXc (VPR,#)z=The PEP 508 ``python_version``: the target's ``major.minor``.rrxr&s&rVrResolveTarget.python_versions/00rXcV^8dQhRR/#r+rT)rUs"rVrWr# s66S6rXc (VPR,#)z?The PEP 508 ``python_full_version``: the target's full release.rlr-r.s&rVrl!ResolveTarget.python_full_version 455rXcV^8dQhRR/#)rQrSrrT)rUs"rVrWr#s G G GrXc R\\VP4P4#)aThe release a ``Requires-Python`` specifier is compared against. ``python_full_version`` is the PEP 508 marker value, so on a release candidate it carries the ``rc``. A specifier admits no prerelease unless it names one, so comparing that value directly would exclude every distribution requiring the very release the interpreter is a candidate for. pip compares ``sys.version_info``, and so does this. )rrlrr.s&rVpython_releaseResolveTarget.python_releases wt778EEFFrXcV^8dQhRR/#rQrSrrT)rUs"rVrWr#sFF4FrXc VP'gVP'dR#VP'dR#VPVP R28H#)aWhether this target is a bare minor resolved as a micro interval. A host reports a real interpreter and a python-patches pin names a concrete micro; both are whole and resolve at one point. A bare minor synthesizes ``{minor}.0`` and stands for every real micro of the minor, so the micro line can be split on it and Requires-Python is answered against the whole minor, not the synthetic floor. A slice off that minor carries ``micro_clauses`` and still stands for every interpreter its bounds admit, so it too is an interval answering Requires-Python at the same whole minor. A pinned ``X.Y.0`` reads as the synthetic floor by string alone, so the concrete-micro flag, not the value, decides: a python-patches pin is whole even when its micro is ``.0``. FTr)rr!rzrlrr.s&rVrResolveTarget.is_minor_intervalsL"    !4!4!4    ''d.A.A-B"+EEErXcV^8dQhRR/#)rQrSrrT)rUs"rVrWr#3sVV\VrXc  \VP4PpV^,V^,r2\RV RV RV RV^, R2 4P 4#)z= "3.13.2"`` admits the 3.13 minor instead of excluding it at the synthetic ``.0`` floor. The test is range overlap, not a scalar ``in``: ``>= "3.13.2"`` would exclude both ``3.13`` and ``3.13.0``. )rr intersectionr?is_emptyr6)r&rBs&&rVadmits_requires_python$ResolveTarget.admits_requires_python9sG  ! ! !}}33D4D4DENNN N""d**rXcV^8dQhRR/#r+rT)rUs"rVrWr#Hs666rXc (VPR,#)z@The target's interpreter implementation (``cpython``, ``pypy``).rBr-r.s&rVr[ResolveTarget.implementationGr3rXcV^8dQhRR/#r+rT)rUs"rVrWr#Ms///rXc ,\VP4#)zThe conflict fork this target belongs to, as a label slug. ``extra-cpu``, ``group-black22.group-isort5``, empty when unforked. It is the tail of :attr:`label` without the leading separator. )_selection_slugrr.s&rVselection_slugResolveTarget.selection_slugLst~~..rXcV^8dQhRR/#r+rT)rUs"rVrWr#Ws..S.rXc VVPf\#VPP#)z@The matrix platform this target names, or ``host`` for the host.)r_HOST_PLATFORM_LABEL platform_idr.s&rVrSResolveTarget.platform_idVs(    %' '!!---rXcV^8dQhRR/#)rQrSzdict[str, str | frozenset[str]]rT)rUs"rVrWr#]s<<%D.s1 CT4CGGDMT__006 6CTs:=TF)rxrr )dictrxranyrFr r )r&rhmovedr^sf& @rVwith_marker_overrides#ResolveTarget.with_marker_overridess|,K4??#!#y1 CT  CT   ,,::U   rXc V^8dQhRRRR/#)rQrrrSr#rT)rUs"rVrWr#s  (C  rXc VPpVP'd#VR\\VP44)p\ VV\V4,VR7#)aReturn this target under a conflict fork's active members. The label gains one ``kind-name`` clause per member, joined by ``.`` in sorted order, so the forks of one target stay distinct: ``py311-linux_x86_64-group-black22.group-isort5``. The ``.`` separator and the ``kind`` prefix keep it unambiguous, since canonical member names are ``[a-z0-9-]`` only: two selections that differ in how their names split on ``-`` (or an extra and a group of the same name) cannot collide onto one label and silently overwrite each other's pins. N)rr)rrr_selection_suffixr )r&rrs&& rVwith_selectionResolveTarget.with_selectionsVzz >>>A30@AABD *955  rXc$V^8dQhRRRRRR/#)rQrlrbrrErSr#rT)rUs"rVrWr#s$  #& 1@  rXc \VP4p\VRV/4VPRR4p\VVP RV 2VVR7#)aCReturn this target moved onto one micro slice of its minor. ``python_full_version`` is the representative release the slice resolves at (its lower bound), and ``clauses`` are the python_full_version bounds that fence the slice off from the others, appended to :attr:`environment_marker_string`. The label gains a ``-pfXYZ`` suffix so each slice pins under its own key. The python axis is re-derived, so ``python_version`` stays the minor and only the micro (and, on CPython, ``implementation_version``) moves; the wheel tags do not move with the micro, so they stay faithful. rlrrz-pf)rrxrz)rlrxrr r)r&rlrr^compacts&&& rVrResolveTarget.with_micro_slices]4??#!#(=?R'ST%--c26 ZZLG9-!   rXr tags_sourcec$V^8dQhRRRRRR/#)rQrrrzrrSr#rT)rUs"rVrWr#s*  &     rXc ^V!\\V4\P!VR7RR7#)zReturn the target the running interpreter is. Both sources are injected so a caller can model an interpreter other than the one running, and so tests do not have to resolve against whatever machine they happen to be on. rzT)rrxrr)rRrrfor_host)clsrrzs&$$rVr~ResolveTarget.for_hosts+&' 3[9   rXc(V^8dQhRRRRRRRR/#) rQpythonrbrrrzrrSr#rT)rUs"rVrWr#s2   &      rXc  \V4p\V\V44V!\VR,VR,4R\ 2,V\ P !WR7R\\V4P4\8R7#)aReturn the host with its interpreter moved to ``python``. The machine stays the host: its markers and platform tags carry over, and only the python axis (``python_version``, ``python_full_version``, and the tags' interpreter/abi) moves. This is what pip's ``--python-version`` targets. A bare minor ("3.10") resolves as a micro interval off its ``.0`` floor; a named patch level ("3.10.5", "3.13.0") is one concrete micro resolved whole, so an ``X.Y.0`` pin is not the synthetic floor. rrB-r}F)rrxrrr!) rrr  _python_labelrRrfor_host_pythonrrrr)rrrrzr^s&&$$ rVrResolveTarget.for_host_pythons~&z*!#'>v'FG$4 5s;P7QR&'()''Hwv667;UU   rXr[r?rlc 0V^8dQhRRRRRRRRRR R R /#) rQrrbrBrr[rl str | NonerrrSr#rT)rUs"rVrWr#sH       (  #   rXc  V!\W4RVP 2,\WW44\P!VVVR7RVVVRJR7#)aReturn a target declared as (python, platform, implementation). A bare minor resolves as a micro interval: its ``python_full_version`` floor is ``{minor}.0`` and a consulted ``python_full_version`` marker splits it at the boundary it names. Passing ``python_full_version`` pins the target to one concrete deployment micro and resolves it whole, the manual single-point alternative to splitting. r)rrBr[FN)rrxrrrrr!)rrdeclared_environmentrfor_spec)rrrBr[rlrs&$$$$$rV for_declaredResolveTarget.for_declareds`$?Adjj\BRR+n--  !5.d:  rXrT)*rrrrr__annotations__rrxrrrrrr r!rzr(propertyrrlr6rr?rFr[rNrSrWrur_rerortr classmethodrptagssys_tagsr~rrrrTrXrVr#r#s/8 J$)%$8J!8'D&'.M4.-/I*/).tU)KM&K!&ue!D$DeND> &+2u%EM?E+ 1166 G GFF,VV +66//.. <MM*"" H * 0 )< #(..   & )<  #(..   : (  +/  &+  rXc ,V^8dQhRRRRRRRRRR /#) rQrrbrBrr[rlrrSrIrT)rUs"rVrWrW@s: $   rXc T;'gV R2p/\VP,C\V,CRVRVRVRVPRVP/C#)aBuild a complete PEP 508 marker environment for a declared target. Combines the platform's OS/arch markers and the implementation's interpreter-identity markers with the python-axis values derived from ``python_version``. ``platform_release`` and ``platform_version`` come from the :class:`~nab_python.tags.PlatformSpec`; both default to ``""`` so kernel-conditioned markers evaluate False unless the user declares a target kernel or OS version. ``implementation_version`` is set to the Python version for every implementation; for non-CPython this is the interpreter's Python level, not its own release (PyPy 7.3.x), so the rare ``implementation_version`` marker on PyPy may misevaluate during the resolve. The lock does not carry the synthetic value: see :func:`unboundable_variables`. rrrlrZrLrM)rrSrrLrM)rrBr[rlr s&&&& rVrr@so,  7 7^$4B"7D  4++ ,   0  .t $D11D11 rXcf]tRtRt$RtR]R&R]R&RtR]R&R tR ]R &RtR ]R &RRlt Rt R #)r!ibaThe declared set of targets a resolve covers. Expands a python range, a platform list, and an implementation list into a finite list of :class:`ResolveTarget`. Every PEP 508 variable any marker on the dep graph names has a value in every target; ``Requires-Python`` filtering happens elsewhere. ``python_order``: ``"asc"`` (default, oldest first) or ``"desc"``. Combined with cross-target alignment in the resolver this selects between ``fork-strategy=fewest`` (asc: the oldest-Python pin propagates forward, so the lowest common version wins) and ``fork-strategy=requires-python`` (desc: the newest-Python pin propagates, so older Pythons diverge only when the new version is incompatible). ``python_patches``: optional ``{minor: full_version}`` mapping that pins a matrix minor to one concrete deployment micro and resolves it whole, instead of as a micro interval split at each consulted boundary. Use it to resolve a minor as the single patch release you deploy. Example: ``python_patches={"3.11": "3.11.4", "3.12": "3.12.1"}``. ``implementations``: the interpreter implementations to model (``"cpython"``, ``"pypy"``). Each multiplies the target count; markers and wheel tags resolve per implementation. rbrztuple[PlatformSpec, ...] platformsasc python_orderNzdict[str, str] | Nonepython_patchesrEimplementationscV^8dQhRR/#)rQrSrrT)rUs"rVrWMatrix.__annotate__s? ? +? rXc VPR 9dRVP: 2p\V4hVPUu.uF&pVP\9gKVPNK( ppV'dRV: 2p\V4hVP Uu.uFqD\ 9gKVNK ppV'dRV: 2p\V4hVP;'g/pVUu.uFqw\9gKVNK ppV'dRV: R2p\V4h\VPVP \\VP44R7\\VP44p V 'gRVP: 2p\V4hVPR8XdV P4\VP 4^8p V U U U u.uFRp VPF?p VP F,p \ P#V V V VP%V 4V R 7NK. KA KT up p p #uupiuupiuupiuup p p i) aLExpand the matrix into concrete targets. Validates inputs eagerly: unknown platform ids, unknown implementations, ``python_patches`` keys that are not known minors, an empty python range, an invalid ``python_order``, or a free-threaded platform no interpreter build can satisfy each raise a ``ValueError`` before any work happens. descz*python_order must be 'asc' or 'desc'; got zUnknown platform ids: zUnknown implementations: zUnknown python_patches minors: z&; keys must be major.minor like '3.11')rrpython_versionszNo known Python versions match )rrBr[rlr>rr)rr%rrSrrrrrcheck_free_threadedr_pythons_in_rangerrtreverserr#rr)r&rsunknowni unknown_implpatchesmunknown_patches py_versions multi_implrGrBimpls& rVexpand Matrix.expands9   O 3>t?P?P>STCS/ !^^ #}}$44 AMM#  *7+6CS/ !++ +!8N/NAA+   -l-=>CS/ !%%++&-Ng:M1M11gN 1/1DE88 S/ !nn 00!"3DKK"@A ,T[[9: 3DKK?CCS/ !    &    !--.2 "  ",,  & &!#$+KKO%/ ' - ' "  O  O,  s*H*H* H/!H/ H4-H4 AH9rT)r?) rrrrrrrrrrrrTrXrVr!r!bs=4 K''L#,0N)0'3O_3? ? rXc(V^8dQhRRRRRRRR/#)rQrzSequence[PlatformSpec]rz Sequence[str]rrSrrT)rUs"rVrWrWs2%##   rXc\;QJdRV4F 'gK RM RM !RV44'gR#VUu.uF q3R8wgK VNK ppV'dRV: R2p\V4hRPR \44pVUu.uFp\ V4'dKVNK ppV'dR V R V: 2p\V4hR#uupiuupi) aVReject a free-threaded platform no interpreter build can satisfy. The ``cpXYt`` ABI ships only from CPython 3.13, and the rule needs all three axes: the platform carries the flag, and only the declaration around it knows the implementation and the python versions. Both declaring surfaces (the matrix and the single environment) call this. c38"TFqPxK R#5ir) free_threaded)rmrBs& rVro&check_free_threaded..s8id!!irTFNr?z,a free-threaded platform needs CPython, not z(; only CPython has a free-threaded buildrc38"TFp\V4xK R#5irr)rmps& rVrors>%=SVV%=rz'a free-threaded platform needs CPython z or newer, not )rmr%r{rr) rrrrforeignrrrGtoo_olds $$$ rVrrs 38i83338i8 8 8)%=> >E+OOb3J23NrrOGO5eWOG; W o =PsCCC(Cc V^8dQhRRRR/#)rQrBrbrSz Iterable[str]rT)rUs"rVrWrWs  C M rXc#p"\V4p\Fp\V R24V9gKVxK R#5i)zuYield the known Python minors that satisfy ``spec``. ``spec`` is a PEP 440 specifier set, e.g. ``">=3.11, <3.14"``. rN)rrr)rBrr s& rVrrs5 $ F$ eWB< F *K %s%6 6c$V^8dQhRRRRRR/#)rQrrbr[rSrT)rUs"rVrWrWs!44#4s4s4rXcf\PV\4pW PRR4,#)zDRender the interpreter half of a label, e.g. ``py311`` or ``pp311``.rr)rJr_DEFAULT_IMPLEMENTATION_PREFIXr )rr[prefixs&& rVrrs+ # ' '8V WF **33 33rXc V^8dQhRRRR/#rQrrrSrbrT)rUs"rVrWrWsJJ:JsJrXcDRPR\V444#)z@Render a conflict-fork selection as a slug, empty when unforked.rc34"TFwrV RV 2xK R#5i)rNrT)rmrcrs& rVro"_selection_slug..sI7HtfAdV$7Hs)r{rr)rs&rVrMrMs 88Ivi7HI IIrXc V^8dQhRRRR/#rrT)rUs"rVrWrWs&&!<&&rXc6\V4pV'dRV 2#R#)zHRender a conflict-fork selection as a label suffix, empty when unforked.rr)rM)rslugs& rVrsrss 9 %DQtf:%2%rX)rrrrr rr!r"r#r rrrrrrrdrr rr])rBr+r)r@r'rr%)z3.8z3.9z3.10z3.11z3.12z3.13z3.14z3.15> r+r%rr'r)rLrMrBrlrZr@)rr%r))rlrZ>in===not in>rrrr~=r)]__conditional_annotations__r __future__rrecollections.abcrrrr dataclassesrrr typingr _conflict_kindr r r _vendor.packagingrr_vendor.packaging.markersrr_vendor.packaging.markersetsr_vendor.packaging.specifiersrr_vendor.packaging.versionrrrrrr_vendor.packaging.rangesrr__all__rbobjectrrrrrFrJrrRrrrrrr r]r^rw_MARKER_OPERANDcompilerrdrrrrrrrr%r"rrrrrrrrrr rr#rr!rrrrMrs)rs@rVrs&# AA11  -B8H>6  8Rf!5567H7  7I7  8G7  8H7  9G4  9G4  7F7  7H7 W1/+1l()y (&v  51 &?+4T64)HH!% (_ +4 +*09+,0n E$%/C?JJ ! #A.2!j!&*$$;<""?@ 3Yu5EE$$$$ &N Z  !H + .*Z'T '"V%8 YB:< $y y y x D ` `  ` FB 4 J &rX