#j%SrSSKJr SSKrSSKJr SSKJrJrJ r SSK J r \"S5r Sr S \S '\ \ 4SS jjr\ \ 4SS jjr\ 4SS jjrg)u%TTL-aware S3 ingestion cache (QUE-223). Registers a persistent-cache ``cloudpathlib.S3Client`` as the process-global default for ``s3://`` URIs, so any ``CloudPath("s3://...")`` / ``AnyPath("s3://...")`` materializes through a project-local cache dir instead of re-downloading every run. Source-change correctness is cloudpathlib's built-in ETag check; disk hygiene is a wall-clock TTL enforced by a single startup sweep. No subclass, no per-access hook — one module, two functions, two constants: - ``evict_stale_s3_cache()`` — startup sweep. Walks the cache dir and unlinks any file whose access time is older than the TTL. This is the *only* TTL reclamation path: cloudpathlib's ETag check handles source correctness; the sweep handles "downloaded once, never touched again" files that would otherwise live in the cache forever. - ``init_s3_cache()`` — package-import entrypoint. Runs the sweep, then constructs and registers the default S3 client. Called once from ``quber/__init__.py``. TTL is keyed off ``st_atime``, so re-processing a cached document resets its window: actively used files stay warm, abandoned ones age out after the TTL. On ``noatime``-mounted volumes atime is frozen and TTL degrades to "time since download" — accepted rather than adding mount-detection complexity. ) annotationsN)Path)AnyPathS3ClientS3Path)loggerz .cache/s3ifloat TTL_SECONDSc.UR5(dg[R"5U- nSnURS5HOnUR5(dMUR 5R U:dM:UR 5 US- nMQ U$)aDDelete cached files whose atime is older than ``ttl_seconds``. Walks ``cache_dir`` once with ``rglob('*')`` and unlinks regular files past the TTL. Returns the count evicted. Idempotent and safe to call when the cache directory does not exist yet (returns 0). Linear in the cached-file count; sub-second even at thousands. r*)existstimerglobis_filestatst_atimeunlink) cache_dir ttl_secondscutoffevictedps )/home/mande/repo/quber/src/quber/cache.pyevict_stale_s3_cacher'su      YY[; &FG __S ! 99;;1668,,v5 HHJ qLG" Nc[X5nU(a[R"SX 5 [USS9R 5 g)uPrune the stale cache, then register the default S3 client. Called once at package import (see ``quber/__init__.py``). Two ordered steps: 1. ``evict_stale_s3_cache()`` — bound disk usage for keys not re-accessed between runs. 2. Construct a persistent-cache ``S3Client`` rooted at ``cache_dir`` and publish it via ``set_as_default_client()`` so plain ``CloudPath("s3://...")`` / ``AnyPath("s3://...")`` picks it up. Constructing the client requires neither AWS credentials nor network access (boto3 resolves both lazily on first GET), so this is safe to run at import on any host, including CPU-only / credential-less dev environments. z,Evicted {} stale file(s) from S3 cache at {} persistent)local_cache_dirfile_cache_modeN)rrdebugrset_as_default_client)rrrs r init_s3_cacher#=s9&#9:G CWX !$rc[U5n[U[5(a_XR- UR- nUR 5(a[ R"SX#5 O[ R"SX#5 [U5$)aiCoerce a user-supplied path string to a local filesystem Path. Local inputs pass straight through. For ``s3://`` inputs, log an INFO line when the document is already present in the local cache (cache hit), then materialize it (cloudpathlib downloads on miss) and return the local Path. The cache-hit check mirrors cloudpathlib's on-disk layout (``//``) using only public ``S3Path`` attributes. Note: cloudpathlib still revalidates the S3 ETag on access, so a logged hit means "present locally"; if the source object changed upstream, cloudpathlib transparently re-downloads the fresh copy. zS3 cache hit: {} served from {}z#S3 cache miss: downloading {} to {}) r isinstancerbucketkeyrrinfor!r)rawrdoccacheds rresolve_documentr,Ysb #,C#vZZ'#''1 ==?? KK93 G LL> L 9r)rrrr returnint)rrrr r-None)r)strrrr-r)__doc__ __future__rrpathlibr cloudpathlibrrrlogurur CACHE_DIRr __annotations__rr#r,rrr9s4# 22    U $ . $ 82;r