+ 4j:{Rt^RIHt^RIt^RIt^RIt^RIt^RIt^RIH t H t ^RI H t ^RI Ht^RIHt^RIHtHtHt^RIHtHtHtHtHtHtHtHtHtHtH t H!t!H"t"^R I#H$t$H%t%H&t&H't'^R I(H)t*^R I(H+t,^R I(H-t.^R I/H0t0H1t1^RI2H3t3H4t4]'d^RI5H6t6^RI7H8t8^RI2H9t9H:t:.R0Ot;]Px!]=4t>] !RR7!RR44t?Rt@RtA]P!R]P4tD]P!R4tER1tF]G!]H!]F44tIRRltJRRltKRR ltLR!R"ltMR#R$ltNR%R&ltOR'R(ltPR)R*ltQR+R,ltRR-R.ltS!R/R4tTR#)2aDisk-cached PyPI Simple API client. Drives an :class:`~nab_index.transport.AsyncHttpTransport` and consults a :class:`~nab_index.cache.CacheBackend` before any HTTP call. Honors a small subset of RFC 9111: fresh entries are served directly, stale entries are revalidated with ``If-None-Match``, and PEP 658 metadata + sdist PKG-INFO are treated as immutable (cached forever; never revalidated). ) annotationsN) dataclassreplace)timezone)parsedate_to_datetime) TYPE_CHECKING) CacheBackend CachePolicy OfflineError) _HTTP_NOT_FOUND DEFAULT_INDEXMalformedSimpleResponseError SdistFile WheelFile_extract_sdist_files_header _listing_body _parse_files_select_artifact_hash_verify_metadata_hashholds_unreadable_formatverify_sdist_hash)RangeCapabilityMemoRangeMetadataResult RangeOutcomeread_wheel_metadata_over_range)corruption_reason)decode)encode)SimpleSerializationsimple_accept_header)IDENTITY_HEADERSraise_unless_ok)NormalizedName)Self)AsyncHttpTransport HttpResponseCachedAsyncSimpleClientParsedCacheStatsT)slotscF]tRt^Gt$Rt^tR]R&^tR]R&^tR]R&Rt R#)r(acMutable counters for parsed-listing cache outcomes on the fetcher thread. One instance is shared across every per-index client in a run and read once after it, so a benchmark can confirm a warm resolve serves parsed blobs rather than reparsing. Each fresh-or-offline consult of ``get_files`` bumps exactly one counter: ``hit`` when a present blob binds the policy's body and is served without reading the raw body; ``miss`` when no blob was present; ``rebuild`` when a blob was present but was not served (a stale digest, a different build, corruption, or no records in it) and was rebuilt from the raw body. inthitmissrebuildN) __name__ __module__ __qualname____firstlineno____doc__r,__annotations__r-r.__static_attributes__r/i/home/user/pdf2html-billing-ledger-validate/.venv/lib/python3.14/site-packages/nab_index/cached_client.pyr(r(Gs% CLD#MGSr7iXi0zmax-age\s*=\s*"?(\d+)z\A\s*(\d+)\s*\Zc V^8dQhRRRR/#)digitsstrreturnr+r/)formats"r8 __annotate__r?ds 6 63 63 6r7cVPR4p\V4\8d\#\ \ T;'gR4\4#)a Return a ``delta-seconds`` digit run as an int. RFC 9110 5.6.7 allows leading zeros, sets no length limit on the run, and caps a value too large to represent at 2**31. ``int`` refuses a string past 4300 digits, so the padding is stripped before the run is measured. 0)lstriplen_SECONDS_CEILING_DIGITS_SECONDS_CEILINGminr+)r;trimmeds& r8_parse_secondsrHds>mmC G 7|-- s7>>c"$4 55r7c V^8dQhRRRR/#)r: cache_control str | Noner= int | Noner/)r>s"r8r?r?rs**j*Z*r7cxVfR#\PV4pVfR#\VP^44#)zBReturn the ``max-age`` a Cache-Control field carries, or ``None``.N) _MAX_AGE_REsearchrHgroup)rJmatchs& r8_max_age_directiverRrs6   } -E } %++a. ))r7c V^8dQhRRRR/#)r:agerKr=r+r/)r>s"r8r?r?|s * *J *3 *r7cxVf^#\PV4pVf^#\VP^44#)zReturn the seconds a response spent in caches before nab received it. An absent header, or one that is not a bare run of digits, reads as 0. )_AGE_RErQrHrP)rTrQs& r8 _parse_agerW|s5  { MM# E } %++a. ))r7c V^8dQhRRRR/#r:responser&r=r+r/)r>s"r8r?r?sCC|CCr7cr\\P!44\\VR44, #)a*Return when ``response`` opened its freshness window. A shared cache reports as Age how long ago the origin generated the representation, so a relayed response arrives that far into its window. Only the Age term of RFC 9111 4.2.3 is applied; the apparent age computed from the Date header is not. rT)r+timerWrrZs&r8_freshness_startr^s& tyy{ j5)AB BBr7c V^8dQhRRRR/#)r:valuerKr=rLr/)r>s"r8r?r?s##j#Z#r7cVfR#\V4pTPf!TP \ P R7p\TP44# \\3dR#i;i)aMReturn an HTTP-date as Unix seconds, or ``None`` if it is not a date. RFC 9110 5.6.7 writes every HTTP-date in GMT, so the zone-less obsolete asctime form reads as GMT rather than as local time. A year, day, hour or zone offset too large for a C int raises :class:`OverflowError` rather than :class:`ValueError`; neither is a date. N)tzinfo) r ValueError OverflowErrorrbrrutcr+ timestamp)r`parseds& r8_http_date_secondsrhsh }&u-}}x||4 v! ""  &s AA/.A/c$V^8dQhRRRRRR/#)r:expiresr<daterKr=r+r/)r>s"r8r?r?s&DDsD*DDr7c\V4pVf^#\V4pVf\\P!44p\\ W#, ^4\ 4#)zReturn the freshness lifetime an Expires field grants. RFC 9111 5.3: an Expires that is not an HTTP-date, ``0`` included, means already expired. Date is the point the expiry is measured from; a response that omits it is measured from its arrival. )rhr+r\rFmaxrE)rjrk expires_at generated_ats&& r8_expires_lifetimerpsO$G,J%d+L499;' s:,a02B CCr7c V^8dQhRRRR/#)r:rZr&r=boolr/)r>s"r8r?r?s r7cJ\VR4RJ;'g\VR4RJ#)z:Whether ``response`` carries a freshness field of its own. cache-controlNrj)rr]s&r8_states_freshnessrus1 /*$6 4 4 8Y 't 3r7c V^8dQhRRRR/#rYr/)r>s"r8r?r?sAA,A3Ar7c\\VR44pVeV#\VR4pVf\#\V\VR44#)aReturn how long ``response`` may be served without revalidation. RFC 9111 4.2.1 for a private cache: an explicit ``max-age``, else Expires measured from Date, else the heuristic default. 4.2.2 reserves that default for a response stating no expiry at all. rtrjrk)rRr_DEFAULT_MAX_AGErp)rZmax_agerjs& r8_freshness_lifetimerzsK!?!CDGh *G Wgh&? @@r7c$V^8dQhRRRRRR/#)r:policyr page_urlr<r=rKr/)r>s"r8r?r?s& G GK G3 G: Gr7c>WP8Xd VP#R#)aReturn the body digest a 304 may carry forward, or ``None`` to retire it. A 304 leaves the body alone, so the parsed blob bound to it still describes that body, but only while the page it was parsed from is the same one: a relative entry resolves against the page URL, so a move re-resolves every file URL. Dropping the digest retires the blob, and the next read rebuilds it against the new base. N)r} body_digest)r|r}s&&r8_carried_digestrs"*__!<6  F$Fr7c(V^8dQhRRRRRRRR/#) r:cacherpackager<offlinerrr="list[WheelFile | SdistFile] | Noner/)r>s"r8r?r?s,00 0"%0370'0r7cVPV4pVfR#VP4'g V'gR#VPV4pVfR#\WC4;'gR#)aKRead a fresh (or offline) parsed listing for ``package``, or ``None``. The write-free subset of :meth:`CachedAsyncSimpleClient.get_files`' fresh-hit branch: same policy, same ``is_fresh() or offline`` test, same blob, same :func:`parsed_listing.decode`, so on a hit it returns the records ``get_files`` would. Every other case (no policy, stale-online, no blob, a non-binding digest, a corrupt blob, a blob holding no records) declines to ``None`` and, unlike ``get_files``, never reads the raw body, revalidates, rebuilds, writes, or logs. It never raises, so a caller's pending is never stranded. A blob that rehydrates to no records declines for the same reason :meth:`CachedAsyncSimpleClient._parsed_hit` does: an empty listing also has to say whether the page offered only formats nab does not read, and only the raw body answers that. N)get_simple_policyis_freshget_simple_parsed_decode_parsed)rrrr|blobs&&$ r8read_fresh_parsed_listingrsY& $ $W -F ~ OO    " "7 +D | $ ' / /4/r7c T]tRt^tRt]3RRRRR]PRRRR/R R llltR R lt R Rlt RRlt RRlt RRlt RRltRRltRRltRRltRRltRR ltR!R/R"R#lltR$R%ltR&R'ltR(R)ltR3R*R+lltR4R,R-lltR4R.R/lltR4R0R1lltR2tR#)5r'zAsync PyPI Simple API client with on-disk caching. Distinct from :class:`AsyncSimpleClient`: the interface mirrors what :class:`FetchCoordinator` actually needs rather than the Simple API. rF range_memoN serializationmin_fresh_seconds parsed_statsc<V^8dQhRRRRRRRRR R R R R RRRRR/ #)r: transportr%rr index_urlr<rrrrzRangeCapabilityMemo | NonerrrrLrzParsedCacheStats | Noner=Noner/)r>s"r8r?$CachedAsyncSimpleClient.__annotate__sd, , %, ,  ,  , /, +, &, .,  , r7c WnW nVPR4R,VnW@nW`n\ 4VnVeTM \4Vn Wpn Ve VVn R#\4Vn R#)aCreate a cached client wrapping ``transport``. ``range_memo`` is the per-run range-capability memo shared across the indexes' clients; the coordinator owns the shared instance and injects it. A fresh memo is built when none is passed, so a stand-alone client still learns each host's range behaviour within its own lifetime. ``serialization`` pins which Simple-API serialization this index is asked for and read as. ``min_fresh_seconds`` is a read-time freshness floor for this index's Simple listing. A stale positive listing or negative sentinel within the floor is served without revalidation; it only extends freshness and rewrites nothing on disk. ``parsed_stats`` is the per-run parsed-listing cache sink, shared the same way so hit/miss/rebuild counts total across every index client. A private sink is created when none is passed, so a stand-alone client still counts its own outcomes. /N) _transport_cacherstrip _index_url_offline_serializationset_unreadable_onlyr _range_memo_min_fresh_secondsr( _parsed_stats) selfrrrrrrrrs &&&&$$$$$r8__init__ CachedAsyncSimpleClient.__init__sw@$ #**3/#5 +*-%$0J6I6K #4(4L :J:L r7cV^8dQhRR/#)r:r=rr/)r>s"r8r?r3s''d'r7c V"VPP4GRjxL R#L5i)zClose the underlying transport.N)raclosers&r8rCachedAsyncSimpleClient.aclose3soo$$&&&s )')cV^8dQhRR/#)r:r=r$r/)r>s"r8r?r7s$r7c "V#5i)z Enter the async context manager.r/rs&r8 __aenter__"CachedAsyncSimpleClient.__aenter__7s  sc V^8dQhRRRR/#)r:argsobjectr=rr/)r>s"r8r?r;sVr7c B"VP4GRjxL R#L5i)z7Exit the async context manager and close the transport.N)r)rrs&*r8 __aexit__!CachedAsyncSimpleClient.__aexit__;skkms c V^8dQhRRRR/#r:rr<r=list[WheelFile | SdistFile]r/)r>s"r8r?r?sB1B1sB1/JB1r7c r"VPPV4pRpVeVP4;'g'VP;'gVP W!R4pV'dVP W4pVeV#VPP V4pVeoVwrrVPWq4pVeTVPWVPR7p V'dVPWW)4V #VPWV4GRjxL #RpV'gbVPPV4p V eCV P4'g+VP'gVP WR4'd.#VP'dRV R2p \V 4hVPV4GRjxL #LL5i) a2Return parsed Simple API file list for ``package``. Cache hit served from disk (fresh, offline, or kept fresh by the read-time floor): the parsed-listing blob is rehydrated without reading the large raw body; on a blob miss, build/digest mismatch, corruption, or a blob holding no records the raw body is reparsed and the blob rebuilt (a WARNING self-heal on genuine corruption). Cache hit + stale + online: conditional revalidation; on 304 the body (and its parsed blob) are reused, on 200 both are replaced. Cache miss + offline: raises :class:`OfflineError`. Cache miss + online: fetches, caches, returns. The policy sidecar is read first: it carries the freshness window and the ``body_digest`` that gates the parsed blob, without the raw body. An absent policy is a full miss. A positive entry beats the negative sentinel, so the sentinel is consulted only on a positive miss. A fresh sentinel, or any sentinel offline, answers an absent name empty with no transport call; a stale sentinel online falls through to a fetch. A 404 records a sentinel. A cached body that will not decode as JSON is a corrupt positive: re-fetched online, raising :class:`OfflineError` offline. It is reached only after a parsed-blob miss reads the body, so the sentinel is not consulted then and a corrupt body never answers the name absent. FNlistingr}Tzabsent-name sentinelzNo cached listing for  (offline mode))rrrr_floor_keeps_fresh _parsed_hit get_simple_decode_cached_listing _parse_bodyr}_rebuild_parsed_revalidate_simple get_negativer _fetch_simple) rrr|corrupt_positive serve_cachedr,cachedbodydatafilesnegativemsgs && r8 get_files!CachedAsyncSimpleClient.get_files?s8..w7   !GG==GG**6IF  &&w7?J[[++G4F!% 224A# ,,TV__,UE#,,WFJ$ !%!8!8!OOO#' {{//8H#!!##===**8>TUU ===*7)?CCs# #''000P1sM8F7F7F7*BF7F3 F74F7 F7+F7 %F7.F5/F75F7c(V^8dQhRRRRRRRR/#)r:r|r rr<kindr=rrr/)r>s"r8r?rs)s#RVr7c  VPfR#\\P!44VP, pW@P8dR#\P RVPVVVP VVP4R#)zWhether the read-time freshness floor still covers a stale entry. Consulted only after the stored policy has said stale and offline is false. Fznassume-fresh-seconds=%d: %s for %r from %s kept fresh at age %ds (server freshness %ds); skipping revalidationT)rr+r\ fetched_atloggerdebugrry)rr|rrrTs&&&& r8r*CachedAsyncSimpleClient._floor_keeps_freshss  " " *$))+!2!22 )) )  <  # #   OO  NN r7c$V^8dQhRRRRRR/#)r:rr<r|r r=rr/)r>s"r8r?rs$***$/* +*r7c VPPV4pVf&VP;P^, unR#\ W24pV'd&VP;P ^, unV#VP;P ^, unVeR#\V4pVe#\PRVVPV4R#)aRehydrate the parsed blob for ``package``, or ``None`` on any miss. Returns the records only when a present blob decodes to at least one record and its header binds ``policy``'s body. An absent blob, a build/digest mismatch, or a corrupt blob all return ``None`` so the caller reparses the raw body; genuine corruption (garbage/truncated bytes) is logged at WARNING as a self-heal, while a build/digest mismatch is a silent rebuild. A blob that rehydrates to no records also declines. An empty listing carries a second fact the blob does not hold: whether the page offered only formats nab does not read, which decides between the "no such package" and the "nothing nab reads" report. Only the raw body answers that, and an empty listing is small enough to reparse. This is the one place that reads the blob, so it records the outcome: a served blob counts a ``hit``, an absent one a ``miss``, and a present-but-not-served one a ``rebuild``. NzRCorrupt parsed-listing cache blob for %r from %s: %s; rebuilding from the raw body) rrrr-rr,r._parsed_corruptionrwarningr)rrr|rrecordsreasons&&& r8r#CachedAsyncSimpleClient._parsed_hits,{{,,W5 <    # #q ( # .     " "a ' "N ""a'"  #D)   NN/  r7c(V^8dQhRRRRRRRR/#) r:rr<digestrKrrr=rr/)r>s"r8r?rs2 N N N$. N7R N  Nr7c lVe V'gR#VPPV\W244R#)axWrite the parsed blob for ``files``, when there is one worth writing. ``digest`` is ``None`` when the body write did not land, so no blob ever claims to describe a body the store does not hold. A listing with no records is skipped too: :meth:`_parsed_hit` declines a blob holding none, so writing one would rebuild and rewrite it on every later read without ever serving it. N)rput_simple_parsed_encode_parsed)rrrrs&&&&r8 _store_parsed%CachedAsyncSimpleClient._store_parseds' >  %%g~e/LMr7c ,V^8dQhRRRRRRRRR R /#) r:rr<rbytesr|r rrr=rr/)r>s"r8r?rs<3333 3 + 3  3r7c V'gR#VPpVfK\P!V4P4pVPP V\ W5R74VPWV4R#)a2Write a parsed blob for ``files`` bound to the on-disk ``body``. An older policy carries no ``body_digest``; the blob would never bind, so the digest is computed here and stamped into the refreshed policy so the next read hits. A policy that already carries a digest reuses it, sparing the body a rehash. N)r)rhashlibsha256 hexdigestrrefresh_simple_policyrr)rrrr|rrs&&&&& r8r'CachedAsyncSimpleClient._rebuild_parseds_ ## >^^D)335F KK - -<  7E2r7c V^8dQhRRRR/#)r:rZr&r=r r/)r>s"r8r?rs   + r7c b\\V4\4p\\ V4VRR7#)z?Freshness policy for a name-level 404, clamped to the 600s cap.N)rryetag)rFrzrxr r^)rrZrys&& r8_negative_policy(CachedAsyncSimpleClient._negative_policys.)(35EF'17  r7c$V^8dQhRRRRRR/#)r:rrrr<r=z object | Noner/)r>s"r8r?rs!53=r7c \P!V4pV# \d&\P RTTP 4R#i;i)aReturn the parsed JSON of a cached Simple body, or ``None``. A body that will not decode as JSON is logged and treated as a miss. A body that decodes but is the wrong shape is not caught here: :func:`_parse_files` raises on it, the same as on the wire path. zaCorrupt cached Simple-API body for %r from %s: not valid JSON; treating as a miss and re-fetchingN)jsonloadsrcrrr)rrrdecodeds&&& r8r.CachedAsyncSimpleClient._decode_cached_listingsM "jj.G  NN5    s,A  A c(V^8dQhRRRRRRRR/#)r:rrrr<r}r=rr/)r>s"r8r?r s2BBB$'B36B $Br7c \P!V4pTP YBTR7# \d%pTP RT: R2p\ T4ThRp?ii;i)aiParse a Simple-API listing body served from ``page_url``. A body that is not valid JSON raises the same :class:`MalformedSimpleResponseError` as a valid-JSON body of the wrong shape, not a raw decode error. ``json.loads`` raises a :class:`ValueError` for every body it rejects, including non-UTF-8 bytes and an integer literal past CPython's conversion limit. z, served a malformed Simple-API response for z: body is not valid JSONNr)rrrcrr r)rrrr}rexcrs&&&& r8_parse_listing&CachedAsyncSimpleClient._parse_listing sm =::d#DAA  =??##O+57 /s3 <  =s+ AAAr}c(V^8dQhRRRRRRRR/#) r:rrrr<r}rKr=rr/)r>s"r8r?rs,   %( 7A  $ r7c \WPW#R7pV'g-\V4'dVPP V4V#)zParse a decoded listing body, marking one with no readable file. ``page_url`` is the URL the body was served from, which its relative entries resolve against. r)rrrradd)rrrr}rs&&&$ r8r#CachedAsyncSimpleClient._parse_bodys;T??GO066  ! ! % %g . r7c V^8dQhRRRR/#)r:rr<r=rrr/)r>s"r8r?r+s00c0d0r7c WP9#)zBWhether a listing for ``package`` held only files nab cannot read.)r)rrs&&r8served_unreadable_only.CachedAsyncSimpleClient.served_unreadable_only+s////r7c(V^8dQhRRRRRRRR/#) r:rr<rrr|r r=rr/)r>s"r8r?r/s,+++"'+1<+ $+r7c H"VP V R2pR\VP4/pVPeVPVR&VPP WER7GRjxL pVP \8Xd\\V4\V4'd \V4M VP\VR4;'g VPVP\W6P4R7pVP P#W4VP%W!VP4#VP \&8Xd-VP P)WP+V44.#\-Wd4\/W`PWP4pVP%WVP4p \\V4\V4\VR4VPR7pVP P1WV4p VP3WV 4V #EL5i)rAcceptNz If-None-Matchheadersr)rryrr}rrryrr})rr rrrget status_code_HTTP_NOT_MODIFIEDr r^rurzryrurlrrrrr put_negativerr"r put_simpler) rrrr|rr rZ new_policynew_bodyrrs &&&& r8r*CachedAsyncSimpleClient._revalidate_simple/s!'!,1$2E2EFG ;; "'-{{GO $,,S,BB   #5 5$+H5)22(1Xv.==&++!+FLLA J KK - -g B&&thllC C   ? 2 KK $ $W.C.CH.M NI& oow0C0C  ##Hx||D '1'16*\\  '':F 7E2 ICsA%H"'H(A!H" EH"c V^8dQhRRRR/#rr/)r>s"r8r?r\s33Nr7c "VP V R2p\VP4pVPP VRV/R7GRjxL pVP \ 8Xd-VPPWPV44.#\WB4\W@PWP4pVPWQVP4p\\V4\!V4\#VR4VPR7pVPP%WV4pVP'WV4VPP)V4V#EL 5i)rrrNrr )rr rrr r r rrrr"rrrr r^rzrrr drop_negative) rrracceptrZrrr|rs && r8r%CachedAsyncSimpleClient._fetch_simple\s!!'!,%d&9&9:,,S8V:L,MM   ? 2 KK $ $W.C.CH.M NI&XATATU##D8<<@'1'16*\\   ''v> 7E2 !!'* 'NsA E E D Ec ,V^8dQhRRRRRRRRRR/#)r:rr<version metadata_url metadata_hashztuple[str, str] | Noner=r/)r>s"r8r?rts<0000 0 . 0 0r7c "VPPW4pVeV#VP'dRV RV R2p\V4hVPP V4GRjxL p\ Ws4VPpVe \W4VPR4p TPPYT 4T #LZ \dp T RT RT R2p\T4T hRp ? ii;i5i)aReturn the PEP 658 metadata text published at ``metadata_url``. ``version`` names the coordinate being resolved; the cache entry stands for the sidecar at the URL. Treated as immutable: cached forever, never revalidated. A cache hit is returned without re-checking, since it was verified before being stored. Cache miss + offline raises :class:`OfflineError`. When ``metadata_hash`` is given, the fetched bytes are verified against it and a mismatch raises :class:`MetadataHashMismatchError` before anything is cached. Metadata is decoded from the hash-verified bytes as utf-8 rather than the transport's ``.text``, which a backend may decode under the response Content-Type charset. This keeps the parsed text tied to the bytes the hash covers. A body that is not valid utf-8 raises :class:`MalformedSimpleResponseError` (an :class:`HttpError` subclass) rather than a raw :class:`UnicodeDecodeError`. NzNo cached metadata for ==rzutf-8z1 served a malformed PEP 658 metadata sidecar for z: body is not valid UTF-8) r get_metadatarr rr r"contentrrUnicodeDecodeErrorr put_metadata) rrrrrrrrZr textrs &&&&& r8get_metadata_text)CachedAsyncSimpleClient.get_metadata_textts4))'@  M ===+G9BwiOCs# #,,\::/""  $ !' 9 =>>'*D   = ;" =.!ir'*CE /s3 <  =s:3C/2C/(C)*C/C%C/ C,C''C,,C/c 0V^8dQhRRRRRRRRRRR R /#) r:rr<r wheel_urlcanonical_namer# wheel_hashestuple[tuple[str, str], ...]r=rr/)r>s"r8r?rsF)))) ) ' ) 2 ) )r7c "VPPW4pVe\V\P4#VP 'dRV RV R2p\ V4h\VPVVVP\V4R7GRjxL pVPe'VPPWVP4V#L:5i)a-Recover a sidecar-less wheel's METADATA by HTTP range reads. The recovered text is cached under the same immutable ``metadata-v1`` store the PEP 658 sidecar uses, keyed by the wheel URL. A cache hit is returned without any transport call, so a warm or previously-warmed offline resolve never re-ranges. A cold miss in offline mode raises :class:`OfflineError`; otherwise the reader drives the transport with the shared range-capability memo. Only a successful read is cached; an ``UNSUPPORTED`` or ``MISSING`` result writes nothing so the caller can step to the sdist rung. When ``wheel_hashes`` carries an acceptable published digest, a full-body acquisition is verified against it before its METADATA is read, mirroring the sdist path. A mismatch raises :class:`WheelHashMismatchError` and nothing is cached. NzNo cached range metadata for rr) wheel_hash) rrrrPARTIALrr rrrrr#r") rrrr'r(r)rrresults &&&&&& r8get_range_metadata*CachedAsyncSimpleClient.get_range_metadatas0))'=  &v|/C/CD D ===1'"WI_UCs# #5 OO     ,\:    ;; " KK $ $W E  sA CACC ;Cc ,V^8dQhRRRRRRRRRR/#) r:rr<r sdist_url sdist_hashesr*r=ztuple[str | None, str | None]r/)r>s"r8r?rs<%*%*%*%* %* 2 %* ' %*r7c "VPPW4pVeV#VP'dRV RV R2p\V4hVPP V\ R7GRjxL p\Ws4\V4pVe\VPV4\VP4wrV fV eVPPWW4W3#Lr5i)aReturn ``(pkg_info, pyproject_toml)`` for an sdist, caching both. Cache miss + offline raises :class:`OfflineError`. Either element may be ``None`` if the corresponding file is absent from the archive (or the archive cannot be parsed). Both are treated as immutable: cached forever, never revalidated. When ``sdist_hashes`` carries an acceptable published digest, the downloaded archive is verified against it before extraction. A mismatch raises :class:`SdistHashMismatchError` and nothing is cached. NzNo cached sdist PKG-INFO for rrr) rget_sdist_filesrr rr r!r"rrr rput_sdist_files) rrrr2r3rrrZselectedpkg_infopyproject_tomls &&&&& r8r5'CachedAsyncSimpleClient.get_sdist_filess&,,W>  M ===1'"WI_UCs# #,,Y@P,QQ,(6   h.. 9#78H8H#I   >#= KK ' '( S))Rs3C#8C#.C!/A3C#c ,V^8dQhRRRRRRRRRR/#) r:rr<rr2r3r*r=rr/)r>s"r8r?rs<      2    r7c ""??VP'dRV R2p\V4hVPPV\R7GRjxL p\ Wc4\ V4pVe\VPV4VP#L@5i)a Return the raw bytes of an sdist archive. Used by the ``BUILD_REMOTE`` path when a real backend invocation is required. No on-disk caching is performed: archives are large, builds are rare, and the in-memory index already deduplicates within a single resolve. Offline mode raises :class:`OfflineError` because there is no slot to read from. When ``sdist_hashes`` carries an acceptable published digest, the downloaded archive is verified before its bytes are returned. A mismatch raises :class:`SdistHashMismatchError`. z1sdist archive fetch unavailable in offline mode ()rN) rr rr r!r"rrr )rrrr2r3rrZr7s&&&&& r8get_sdist_archive)CachedAsyncSimpleClient.get_sdist_archives& W ===Ei[PQRCs# #,,Y@P,QQ,(6   h.. 9 RsA B B  AB) rrrrrrrrr)N)r/)r0r1r2r3r4r r NEGOTIATErrrrrrrrrrrrrrrrr$r/r5r>r6r/r7r8r'r's' ,  , 26, .A-J-J, )-, 15, , \'B1H.*X N34 &B* DH 0+Z00d)V%*N  r7)r'r(rl)Ur4 __future__rrrloggingrer\ dataclassesrrdatetimer email.utilsrtypingrrrr r clientr r r rrrrrrrrrr lazy_wheelrrrrparsed_listingrrrrrrrrr rr!r"packaging.utilsr#typing_extensionsr$r%r&__all__ getLoggerr0rr(rxr compile IGNORECASErNrVrErCr<rDrHrRrWr^rhrprurzrrr'r/r7r8rQs4#  *- :: E8.&;    8 $ &jj12==A **' (c"234 6* *C#*D$A" G0