+ 2jRt^RIHt^RIt^RIt^RIt^RIt^RIHtH t ^RI H t H t ^RI Ht^RIHt^RIHtHtHtHt^RIHtHtHt^R IHtHt^R IHtH t ^R I!H"t"H#t#H$t$^R I%H&t&H't'^R I(H)t)^RI*H+t+H,t,^RI-Ht] 'd^RI.H/t/H0t0H1t1^RI2H3t3.R+Ot4Rt5Rt6^ t7R,t8] 'd ^RI9H:t:^RI*H;t;]Px!]=4t>!RR]P~4t@]!RRR7!RR44tARR ltB]!RRR7!R!R44tC]!R"R44tD]!R#R$44tER%R&ltFR'R(ltG!R)R4tH]C]I]C,,R,tJ!R*R4tKR#)-aChannel-based async I/O coordinator for nab-python. Mirrors uv's architecture: a sync resolver on the main thread sends fetch requests through a queue to an async fetcher on a background thread. An InMemoryIndex is shared state between both. The cross-thread bridge is built from the standard library only: the fetcher thread owns an ``asyncio.Queue`` and the sync side schedules puts on the loop with ``call_soon_threadsafe``. ) annotationsN) dataclassfield) TYPE_CHECKINGAny)urlsplit)canonicalize_name) CacheBackend NullCache OfflineError OnDiskCache)CachedAsyncSimpleClientParsedCacheStatsread_fresh_parsed_listing) SdistFile WheelFile)RangeCapabilityMemo RangeOutcome)LocalIndexClient is_file_urlparse_file_url) IndexConfigMultiIndexClient)SimpleSerialization)IDENTITY_HEADERSraise_unless_ok)CallableMappingSequence)SelfFetchCoordinator FetchKind FetchRequest InMemoryIndex IndexRoute WarmSyncStatspypizhttps://pypi.org/simple/)Path)AsyncHttpTransportc2]tRt^MtRtRtRtRtRtRt Rt Rt R #) r!z;Distinguishes the kinds of fetches the coordinator handles.listingmetadatazrange-metadatasdistz sdist-archivezdirect-archiveN) __name__ __module__ __qualname____firstlineno____doc__LISTINGMETADATARANGE_METADATASDIST SDIST_ARCHIVEDIRECT_ARCHIVE__static_attributes__r-[/home/user/billing-ledger-validation/.venv/lib/python3.14/site-packages/nab_python/fetch.pyr!r!Ms#EGH%N E#M%Nr:T)frozenslotsc0]tRt^Xt$RtR]R&R]R&RtR#)r$aPer-package index routing rule (a strict pin to one index). ``name`` is the package name (canonicalised internally). ``index`` is the *name* of an :class:`IndexConfig` declared in the coordinator's ordered list. Routing decides where to fetch a package's listing before any version is known, so a route carries no version scope and no marker; the override layer guarantees at most one route per package. strnameindexr-N)r.r/r0r1r2__annotations__r9r-r:r;r$r$Xs I Jr:c V^8dQhRRRR/#)routeszlist[IndexRoute]returnzdict[str, str]r-)formats"r; __annotate__rHhsLL,LLr:clVUu/uF#p\VP4VPbK% up#uupi)zReduce routes to ``{canonical_name: index_name}``. At most one route exists per package (the override layer rejects two routes for one name at parse time), so this is a straight projection. )rr@rA)rEentrys& r;_resolve_routesrKhs1 EK KF5 ejj )5;; 6F KK Ks)1cv]tRt^qt$RtR]R&R]R&RtR]R&RtR]R &RtR ]R &Rt R ]R &Rt R ]R&Rt R#)r"z@A single fetch request, carried across the sync->async boundary.r!kindr?packageN str | Noneversionurltuple[str, str] | None metadata_hashtuple[tuple[str, str], ...] sdist_hashes wheel_hashesr-) r.r/r0r1r2rBrPrQrSrUrVr9r-r:r;r"r"qsDJ O LGZC,0M)002L-202L-2r:c~]tRt^~t$Rt^tR]R&^tR]R&^tR]R&^t R]R&^t R]R&^t R]R&^t R]R &R t R #) r%zCounters for the synchronous warm-hit listing path. A sync hit bumps ``listing_hits``; a decline bumps ``listing_declines`` and one reason sub-counter, then runs the async path. Written only from the main resolver thread, so the counters need no lock. int listing_hitslisting_declinesdeclined_ineligibledeclined_no_policydeclined_stale_onlinedeclined_no_blobdeclined_small_blobr-N)r.r/r0r1r2rYrBrZr[r\r]r^r_r9r-r:r;r%r%~sWL#c  !"3"c  r:cV]tRt^t$]!]P R7tR]R&Rt R]R&Rt R#)_Pending)default_factorythreading.EventeventNrresultr-) r.r/r0r1r threadingEventrdrBrer9r-r:r;raras"9??CE?CFCr:rac(V^8dQhRRRRRRRR/#rDrNr?rP metadata_urlrOrFr-)rGs"r;rHrHs(::3::J:3:r:cRV RV RV 2#)zReturn the pending key for one sidecar fetch. The URL is in the key so two wheels of a version do not share a request: a waiter is released by the artifact it asked for. z metadata::r-)rNrPrjs&&&r; _metadata_keyrms wiq <. 99r:c(V^8dQhRRRRRRRR/#)rDrNr?rP wheel_urlrFr-)rGs"r;rHrHs(444c4c4c4r:cRV RV RV 2#)a Return the pending key for one range read. The wheel URL is in the key so sibling sidecar-less wheels of a version do not share a request: sibling wheels can declare different dependencies, so a waiter is released by the wheel it asked for, matching the sidecar path. zrange:rlr-)rNrPros&&&r; _range_keyrqsG9AgYa { 33r:c]tRt^tRtRRltRRltRRRR/R R lltR R ltR Rlt RRlt RRlt RRlt RRlt RRltRURRlltRURRlltRURRlltR R!ltRUR"R#lltRUR$R%lltRUR&R'lltR(R)ltR*R+ltR,R-ltR.R/ltR0R1ltR2R3ltR4R5ltR6R7ltR8R9ltR:R;ltR<R=lt R>R?lt!R@RAlt"RBRClt#RDRElt$RFRGlt%RHRIlt&RJRKlt'RLRMlt(RNROlt)RPRQlt*RRRSlt+RTt,R#)Vr#zgThread-safe storage for fetched package data. The async fetcher writes here; the sync provider reads. cV^8dQhRR/#rDrFNoner-)rGs"r;rHInMemoryIndex.__annotate__s0G0G$0Gr:c x\P!4Vn/Vn/Vn/Vn\ 4Vn\ 4Vn/Vn /Vn \ 4Vn \ 4Vn \ 4Vn /Vn/Vn/Vn/Vn/Vn/Vn/VnR#)zCreate an empty index.N)rfLock_lock _listings_listing_errors_listing_indexesset_offline_listing_misses_unreadable_only_listings _metadata_metadata_errors_offline_metadata_misses_offline_metadata_warned_metadata_from_sdist_sdist_pyproject_sdist_archives_sdist_archive_errors_range_outcomes_pending_parsed_metadata_resolved_sdist_metadataselfs&r;__init__InMemoryIndex.__init__s^^% AC9;0214$365& IKRTDG5%25%%;>%!CEDFKM" JL-/ IKEG%r:c V^8dQhRRRR/#rDrNr?rFz"list[WheelFile | SdistFile] | Noner-)rGs"r;rHrvs//3/+M/r:c VP;_uu_4VPPV4uuRRR4# +'giR#;i)z7Return the cached listing for ``package``, or ``None``.N)ryrzgetrrNs&&r; get_listingInMemoryIndex.get_listings) ZZZ>>%%g.ZZZ ; A offline_missFunreadable_onlyc ,V^8dQhRRRRRRRRRR /#) rDrNr?dataSequence[WheelFile | SdistFile]rboolrrFrur-)rGs"r;rHrvs<   .       r:c RV 2p\V4pVP;_uu_4W`PV&V'dVPP V4V'dVP P V4VP PV4pRRR4Xe#WgnVPP4R#R# +'giL8;i)aCache the listing for ``package`` and unblock any waiter. ``data`` is accepted as a Sequence (covariant) so callers can pass homogeneous ``list[WheelFile]`` lists; it is materialised into the internal ``list[WheelFile | SdistFile]`` cache. ``offline_miss`` marks the empty listing as an index skipped offline rather than one that served no files. ``unreadable_only`` marks it as a page whose every file is in a format nab does not read. listing:N) listryrzr~addrrrrerdr})rrNrrrkey materialisedpendings&&&$$ r; store_listingInMemoryIndex.store_listings$ "Dz ZZZ&2NN7 #,,009..227;mm'',G   )N MM    Zs9C6C C c V^8dQhRRRR/#rDrNr?rFrr-)rGs"r;rHrvs;;s;t;r:c VP;_uu_4WP9uuRRR4# +'giR#;i)zBWhether ``package``'s empty listing is an offline cold-cache miss.N)ryr~rs&&r;is_offline_listing_miss%InMemoryIndex.is_offline_listing_misss# ZZZ:::ZZZ. ? c V^8dQhRRRR/#rr-)rGs"r;rHrv s==#=$=r:c VP;_uu_4WP9uuRRR4# +'giR#;i)zAWhether ``package``'s empty listing held only unreadable formats.N)ryrrs&&r;is_unreadable_only_listing(InMemoryIndex.is_unreadable_only_listing s# ZZZ<<<ZZZrc$V^8dQhRRRRRR/#)rDrNr?error BaseExceptionrFrur-)rGs"r;rHrvs!   3  }    r:c RV 2pVP;_uu_4W PV&VPPV4pRRR4XeVPP 4R#R# +'giL2;i)a+Record a failed listing fetch and unblock any waiter. Distinct from ``store_listing([])``: an empty listing means the index served nothing nab could read, while an error means the fetch itself failed. ``fetch_versions`` re-raises the error instead of reporting the package as having no candidates. rN)ryr{rrrdr})rrNrrrs&&& r;store_listing_error!InMemoryIndex.store_listing_errorse " ZZZ,1  )mm'',G   MM    Zs *A.. A> c V^8dQhRRRR/#)rDrNr?rFBaseException | Noner-)rGs"r;rHrv s5551E5r:c VP;_uu_4VPPV4uuRRR4# +'giR#;i)zEReturn the recorded listing fetch error for ``package``, or ``None``.N)ryr{rrs&&r;get_listing_errorInMemoryIndex.get_listing_error s+ ZZZ''++G4ZZZrc$V^8dQhRRRRRR/#)rDrNr? index_namerFrur-)rGs"r;rHrv%s!8838C8D8r:c VP;_uu_4W PV&RRR4R# +'giR#;i)z1Record which configured index served ``package``.N)ryr|)rrNrs&&&r;store_listing_index!InMemoryIndex.store_listing_index%s% ZZZ-7 ! !' *ZZZs. ? c V^8dQhRRRR/#)rDrNr?rFrOr-)rGs"r;rHrv*s6666r:c VP;_uu_4VPPV4uuRRR4# +'giR#;i)zFReturn the configured index name that served ``package``, or ``None``.N)ryr|rrs&&r;get_listing_indexInMemoryIndex.get_listing_index*s+ ZZZ((,,W5ZZZrc(V^8dQhRRRRRRRR/#rDrNr?rPrjrOrFztuple[str | None, bool]r-)rGs"r;rHrv/s2PPP%(P8BP Pr:c VeEWV3pW@P9dVPV,pVeVR3#MW3VP9dR#VPPWR34pWaV3VP93#)aReturn the text answering for ``metadata_url`` and its origin. Caller holds the lock. The artifact's own slot wins, then the version-level one. An sdist's PKG-INFO answers for an artifact whose own read returned nothing, but not for one nobody has read yet: lending it there would give a wheel that declares its own dependencies the sdist's. An injected override has no artifact behind it and answers for any. NF)NF)rrr)rrNrPrjslottext version_levels&&&& r;_read_metadataInMemoryIndex._read_metadata/s  #l3D~~%~~d+# %=($#t'@'@@$$**Gd+CD 1T5N5NNOOr:Nc(V^8dQhRRRRRRRR/#rir-)rGs"r;rHrvFs2JJJ%(J8BJ Jr:c VP;_uu_4VPWV4^,uuRRR4# +'giR#;i)z;Return cached metadata text, or ``None`` if not yet stored.NryrrrNrPrjs&&&&r; get_metadataInMemoryIndex.get_metadataFs.ZZZ&&wFqIZZZs 9 A c(V^8dQhRRRRRRRR/#)rDrNr?rPrjrOrFrr-)rGs"r;rHrvMs,%(8B r:c VP;_uu_4VeWV3VP9d RRR4R#WR3VP9;'dVRJ;'gW3VP9uuRRR4# +'giR#;i)aReturn ``True`` once a fetch answering for ``metadata_url`` resolved. Any value counts, including the ``None`` of a sidecar that was not served. It tracks :meth:`_read_metadata`, so a fetch skipped on the strength of it leaves the reader the same text a fetch would have. NT)ryrrrs&&&&r; has_metadataInMemoryIndex.has_metadataMs|ZZZ(|4F Z d+t~~=$GG%T-F-FFZZZsA7A7 A7A77 B c(V^8dQhRRRRRRRR/#rr-)rGs"r;rHrvas2 G G G%( G8B G  Gr:c VP;_uu_4VPWV4uuRRR4# +'giR#;i)aReturn the metadata text for ``metadata_url`` and its sdist origin. A wheel's METADATA and an sdist's PKG-INFO can both stand for one version, and only sdist text goes through the :pep:`643` dynamic-deps gate, so text and origin are read together under one lock. Nrrs&&&&r;get_metadata_with_origin&InMemoryIndex.get_metadata_with_originas)ZZZ&&wFZZZs 2 A c(V^8dQhRRRRRRRR/#) rDrztuple[str, str, str | None]rrO from_sdistrrFrur-)rGs"r;rHrvms2$$)$$  $  $r:c 0VwrEpVfVPPV4V8wdVPPWE3R4V'dVPP WE34MVPP WE34W PV&R#)zWrite one metadata slot. Caller holds the lock. Reconciled sdist metadata is derived from the version-level text, so replacing that text drops it. The parsed cache carries the text it parsed and needs no eviction. N)rrrpoprrdiscard)rrrrrNrPrjs&&&$ r;_write_metadata_slot"InMemoryIndex._write_metadata_slotms*.&,  ~~!!$'4/--1172DdK))--w.@A))1172DE#tr:c ,V^8dQhRRRRRRRRRR/#) rDrNr?rPrrOrjrFrur-)rGs"r;rHrvs<      !    r:c .\WV4pWV3pVP;_uu_4VPWcRR7VPP V4pRRR4Xe#W7nVP P4R#R# +'giL8;i)aCache metadata text (or ``None`` for a failed fetch). ``metadata_url`` is the sidecar the text came from; ``None`` stores the text as standing for the version rather than for one artifact. A ``data`` of ``None`` means no PEP 658 sidecar arrived and readers fall back to the sdist. It lands in the sidecar's own slot, so it cannot erase sdist PKG-INFO the version-level slot already holds. FrN)rmryrrrrerdr})rrNrPrrjrrrs&&&&& r;store_metadataInMemoryIndex.store_metadatasy Gl;,/ ZZZ  % %dU % Cmm'',G  !N MM    Zs /B B c ,V^8dQhRRRRRRRRRR /#) rDrNr?rPrrrjrOrFrur-)rGs"r;rHrvs<      !    r:c \WV4pVP;_uu_4W0PWV3&VPP V4pRRR4XeVP P 4R#R# +'giL2;i)a2Record a failed metadata fetch and unblock waiters. Distinct from ``store_metadata(None)``: ``None`` means no PEP 658 sidecar arrived and the resolver may fall back to the sdist; an error means an advertised sidecar could not be fetched or failed its published hash, so the resolve must not fall through. N)rmryrrrrdr})rrNrPrrjrrs&&&&& r;store_metadata_error"InMemoryIndex.store_metadata_errorsjGl; ZZZFK ! !7\"B Cmm'',G   MM    Z ,A77 B c(V^8dQhRRRRRRRR/#)rDrNr?rPrjrOrFrr-)rGs"r;rHrvs2 G G G%( G8B G  Gr:c VP;_uu_4Ve.VPPWV34pVe VuuRRR4#VPPWR34uuRRR4# +'giR#;i)zoReturn a recorded metadata fetch error, or ``None``. The artifact's own error wins, then a version-level one. N)ryrr)rrNrPrjrs&&&& r;get_metadata_error InMemoryIndex.get_metadata_errorseZZZ'--117\2RS$ Z ((,,g-EF ZZZs'A.A.. A? c(V^8dQhRRRRRRRR/#)rDrNr?rPrQrFrur-)rGs"r;rHrvs2 G G G%( G/2 G  Gr:c VP;_uu_4VPPWV34RRR4R# +'giR#;i)aMark the metadata fetch at ``url`` as one offline mode skipped. The skip writes the same empty slot a metadata-less artifact writes, so without the mark the two read alike. ``url`` keys it to one rung of the ladder: a rung skipped is no claim about an artifact a later rung read. N)ryrrrrNrPrQs&&&&r;record_offline_metadata_miss*InMemoryIndex.record_offline_metadata_misss2ZZZ  ) ) - -w.E FZZZs = A c(V^8dQhRRRRRRRR/#)rDrNr?rPrQrOrFrr-)rGs"r;rHrvs2LLL%(L/9L Lr:c VP;_uu_4WV3VP9uuRRR4# +'giR#;i)z:Whether the metadata fetch at ``url`` was skipped offline.N)ryrrs&&&&r;is_offline_metadata_miss&InMemoryIndex.is_offline_metadata_misss,ZZZc*d.K.KKZZZs 1 A c V^8dQhRRRR/#rr-)rGs"r;rHrvs  c d r:c VP;_uu_4WP9d RRR4R#VPPV4RRR4R# +'giR#;i)aWhether the caller owns ``package``'s one offline-skip warning. True for the first caller only. The targets of a run share this index but each builds its own :class:`~nab_python.provider.Provider`, so the state lives here to hold the report to one per package. NFT)ryrrrs&&r;claim_offline_metadata_warning,InMemoryIndex.claim_offline_metadata_warningsHZZZ777Z  ) ) - -g 6 ZZZsAA A( c(V^8dQhRRRRRRRR/#)rDrNr?rPrrOrFrur-)rGs"r;rHrvs,   %( 0:  r:c $RV RV 2pVP;_uu_4VPWR3VRR7VPPV4pRRR4Xe#W5nVP P 4R#R# +'giL8;i)aStore sdist-derived PKG-INFO in the version-level metadata slot. PKG-INFO is core-metadata-equivalent, so it stands for the version rather than for one artifact and answers a read that names no artifact. The pending key differs from a wheel's so an sdist request can run in parallel with (or after) a failed wheel metadata request. :meth:`metadata_from_sdist` reports which kind the version-level slot holds. sdist:rlNTr)ryrrrrerdr}rrNrPrrrs&&&& r;store_sdist_metadata"InMemoryIndex.store_sdist_metadatas}wiq * ZZZ  % %w&>QU % Vmm'',G  !N MM    Zs 2A?? B c(V^8dQhRRRRRRRR/#rDrNr?rPrrrFrur-)rGs"r;rHrv,   %( 1>  r:c RV RV 2pVP;_uu_4W0PWR3&VPPV4pRRR4XeVPP 4R#R# +'giL2;i)aRecord a failed sdist fetch and unblock the sdist waiter. Distinct from ``store_sdist_metadata(None)``: ``None`` means the archive yielded no PKG-INFO; an error means the archive could not be fetched or failed its published hash, so the resolve must abort rather than fall through. rrlN)ryrrrrdr}rrNrPrrrs&&&& r;store_sdist_metadata_error(InMemoryIndex.store_sdist_metadata_errorspwiq * ZZZ>C ! !7T": ;mm'',G   MM    Zs ,A33 B c$V^8dQhRRRRRR/#)rDrNr?rPrFrr-)rGs"r;rHrvs&CC3CCCr:c VP;_uu_4W3VP9uuRRR4# +'giR#;i)aReturn ``True`` when the version-level slot was written from an sdist. The slot itself cannot distinguish wheel METADATA from sdist PKG-INFO; readers that apply the :pep:`643` dynamic-deps gate only to sdist values ask here for the current text's origin. N)ryrrrNrPs&&&r;metadata_from_sdist!InMemoryIndex.metadata_from_sdists*ZZZ%)B)BBZZZs 0 A c ,V^8dQhRRRRRRRRRR/#)rDrNr?rProrrFrur-)rGs"r;rHrvs4   %( 58 @C  r:c ,\WV4pVP;_uu_4VPWV3VRR7VPP V4pRRR4Xe#WFnVP P4R#R# +'giL8;i)aStore range-recovered wheel METADATA in the wheel's own slot. The text is authoritative wheel METADATA, so it lands in the ``(package, version, wheel_url)`` slot with ``from_sdist=False`` and stays off the :pep:`643` dynamic-deps gate. Keying by the wheel URL, like the sidecar path, keeps sibling sidecar-less wheels of one version independent: a matrix target that picks one wheel never reads another wheel's dependencies. Firing the ``range:`` pending releases the provider thread blocked on rung 4. FrN)rqryrrrrerdr})rrNrProrrrs&&&&& r;store_range_metadata"InMemoryIndex.store_range_metadatas}95 ZZZ  % %9-t & mm'',G   !N MM     Zs 2B B c(V^8dQhRRRRRRRR/#)rDrNr?rProrFrur-)rGs"r;rHrv&s)   #      PT  r:c \WV4pVP;_uu_4VPPV4pRRR4XeVPP 4R#R# +'giL2;i)aQRelease a rung-4 waiter without writing a metadata slot. A range read that yielded no METADATA (ranges unsupported, no matching dist-info, an offline cold miss, a dead fetcher loop) is a rung miss, not an error: the pending fires so the provider reads ``None`` and steps to the sdist rung, which can still write the version-level slot. N)rqryrrrdr})rrNrProrrs&&&& r;store_range_absent InMemoryIndex.store_range_absent&sU95 ZZZmm'',G   MM    Zs A'' A7 c ,V^8dQhRRRRRRRRRR/#) rDrNr?rProrrrFrur-)rGs"r;rHrv4s4   %( 58 AN  r:c \WV4pVP;_uu_4W@PWV3&VPP V4pRRR4XeVP P 4R#R# +'giL2;i)aRecord a failed range read as a per-wheel error and unblock rung 4. Distinct from :meth:`store_range_absent`: a malformed-UTF-8 METADATA blob, or a wheel URL the index advertised and then could not serve, fails the resolve rather than falling through to the sdist, mirroring :meth:`store_metadata_error` for an advertised sidecar. The error lands in the ``(package, version, wheel_url)`` slot the provider reads for that wheel. The ``range:`` pending fires so the waiter unblocks. N)rqryrrrrdr})rrNrProrrrs&&&&& r;store_range_errorInMemoryIndex.store_range_error4sj95 ZZZCH ! !7Y"? @mm'',G   MM    Zrc ,V^8dQhRRRRRRRRRR/#) rDrNr?rProoutcomerrFrur-)rGs"r;rHrvGs;JJJ%(J58JCOJ Jr:c VP;_uu_4W@PWV3&RRR4R# +'giR#;i)zBRecord the mechanical outcome of a range read for tier accounting.N)ryr)rrNrPrors&&&&&r;store_range_outcome!InMemoryIndex.store_range_outcomeGs,ZZZBI 'I!> ?ZZZs 0 A c(V^8dQhRRRRRRRR/#)rDrNr?rProrFzRangeOutcome | Noner-)rGs"r;rHrvNs2KKK%(K58K Kr:c VP;_uu_4VPPWV34uuRRR4# +'giR#;i)z@Return the recorded range-read outcome, or ``None`` if none ran.N)ryrr)rrNrPros&&&&r;get_range_outcomeInMemoryIndex.get_range_outcomeNs2ZZZ''++Wy,IJZZZs = A c(V^8dQhRRRRRRRR/#)rDrNr?rPrrFrur-)rGs"r;rHrvUs( = =S =3 =c =d =r:c VP;_uu_4W0PW3&RRR4R# +'giR#;i)a]Store sdist-derived pyproject.toml text for static-metadata fallback. The fetcher writes both PKG-INFO and pyproject.toml when an sdist is downloaded. Provider code reads this slot when PKG-INFO marks dependencies as :pep:`643` Dynamic. No ``None`` slot is written: missing pyproject.toml is indistinguishable from never-fetched at the read path. N)ryr)rrNrPrs&&&&r;store_sdist_pyproject#InMemoryIndex.store_sdist_pyprojectUs*ZZZ8< ! !7"4 5ZZZ / A c$V^8dQhRRRRRR/#)rDrNr?rPrFrOr-)rGs"r;rHrvas&AA3AAAr:c VP;_uu_4VPPW34uuRRR4# +'giR#;i)zDReturn sdist pyproject.toml text or ``None`` if absent or unfetched.N)ryrrr s&&&r;get_sdist_pyproject!InMemoryIndex.get_sdist_pyprojectas. ZZZ((,,g-?@ZZZ < A c(V^8dQhRRRRRRRR/#)rDrNr?rPr bytes | NonerFrur-)rGs"r;rHrvfs,     %(  0<    r:c RV RV 2pVP;_uu_4W0PW3&VPPV4pRRR4Xe#W5nVP P 4R#R# +'giL8;i)z;Cache sdist archive bytes (or ``None`` for a failed fetch).sdist-archive:rlN)ryrrrrerdr}rs&&&& r;store_sdist_archive!InMemoryIndex.store_sdist_archivefsswiq 2 ZZZ7; '!3 4mm'',G  !N MM    Zs +A88 B c$V^8dQhRRRRRR/#)rDrNr?rPrFr/r-)rGs"r;rHrvrs&@@@s@|@r:c VP;_uu_4VPPW34uuRRR4# +'giR#;i)zCReturn cached sdist archive bytes, or ``None`` if absent or failed.N)ryrrr s&&&r;get_sdist_archiveInMemoryIndex.get_sdist_archivers. ZZZ''++W,>?ZZZr-c(V^8dQhRRRRRRRR/#rr-)rGs"r;rHrvwrr:c RV RV 2pVP;_uu_4W0PW3&VPPV4pRRR4XeVPP 4R#R# +'giL2;i)aRecord a failed sdist-archive fetch and unblock the waiter. Kept in its own slot rather than ``store_sdist_archive(None)`` so the ``BUILD_REMOTE`` path can tell an archive the index never offered (skip the version) from one it advertised and then failed to serve (abort the resolve). r1rlN)ryrrrrdr}rs&&&& r;store_sdist_archive_error'InMemoryIndex.store_sdist_archive_errorwsnwiq 2 ZZZ=B & &'9 :mm'',G   MM    Zs +A22 B c$V^8dQhRRRRRR/#)rDrNr?rPrFrr-)rGs"r;rHrvs)FFF%(F Fr:c VP;_uu_4VPPW34uuRRR4# +'giR#;i)z9Return a recorded sdist-archive fetch error, or ``None``.N)ryrrr s&&&r;get_sdist_archive_error%InMemoryIndex.get_sdist_archive_errors0ZZZ--1172DEZZZr-c V^8dQhRRRR/#)rDrr?rFztuple[_Pending, bool]r-)rGs"r;rHrvs"""1F"r:c VP;_uu_4WP9d VPV,R3uuRRR4#\4pW PV&VR3uuRRR4# +'giR#;i)z"Return (pending, already_existed).TNF)ryrra)rrrs&& r;get_or_create_pending#InMemoryIndex.get_or_create_pendingsU ZZZmm#}}S)4/ZjG!(MM# E> ZZZs%A+A++ A< c(V^8dQhRRRRRRRR/#)rDrNr?rP source_textrF Any | Noner-)rGs"r;rHrvs,%(7: r:c VP;_uu_4VPPW34pVeV^,V8wd RRR4R#V^,uuRRR4# +'giR#;i)aReturn the cached parse of ``source_text``, or ``None``. Unlike :meth:`get_metadata` (which returns the raw text), this returns the already-parsed dataclass. A parse of any other text is a miss: wheel METADATA and sdist PKG-INFO share one ``(package, version)`` slot and either can replace the other mid-resolve, so a hit on the key alone could hand back the deps of the artifact the caller is not holding. N)ryrr)rrNrPrErJs&&&& r;get_parsed_metadata!InMemoryIndex.get_parsed_metadatasUZZZ))--w.@AE}aK 7Z8 ZZZs0A"A"" A3 c ,V^8dQhRRRRRRRRRR/#) rDrNr?rPr+rrErFrur-)rGs"r;rHrvs; P P P%( P47 PFI P  Pr:c VP;_uu_4WC3VPW3&RRR4R# +'giR#;i)zCache the parse of ``source_text`` for future tuple lookups. Safe across tuples because the parsed object is read-only and a pure function of ``source_text``. Per-tuple classification (marker eval, extras admission) happens above this cache. N)ryr)rrNrPr+rEs&&&&&r;store_parsed_metadata#InMemoryIndex.store_parsed_metadatas/ZZZ9D8OD ! !7"4 5ZZZs 1 A c$V^8dQhRRRRRR/#)rDrNr?rPrFrFr-)rGs"r;rHrvs& I I3 I I Ir:c VP;_uu_4VPPW34uuRRR4# +'giR#;i)aReturn cached post-reconciliation sdist metadata or ``None``. The cached value is the result of :func:`nab_python._provider.metadata_resolver.resolve_dynamic_sdist`: either a :pep:`621` pyproject augmentation or a PEP 517 backend invocation. Both branches are deterministic functions of the sdist content under nab's build inputs, so the value is shared across universal-mode tuples to avoid duplicate work. N)ryrrr s&&&r;get_resolved_sdist_metadata)InMemoryIndex.get_resolved_sdist_metadatas0ZZZ0044g5GHZZZr-c(V^8dQhRRRRRRRR/#)rDrNr?rPr+rrFrur-)rGs"r;rHrvs2III%(I47I Ir:c VP;_uu_4W0PW3&RRR4R# +'giR#;i)z6Cache reconciled sdist metadata for cross-tuple reuse.N)ryr)rrNrPr+s&&&&r;store_resolved_sdist_metadata+InMemoryIndex.store_resolved_sdist_metadatas*ZZZ@H ) )7*< =ZZZr()r{r|rzryrrrr~rrrrrrrrrrN)-r.r/r0r1r2rrrrrrrrrrrrrrrrrrrrrrr rrrrr"r&r+r2r6r:r>rBrHrLrPrTr9r-r:r;r#r#s 0Gd/  #  !&  >; =  5 8 6 P.J( G$. 2 * G GL  ( "C .   &JK =A  @  "F"$ P IIIr:cL]tRtRtRt^ tRRR^2RRRRRR R RR RR R/R Rllt]RRl4tRRlt RRlt ]RRl4t ]RRl4t RRlt RRltRRltRR ltR!R"ltR#R$ltR%R&ltR'R(ltR)R*ltR+R /R,R-lltR]R.R/lltR^R0R1lltR^R2R3lltR^R4R5lltR6R7ltR8R9ltR:R;ltR<R=ltR>R?ltR@RAlt RBRClt!RDRElt"RFRGlt#RHRIlt$RJRKlt%RLRMlt&RNROlt'RPRQlt(RRRSlt)RTRUlt*RVRWlt+RXRYlt,RZR[lt-R\t.R#)_r iaBridges the sync provider and the async fetcher. Cross-thread communication uses an ``asyncio.Queue`` that lives in the fetcher thread's event loop. Sync callers schedule puts on the loop via ``loop.call_soon_threadsafe``. Batch submissions (lists) guarantee all items arrive together for concurrent processing. Use as a context manager: with FetchCoordinator(transport) as coordinator: ... indexesNmax_concurrency cache_dir cache_backendofflineF index_routesindex_cache_floorson_fetchc@V^8dQhRRRRRRRRR R R R R RRRRRRR/ #)rD transportr(rXzlist[IndexConfig] | NonerYrXrZz Path | Noner[zCacheBackend | Noner\rr]zlist[IndexRoute] | Noner^zMapping[str, int] | Noner_zCallable[[], None] | NonerFrur-)rGs"r;rHFetchCoordinator.__annotate__szn.n.%n.* n.  n.  n.+n.n..n.5n.,n. n.r:c Vf\\\4.pV'gRp \V 4hVU u.uFqPNK p p \ V 4\ \ V 448wdC\V U u0uFqPV 4^8gKV kK up 4pRV 2p \V 4h\V4Vn Wn W0n W`n Ve\ V4^8dRp \V 4hVeH\;QJdRV4F 'gK RM RM !RV44'dRp \V 4hVeWPnMHVe6\!WB^,P"V^,P$R 7VnM\'4VnW@n\T;'g.4Vn\-T;'g/4Vn\ VP4^8H;'dgVP*'*;'dN\1VP^,P"4'*;'d\3VP\ 4VnWn\94Vn\=4Vn\A4Vn!\E4Vn#\HVn%RVn&RVn'RVn(RVn)RVn*RVn+\XPZ!4Vn.R#uup iuup i) a,Create a coordinator that wraps ``transport``. ``indexes`` is the ordered list of :class:`IndexConfig` records; order is significant (presence-based first-index walks them left-to-right). When omitted, defaults to ``[IndexConfig("pypi", "https://pypi.org/simple/")]``. Each index name must be unique across the list. ``index_routes`` adds per-package routing rules; an entry's ``index`` field names one of the configured indexes and pins that package's listing fetch to it. ``index_cache_floors`` maps an index name to a read-time freshness floor in seconds, passed to that index's cached client as ``min_fresh_seconds``. Indexes absent from the map, and the ``file://`` local client, get no floor. ``cache_backend`` wins over ``cache_dir`` if both are given; otherwise ``cache_dir`` enables a per-index :class:`OnDiskCache` and ``None`` falls back to a :class:`NullCache`. Passing an explicit ``cache_backend`` together with more than one entry in ``indexes``, or with an index that pins its ``serialization``, is rejected: each of those needs its own cache. Nz-indexes must contain at least one IndexConfigzduplicate index names: zqexplicit cache_backend is incompatible with more than one index: pass cache_dir so each index gets its own cache.c3X"TF qP\PJxK" R#5irV) serializationr NEGOTIATE).0idxs& r; ,FetchCoordinator.__init__..s#- NUs  %8%B%B Bgs(*TFzexplicit cache_backend is incompatible with a pinned serialization: pass cache_dir so the pinned index gets a cache of its own.re)/rDEFAULT_INDEX_NAMEDEFAULT_INDEX_URL ValueErrorr@lenr}sortedcountrrX _transport_max_concurrency_offlineany_cacher rQrer _cache_dir _index_routesdict_index_cache_floorsr isinstance_sync_listing_enabled _on_fetchr#rAr _range_memor_parsed_cache_statsr%_warm_sync_stats_WARM_SYNC_MIN_BLOB_BYTES_warm_sync_min_blob_bytes_thread_started_crashed _crash_error_loop_async_qrfrg _queue_ready)rrarXrYrZr[r\r]r^r_msgrhnamesn duplicatess&&$$$$$$$$ r;rFetchCoordinator.__init__sJ ?"#57HIJGACS/ !%,-WcW- u:SZ (E HEq[[^a5GE HIJ+J<8CS/ !G} # /  $W)9K S/ !  $- NU- - NU- * * %  S/ !  $(5K  "&1:>>9Q9QDK$+DK#!,"4"4"5#'(:(@(@b#A   " 5 5&&& 5 5 Q 3 344 5 54;; 4 """_ /0$4#5 -)B&04   267; :> %OO-I. HsK&4K+K+cV^8dQhRR/#)rDrFrr-)rGs"r;rHrbPsr:c VP#)z>    r:cV^8dQhRR/#rtr-)rGs"r;rHrbzs " "$ "r:c VPfR#VPR4VPP\R7RVnRVnRVnRVnVPP4R#)z.Signal the fetcher thread to exit and join it.N)timeoutF) r_submitjoin!_COORDINATOR_JOIN_TIMEOUT_SECONDSrrrrclearrs&r;rFetchCoordinator.shutdownzsa <<   T "CD     !r:c V^8dQhRRRR/#rDitem _QueueItemrFrur-)rGs"r;rHrbsJ4r:c VPpVPpVeVfVPV4R#VPVPV4R# \ dTPT4R#i;i)zSchedule ``item`` on the fetcher loop's queue from any thread. Requests the loop cannot take are recorded as failures so their waiters unblock instead of hanging. N)rr_refusecall_soon_threadsafe put_nowait RuntimeError)rrloopqueues&& r;rFetchCoordinator._submitsd zz  <5= LL     % %e&6&6 =  LL  sAA32A3c$V^8dQhRRRRRR/#)rDcallbackzCallable[..., object]rrrFrr-)rGs"r;rHrbs"&;Ftr:c xVPpVfR#VP!V.VO5!R# \dR#i;i)zHand ``callback`` to the fetcher loop from any thread. Returns ``False`` when there is no live loop (never started, or closed between the read and the post) so the caller can run the work inline. FT)rrr)rrrrs&&* r; _post_to_loopFetchCoordinator._post_to_loopsF zz <   % %h 6 6  s * 99c V^8dQhRRRR/#rr-)rGs"r;rHrbsVVJV4Vr:c VfR#\V\4'dTMV.pVEFp\R4pVP\P Jd)VP PVPV4KUVPfQhVP\PJd>VP PVPVPWCP4KVP\PJdOVPfQhVP PVPVPVP4EK,VP\PJd5VP P!VPVPV4EK~VP P#VPVPV4EK R#)zBRecord a failure for each request in ``item``, unblocking waiters.Nz,Fetcher loop is not running, request refused)r{rrrMr!r3rArrNrPr4rrQr5rr6rr:)rrrequestsreqrs&& r;rFetchCoordinator._refuses? < %dD114vC !OPExx9,,, ..s{{EB;;* **xx9--- //KKeWWY555ww*** --ckk3;;PY__, 55ckk3;;PUV 44S[[#++uU%r:c V^8dQhRRRR/#)rDrrrFrur-)rGs"r;rHrbs=Tr:c WnRVnR#)z2Record the failure that killed the fetcher thread.TN)rr)rrs&&r; _record_crashFetchCoordinator._record_crashs! r:cV^8dQhRR/#rtr-)rGs"r;rHrbs  d r:c ^VP'gR#RVP 2p\V4h)NzFetcher thread crashed: )rrr)rrs& r; _check_aliveFetchCoordinator._check_alives,}}} ():):(;<3r:c V^8dQhRRRR/#rr-)rGs"r;rHrbs1Sr:c VPpVP'gV;P^, unR#\VPWP R7pVeV#VPP V4pVfV;P^, unR#VP4'g.VP 'gV;P^, un R#V;P^, un R#)a Read a fresh parsed listing on the caller's thread, or ``None``. ``read_fresh_parsed_listing`` never raises, so the caller's pending is never stranded. On a decline the policy is re-read to attribute a reason counter rather than threading it out of the pure helper. Nr\) rr|r[rrvrtget_simple_policyr\is_freshr]r^)rrNstatsrecordspolicys&& r;_try_listing_sync"FetchCoordinator._try_listing_syncs%%)))  % % * %+DKK--X  N..w7 >  $ $ ) $  //##t}}}  ' '1 , '  " "a ' "r:c V^8dQhRRRR/#rr-)rGs"r;rHrbs 6 6C 6D 6r:c VP'gR#VPPV4pVfR#W P8#)aWhether a warm listing may be served inline, or must go async. A parsed blob below ``_WARM_SYNC_MIN_BLOB_BYTES`` declines to the async path. A blob whose size cannot be stat'd, or a run where the sync path is disabled, is admitted and left to ``_try_listing_sync`` to classify. T)r|rvget_simple_parsed_sizer)rrNsizes&& r;_overlap_gate_admits%FetchCoordinator._overlap_gate_admitss>))){{11': <5555r: speculativec$V^8dQhRRRRRR/#)rDrNr?rrrFrcr-)rGs"r;rHrbs$))),0) )r:c VP4VPPV4e(\P!4pVP 4V#RV 2pVPP V4wrVV'd VP#V'Eg'VPV4'dVPV4pVeVPPWP^,P4VPPW4VP;P^, unVP!VP"W4'gVP#W4VP#M#VP;P$^, unVP;P&^, unVP)\+\,P.VR74VP#)a=Request a listing fetch; return an event set when the result lands. The single-flight pending is claimed first: an existing pending means another party owns fulfillment, so its event is joined and the cache is never probed. Only the pending's creator probes; a fresh parsed hit is served inline, and every other outcome declines to the async fetch, which owns every cache write and self-heal. ``speculative`` callers skip the sync probe and dispatch async, so their read work overlaps resolver CPU on the fetcher thread; only blocking critical-path callers serve inline. r)rMrN)rrArrfrgr}rBrdrrrrXr@rrrYr_run_listing_tailr_rZrr"r!r3)rrNrdonerrexistedrs&&$ r;request_listing FetchCoordinator.request_listingso  :: ! !' * 6??$D HHJK "::;;C@ == {((11009&JJ227LLO))66!;6--d.D.DgWW..w@"==('%%99Q>9  ! ! 2 2a 7 2 \y'8'8'JK}}r:c ,V^8dQhRRRRRRRRRR/#) rDrNr?rPrQrSrRrFrcr-)rGs"r;rHrbs<  .   r:c  VP4VPPWV4'd(\P!4pVP 4V#\ WV4pVPPV4wrxV'g.VP\\PVVVVR74VP#)zJRequest the sidecar at ``url`` as the metadata for ``(package, version)``.rMrNrPrQrS) rrArrfrgr}rmrBrr"r!r4rd) rrNrPrQrSrrrrs &&&&& r;request_metadata!FetchCoordinator.request_metadatas  :: " "7S 9 9??$D HHJKGc2::;;C@ LL"++##"/  }}r:c ,V^8dQhRRRRRRRRRR/#) rDrNr?rProrVrTrFrcr-)rGs"r;rHrb:s<  2   r:c  VP4\WV4pVPPV4wrgV'g.VP \ \ PVVVVR74VP#)afRequest a sidecar-less wheel's METADATA over an HTTP range read. This is rung 4: the ``range:`` pending key is per ``(package, version, wheel_url)``, so two provider threads asking for the same wheel enqueue a single read, while sibling sidecar-less wheels of one version (which a matrix picks per target and which can declare different dependencies) each get their own read, matching the sidecar path. A warm cache hit is served inside the client, so there is no early cache check here. ``wheel_hashes`` are the wheel's published digests; a full-body read is verified against them before its METADATA is used. )rMrNrPrQrV) rrqrArBrr"r!r5rd)rrNrProrVrrrs&&&&& r;request_range_metadata'FetchCoordinator.request_range_metadata:sk$ 95::;;C@ LL"11##!!-  }}r:c ,V^8dQhRRRRRRRRRR/# rDrNr?rPrQrUrTrFrcr-)rGs"r;rHrb[s<  2   r:c  VP4RV RV 2pVPPV4wrgV'g.VP\ \ P VVVVR74VP#)aRequest sdist PKG-INFO extraction. Uses a separate ``sdist:`` pending key so it can fire even when a prior wheel metadata fetch already cached ``None`` for the same ``(package, version)`` slot. The fetcher verifies the downloaded archive against ``sdist_hashes`` before extraction. rrlrMrNrPrQrU)rrArBrr"r!r6rdrrNrPrQrUrrrs&&&&& r; request_sdistFetchCoordinator.request_sdist[so wiq *::;;C@ LL"##!-  }}r:c ,V^8dQhRRRRRRRRRR/#rr-)rGs"r;rHrbxs<  2   r:c  VP4RV RV 2pVPPV4wrgV'g.VP\ \ P VVVVR74VP#)aRequest the raw bytes of an sdist archive. Used by the :class:`~nab_python.provider.BuildPolicy.BUILD_REMOTE` path; the bytes are extracted to a temp dir and handed to a PEP 517 backend. Stored under a separate pending key so it can run concurrently with a PKG-INFO fetch for the same version. The fetcher verifies the downloaded archive against ``sdist_hashes`` before storing the bytes. r1rlr)rrArBrr"r!r7rdrs&&&&& r;request_sdist_archive&FetchCoordinator.request_sdist_archivexsq wiq 2::;;C@ LL"00##!-  }}r:c(V^8dQhRRRRRRRR/#)rDrNr?rPrQrFrcr-)rGs"r;rHrbs2   r:c  VP4RV RV 2pVPPV4wrVV'g-VP\ \ P VVVR74VP#)aJRequest the bytes of an archive named by URL rather than by an index. Used by ``[[tool.nab.archive-sources]]``, whose URL is declared independently of every index, so the URL's own scheme decides how it is read. The bytes land unverified in the same slot as :meth:`request_sdist_archive`; the caller checks the declared hashes. r1rl)rMrNrPrQ)rrArBrr"r!r8rd)rrNrPrQrrrs&&&& r;request_direct_archive'FetchCoordinator.request_direct_archivesn wiq 2::;;C@ LL"11##  }}r:c V^8dQhRRRR/#)rDitemsz2list[tuple[str, str, str, tuple[str, str] | None]]rFz&list[tuple[str, str, threading.Event]]r-)rGs"r;rHrbs!!G! /!r:c  &VP4.p.pVFwrErgVPPWEV4'd;\P!4pVP 4VP WEV34Kb\WEV4p VPPV 4wrV 'g.VP \\PVVVVR74VP WEV P34K V'dVPV4V#)zSubmit a batch of metadata requests as a single queue item. Each item is ``(package, version, url, metadata_hash)``. All requests in the batch reach the fetcher together so they are processed concurrently. r)rrArrfrgr}appendrmrBr"r!r4rdr) rrresultsbatchrNrPrQrSrrrrs && r;request_metadata_batch'FetchCoordinator.request_metadata_batchs :<$&49 0Gczz&&w== ( $78#6C#zz??D G  &// ' '&3  NNGgmm< =%5:&  LL r:cV^8dQhRR/#rtr-)rGs"r;rHrbs4r:c \P!VP44R# \dIpTP T4\ P R4\T\4'ghRp?R#Rp?ii;i)zFetcher thread crashedN) asynciorun_async_fetcherrrlogger exceptionr{ Exception)rexcs& r;rFetchCoordinator._run_loops^  KK++- .    s #   5 6c9--.  s$( A;=A66A;cV^8dQhRR/#)rDrF=CachedAsyncSimpleClient | LocalIndexClient | MultiIndexClientr-)rGs"r;rHrbs  F r:c \VP4p\VP4^8Xd+V'g#VP VP^,4#/pVPF pVP V4W#P &K" VPUu.uFq3P NK pp\ VVV4#uupi)aEReturn the index client for this run. Single-index configurations return a plain :class:`CachedAsyncSimpleClient` (or a :class:`LocalIndexClient` for a ``file:`` URL). Multi-index configurations wire up a :class:`MultiIndexClient` whose underlying clients share the coordinator's transport but get their own per-URL cache. )rKrxrorX_build_index_clientr@r)r override_mapclients_by_namecfgorders& r; _build_clientFetchCoordinator._build_clients't'9'9: t||  !,++DLLO< i;iLLLn TP-4GRjxL TP.P-4GRjxL i;i5i)NFTreturn_exceptions)rr~rrrQueue Semaphorersr}rget_running_looprrrrrr _dispatchempty get_nowait QueueEmptygatheracloserr) rrsemtasksclientrstoppingrextras & r;rFetchCoordinator._async_fetchers/0$4#5 +2==? 5 56#&5 $'')F 113DJ!M    ! ! # +H"YY[(<tS8 ++-- % 0 0 2}$(NN5#=nneDtDDD--/ ! !//((* * *M    s #      ! ! # )#--E ! + --/ ! !//((* * *sAH8!0F H8- G77G7 G .G7?G#G73G7 G1 G7H8$G3%!H8G5H8 F/F**F//F22GH8G7G.)G7-G..G73H85H87H5 H "H5.H1/H55H8c ,V^8dQhRRRRRRRRR R /#) rDrz!FetchRequest | list[FetchRequest]r5rr3asyncio.Semaphorer4zset[asyncio.Task]rFrur-)rGs"r;rHrbQs=22/2N2 2 ! 2  2r:c \V\4'd^VFUp\P!VP W%V44pVP V4VP VP4KW R#\P!VP W!V44pVP V4VP VP4R#)z3Create async tasks for a single request or a batch.N)r{rr create_task_handleradd_done_callbackr)rrr5r3r4rtasks&&&&& r;r-FetchCoordinator._dispatchQs dD ! !**4<<S+IJ $&&u}}5 &&t||F#'FGD IIdO  " "5== 1r:c(V^8dQhRRRRRRRR/#) rDr5rrr"r3r:rFrur-)rGs"r;rHrbcs2==M== =  =r:c "T;_uu_4GRjxL VP\PJdVPW4GRjxL MVP\PJdVP W4GRjxL MVP\P JdVPW4GRjxL MVP\PJdVPW4GRjxL MRVP\PJdVPW4GRjxL MVPV4GRjxL RRR4GRjxL R#ELJELLLLsL=L% \dSp\PRTPP TP"T4TP%YT4Rp?LzRp?i\&dSp\P)RTPP TP"T4TP%YT4Rp?LRp?ii;iL +GRjxL 'giR#;i5i)NzFetch failed: %s %s: %s)rMr!r3_fetch_listingr4_fetch_metadatar6 _fetch_sdistr7_fetch_sdist_archiver5_fetch_range_metadata_fetch_direct_archiver rdebugvaluerN_record_fetch_failurerwarning)rr5rr3rs&&&& r;r=FetchCoordinator._handlecs 33 =88y000--f:::XX!3!33..v;;;XX0++F888XX!8!8833F@@@XX!9!9944VAAA44S99933;;8@A9 = -sxx~~s{{C**6<< =-sxx~~s{{C**6<<  =)333s5IEIH(2E+ E E+H(2E+E!E+H(2E+9E#:E+>H(?2E+1E%2E+6H(72E+)E'*E+.H(/E+E)E+H( IH&IE+!E+#E+%E+'E+)E++ H#6AG>H( H#H#AHH(H##H(&I(I .H1/ I :I < Ic(V^8dQhRRRRRRRR/#) rDr5rrr"rrrFrur-)rGs"r;rHrbs8BBMBB B  Br:c \V\4pVP\PJdV'dFVP WP 4VPPVP .RR7R#VPPVP 4f'VPPVP V4R#VPfQhVPW#VR7R#)aCRecord a failed fetch so any waiter unblocks (else a deadlock). Offline with a cold cache is the one deliberate degradation: the artifact is recorded absent and the resolver works with what the cache holds. Any other failure is recorded as an error, because a file the listing advertised and the index then failed to serve is not the same as a file that does not exist. A listing that is already stored keeps it: the fetch succeeded, and the work that raised ran after the waiter woke, so recording an error would make the outcome depend on which thread reads the index first. T)rNr) r{r rMr!r3_record_serving_indexrNrArrrrP_record_versioned_failure)rr5rrr\s&&&& r;rK&FetchCoordinator._record_fetch_failures$S,/ 88y(( (**6;;? ((bt(L '' 4< ..s{{C@ {{&&& &&s&Ar:c(V^8dQhRRRRRRRR/#) rDrr"rrr\rrFrur-)rGs"r;rHrbs23P3P3P&/3P=A3P 3Pr:c VPfQhVP\PJdV'dVPfQhVP P VPVPVP4VP PVPVPRVP4R#VP PVPVPW!P4R#VP\PJdVPfQhV'dyVP P VPVPVP4VP PVPVPVP4R#VP PVPVPVPV4R#VP\PJdV'dVPfQhVP P VPVPVP4VP PVPVPR4R#VP PVPVPV4R#V'dRVP\P Jd4VP P#VPVPR4R#VP P%VPVPV4R#)anRecord the failure of a version-scoped fetch, unblocking its waiter. Offline is the one deliberate degradation: the artifact is recorded absent so the resolver works with what the cache holds. Any other failure is recorded as an error, because a file the listing advertised and the index then failed to serve is not one that does not exist. A declared archive is the exception: it is the package's only candidate, so there is nothing to degrade to and an offline miss is recorded as an error. A metadata rung marks the skip before it stores, so a waiter released by the store reads the mark and not a bare empty slot. N)rPrMr!r4rQrArrNrrr5rrr6rrr7r2r:)rrrr\s&&&$r;rQ*FetchCoordinator._record_versioned_failures"{{&&& 88y)) )ww*** 77KKcgg ))#++s{{D#''R // S[[#wwW XX11 177& && 77KKcgg --ckk3;;P ,,S[[#++swwPST XX (ww*** 77KKcgg // S[[$O 55ckk3;;PST Y%<%<< JJ * *3;; T J JJ 0 0ckk3 Or:c$V^8dQhRRRRRR/#rDr5rrr"rFrur-)rGs"r;rHrbs-BBMBB  Br:c "VPVP4GRjxL pVPWP4VPP VPVVP VP4R7\ PRVP\V44VPeVP4VPVPV4R#L5i)N)rzfetched listing: %s (%d files)) get_filesrNrPrArserved_unreadable_onlyrrIror} _prefetch_metadata_after_listing)rr5rfiless&&& r;rCFetchCoordinator._fetch_listings &&s{{33 ""6;;7   KK "99#++F !  5s{{CJO >> % NN  --ckk5A4sC*C(CC*c$V^8dQhRRRRRR/#)rDrNr?r\rrFrur-)rGs"r;rHrbs)LLL#BL Lr:c |/pVFKp\V\4'gKVP'gK/VPVPV4KM \ VP 44VP)RpVF;pVPpVfQhVPWPWvP4K= R#)zEnqueue metadata for the newest candidates of a stored listing. Files are oldest-first. One wheel per version: the first with a sidecar is the one the provider picks for that version's metadata. N) r{rr setdefaultrPrvaluesPREFETCH_METADATA_COUNTrjrrS)rrNr\ first_wheelfnewestwrQs&&& r;r[1FetchCoordinator._prefetch_metadata_after_listings-/ A!Y''ANNN&&qyy!4k((*+T-I-I,I,KLA..C? "?  ! !'99c?? Kr:c$V^8dQhRRRRRR/#)rDrNr?rrrFrur-)rGs"r;rHrbs)QQQ%DQ Qr:c VPeVP4VPW4R# \d"p\P RY4Rp?R#Rp?ii;i)aRun the post-listing tail on the fetcher loop: tick then prefetch. Mirrors the tail of the async ``_fetch_listing``. A failure is swallowed rather than turned into a listing error: the pending has already fired, so the served listing must not be overwritten. Nz$listing prefetch tail failed: %s: %s)r}r[rrrL)rrNrrs&&& r;r"FetchCoordinator._run_listing_tailsN Q~~)  1 1' C Q NNA7 P P Qs/3 AAAc$V^8dQhRRRRRR/#)rDr5rrNr?rFrur-)rGs"r;rHrbs(66M66  6r:c \V\4'd6VPV4pVeTMVP^,PpMVP^,PpVP P W$4R#)adRecord which configured index served ``package``'s listing. Single-client configurations always serve from the lone configured index. Multi-client configurations consult the router's per-package route cache; an empty cache (e.g. an index returned no listing on every walk) falls back to the first configured index name so consumers always see something. N)r{r route_forrXr@rAr)rr5rNroutedr@s&&& r;rP&FetchCoordinator._record_serving_indexsa f. / /%%g.F#/6T\\!_5I5ID<<?''D &&w5r:c$V^8dQhRRRRRR/#rWr-)rGs"r;rHrb&s- J JM J J  Jr:c "VPfQhVPf4VPPVPVPR4R#VP VPVPVPVP 4GRjxL pVPPVPVPW2P4\PRVPVP4R#Ll5i)Nzfetched metadata: %s %s) rPrQrArrNget_metadata_textrSrrI)rr5rrs&&& r;rD FetchCoordinator._fetch_metadata&s {{&&& 77? JJ % %ckk3;; E -- KKcggs/@/@   !!#++s{{D''J . S[[I  sBDDA-Dc$V^8dQhRRRRRR/#rWr-)rGs"r;rHrb5s($ $ M$ $   $ r:c 0"VPfQhVPfQhVPVPVPVP\ VP4VP 4GRjxL pVP PVPVPVPVP4VPf=VP PVPVPVP4MFVP PVPVPVPVP4\PRVPVPVPP4R#EL5i)aRecover a sidecar-less wheel's METADATA over an HTTP range read. A read that returns text stores it in the wheel's own slot; a read that returns none (ranges unsupported, no METADATA member) records the outcome and fires the waiter with no slot, so the provider steps to the sdist rung. A malformed blob or an unserveable wheel URL raises out of the client and is caught by :meth:`_handle` as a fetch failure. Nzrange metadata: %s %s (%s))rPrQget_range_metadatarNcanonicalize_name_boundaryrVrArrrrrrrIrJ)rr5rres&&& r;rG&FetchCoordinator._fetch_range_metadata5s{{&&&ww"""00 KK KK GG &s{{ 3       && KKcggv~~  ;;  JJ ) )#++s{{CGG L JJ + + S[[#''6;;   ( KK KK NN  ! sA4F6F7DFc$V^8dQhRRRRRR/#rWr-)rGs"r;rHrb[s-LLMLL  Lr:c "VPfQhVPfQhVPVPVPVPVP4GRjxL wr4Ve2VP P VPVPV4VP PVPVPV4R#Ln5irV)rPrQget_sdist_filesrNrUrAr&r)rr5rpkg_info pyprojects&&& r;rEFetchCoordinator._fetch_sdist[s {{&&&ww"""$*$:$: KKcggs/?/?%    JJ , ,S[[#++y Q '' S[[(K sA C"C#A/Cc$V^8dQhRRRRRR/#rWr-)rGs"r;rHrbls- G GM G G  Gr:c "VPfQhVPf4VPPVPVPR4R#VP VPVPVPVP 4GRjxL pVPPVPVPV4R#L75irV)rPrQrAr2rNr6rU)rr5rrs&&& r;rF%FetchCoordinator._fetch_sdist_archivels {{&&& 77? JJ * *3;; T J -- KKcggs/?/?   &&s{{CKKF sBC C 8C c V^8dQhRRRR/#)rDrr"rFrur-)rGs"r;rHrbzsGG|GGr:c F"VPfQhVPfQh\VP4PR8Xd%\ VP4P 4pMVP 'dRVP R2p\V4hVPPVP\R7GRjxL p\WAP4VPpVPPVPVPV4R#LX5i)z:Read an archive declared by URL, by that URL's own scheme.Nfilez+archive fetch unavailable in offline mode ())headers)rPrQrschemer read_bytesrtr rrrrrcontentrAr2rN)rrrrresponses&& r;rH&FetchCoordinator._fetch_direct_archivezs{{&&&ww""" CGG  # #v -!#''*557D}}}CCGG9AN"3''!__00BR0SSH Hgg .##D &&s{{CKKF TsA:D!=A D!DAD!)rrvrwrrrzrxrrsrtr}rrr~rr|rrrrrrArXrV)r-)/r.r/r0r1r2rbrpropertyr\rrrrrrrrrrrrrrrrrrrr rrrrr-r=rKrQrCr[rrPrDrGrErFrHr9r-r:r;r r sz !n.-1 n. " n. "& n..2n.n.15n.8<n./3n.` ((%% ! "" V6  . 6)38)V6B:>6!F 0  D6+p2$=@BB3PjB*L&Q 6* J$ LL" GGGr:)rlrmr r!r"r#r$r%i)Lr2 __future__rrenumloggingrf dataclassesrrtypingrr urllib.parserpackaging.utilsrrwnab_index.cacher r r r nab_index.cached_clientr rrnab_index.clientrrnab_index.lazy_wheelrrnab_index.local_indexrrrnab_index.multi_indexrrnab_index.serializationrnab_index.transportrr_vendor.packaging.utilscollections.abcrrrtyping_extensionsr__all__rlrmrrpathlibr'r( getLoggerr.rEnumr!r$rKr"r%rarmrqr#rrr r-r:r;rs` # (%!KNN 2BOO?7A6;;& .%'! &6   8 $& & $d#  $ L $d# 3 3$ 3 !! !&   :4]I]IBD. . 5 zGzGr: