client-query-cache 0.1.0__py3-none-any.whl

client_query_cache/synchronous/database.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from pymongo.synchronous.collection import Collection
+from pymongo.synchronous.database import Database
+
+from client_query_cache.synchronous.collection import CachedCollection
+
+if TYPE_CHECKING:
+    from client_query_cache.synchronous.manager import CacheManager
+
+
+class CachedDatabase[DocumentType: Mapping[str, Any]]:
+    __slots__ = ("_database", "_manager")
+
+    def __init__(
+        self, manager: CacheManager[DocumentType], database: Database[DocumentType]
+    ) -> None:
+        self._manager = manager
+        self._database = database
+
+    @property
+    def manager(self) -> CacheManager[DocumentType]:
+        return self._manager
+
+    @property
+    def name(self) -> str:
+        return self._database.name
+
+    @property
+    def raw(self) -> Database[DocumentType]:
+        return self._database
+
+    def __getitem__(self, name: str) -> CachedCollection[DocumentType]:
+        return CachedCollection(self, self._database[name])
+
+    def __getattr__(self, name: str) -> Any:  # noqa: ANN401
+        return self._wrap_delegated(getattr(self._database, name))
+
+    def _wrap_delegated(self, value: Any) -> Any:  # noqa: ANN401
+        if isinstance(value, Collection):
+            return CachedCollection(self, value)
+        if isinstance(value, Database):
+            return CachedDatabase(self._manager, value)
+        if not callable(value):
+            return value
+
+        def _delegate(*args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
+            return self._wrap_delegated(value(*args, **kwargs))
+
+        return _delegate

client_query_cache/synchronous/manager.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self
+
+from client_query_cache._core.collection_metadata import (
+    CollectionMetadata,
+    CollectionMetadataCache,
+)
+from client_query_cache._core.manager import CacheCore
+from client_query_cache._core.stream_options import (
+    DEFAULT_MAX_AWAIT_TIME_MS,
+    validate_max_await_time_ms,
+)
+from client_query_cache._core.unique_keys import (
+    UniqueKeyMetadata,
+    UniqueKeyMetadataCache,
+    discover_unique_keys,
+)
+from client_query_cache.synchronous.database import CachedDatabase
+from client_query_cache.synchronous.streams import ChangeStreamCoordinator
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    from pymongo import MongoClient
+
+    from client_query_cache._core.collection_metadata import CollectionProbeResult
+    from client_query_cache._core.keys import NamespaceId
+    from client_query_cache._core.manager import CacheCoreConfig
+    from client_query_cache._core.unique_keys import UniqueKeyDefinition
+
+
+class CacheManager[DocumentType: Mapping[str, Any]]:
+    __slots__ = ("_cache", "_client", "_coordinator", "_metadata", "_unique_keys")
+
+    def __init__(
+        self,
+        client: MongoClient[DocumentType],
+        *,
+        cache_config: CacheCoreConfig | None = None,
+        max_await_time_ms: int = DEFAULT_MAX_AWAIT_TIME_MS,
+    ) -> None:
+        validate_max_await_time_ms(max_await_time_ms)
+        self._client = client
+        self._cache = CacheCore(cache_config)
+        self._coordinator = ChangeStreamCoordinator(
+            client, self._cache, max_await_time_ms=max_await_time_ms
+        )
+        self._metadata = CollectionMetadataCache()
+        self._unique_keys = UniqueKeyMetadataCache()
+
+    @property
+    def client(self) -> MongoClient[DocumentType]:
+        return self._client
+
+    @property
+    def cache_core(self) -> CacheCore:
+        return self._cache
+
+    def ensure_cache_eligible(
+        self,
+        namespace: NamespaceId,
+        collection_probe: Callable[[], CollectionProbeResult | None],
+    ) -> bool:
+        self._coordinator.activate_database(namespace.database)
+        if not self._cache.is_database_available(namespace.database):
+            return False
+        current_epoch = self._cache.current_epoch(namespace)
+        cached = self._metadata.get(namespace)
+        if cached is None or cached.checked_epoch != current_epoch:
+            probe_result = collection_probe()
+            if probe_result is None:
+                return False
+            cached = CollectionMetadata(
+                checked_epoch=current_epoch,
+                is_cacheable=probe_result.is_cacheable,
+                default_collation=probe_result.default_collation,
+            )
+            self._metadata.put(namespace, cached)
+        return cached.is_cacheable
+
+    def default_collation_for(self, namespace: NamespaceId) -> Mapping[str, Any] | None:
+        cached = self._metadata.get(namespace)
+        return cached.default_collation if cached is not None else None
+
+    def unique_keys_for(
+        self,
+        namespace: NamespaceId,
+        list_indexes: Callable[[], Sequence[Mapping[str, Any]] | None],
+    ) -> tuple[UniqueKeyDefinition, ...]:
+        current_generation = self._cache.current_index_generation(namespace)
+        cached = self._unique_keys.get(namespace)
+        if cached is None or cached.checked_index_generation != current_generation:
+            index_specs = list_indexes()
+            if index_specs is None:
+                return ()
+            if self._cache.current_index_generation(namespace) != current_generation:
+                return ()
+            cached = UniqueKeyMetadata(
+                checked_index_generation=current_generation,
+                keys=discover_unique_keys(index_specs),
+            )
+            self._unique_keys.put(namespace, cached)
+        return cached.keys
+
+    def __getitem__(self, name: str) -> CachedDatabase[DocumentType]:
+        return CachedDatabase(self, self._client[name])
+
+    def close(self) -> None:
+        self._coordinator.close()
+        self._cache.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *_exc_info: object) -> None:
+        self.close()

client_query_cache/synchronous/streams.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import threading
+from typing import TYPE_CHECKING, Any
+
+import bson
+from bson.errors import BSONError
+from pymongo.errors import OperationFailure, PyMongoError
+
+from client_query_cache._core.errors import StreamLifecycleError, StreamStartupError
+from client_query_cache._core.stream_events import (
+    build_change_stream_pipeline,
+    is_unresumable_change_stream_error,
+    route_change_event,
+)
+from client_query_cache._core.stream_health import RetryBackoff, StreamHealth
+from client_query_cache._core.stream_options import DEFAULT_MAX_AWAIT_TIME_MS
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from pymongo import MongoClient
+    from pymongo.synchronous.change_stream import DatabaseChangeStream
+    from pymongo.synchronous.database import Database
+
+    from client_query_cache._core.manager import CacheCore
+
+MINIMUM_SERVER_VERSION = (8, 0)
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseStreamSupervisor:
+    __slots__ = (
+        "_backoff",
+        "_cache",
+        "_database",
+        "_health",
+        "_health_lock",
+        "_lifecycle_lock",
+        "_max_await_time_ms",
+        "_resume_token",
+        "_stop_event",
+        "_stream",
+        "_thread",
+    )
+
+    def __init__(
+        self,
+        database: Database[Any],
+        cache: CacheCore,
+        *,
+        backoff: RetryBackoff | None = None,
+        max_await_time_ms: int = DEFAULT_MAX_AWAIT_TIME_MS,
+    ) -> None:
+        self._database = database
+        self._cache = cache
+        self._backoff = backoff if backoff is not None else RetryBackoff()
+        self._max_await_time_ms = max_await_time_ms
+        self._health = StreamHealth.STARTING
+        self._health_lock = threading.Lock()
+        self._lifecycle_lock = threading.RLock()
+        self._stream: DatabaseChangeStream[Any] | None = None
+        self._resume_token: Mapping[str, Any] | None = None
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._cache.set_database_available(self._database.name, available=False)
+
+    @property
+    def healthy(self) -> bool:
+        with self._health_lock:
+            return self._health is StreamHealth.HEALTHY
+
+    def start(self) -> None:
+        with self._lifecycle_lock:
+            if self._health is not StreamHealth.STARTING:
+                message = "start() may only be called once per supervisor instance"
+                raise StreamLifecycleError(message)
+            self._set_health(StreamHealth.CONNECTING)
+        self._clear_namespaces_for_database()
+        try:
+            self._ensure_server_supports_expanded_events()
+            self._open_stream(resume_token=None, use_start_after=False)
+        except StreamStartupError:
+            self._set_health(StreamHealth.CLOSED)
+            raise
+        except PyMongoError as exc:
+            self._set_health(StreamHealth.CLOSED)
+            message = (
+                f"failed to open change stream for database {self._database.name!r}"
+            )
+            raise StreamStartupError(message) from exc
+        with self._lifecycle_lock:
+            if self._stop_event.is_set():
+                assert self._stream is not None
+                with contextlib.suppress(PyMongoError):
+                    self._stream.close()
+                self._set_health(StreamHealth.CLOSED)
+                message = "stop() was called while start() was still connecting"
+                raise StreamLifecycleError(message)
+            self._set_health(StreamHealth.HEALTHY)
+            self._thread = threading.Thread(
+                target=self._run,
+                name=f"client-query-cache-stream-{self._database.name}",
+                daemon=True,
+            )
+            self._thread.start()
+
+    def stop(self) -> None:
+        with self._lifecycle_lock:
+            self._stop_event.set()
+            self._set_health(StreamHealth.CLOSED)
+            stream = self._stream
+            if stream is not None:
+                try:
+                    stream.close()
+                except PyMongoError:
+                    logger.warning(
+                        "change stream close failed during shutdown",
+                        extra={"database": self._database.name},
+                        exc_info=True,
+                    )
+            thread = self._thread
+        if thread is not None:
+            thread.join()
+        self._set_health(StreamHealth.CLOSED)
+
+    def _ensure_server_supports_expanded_events(self) -> None:
+        server_info = self._database.client.server_info()
+        version = tuple(server_info["versionArray"][:2])
+        if version < MINIMUM_SERVER_VERSION:
+            message = (
+                f"MongoDB server version {server_info['version']} is not supported; "
+                "client_query_cache requires MongoDB 8.0 or newer"
+            )
+            raise StreamStartupError(message)
+
+    def _open_stream(
+        self, *, resume_token: Mapping[str, Any] | None, use_start_after: bool
+    ) -> None:
+        kwargs: dict[str, Any] = {
+            "show_expanded_events": True,
+            "max_await_time_ms": self._max_await_time_ms,
+        }
+        if resume_token is not None:
+            if use_start_after:
+                kwargs["start_after"] = resume_token
+            else:
+                kwargs["resume_after"] = resume_token
+        previous_stream = self._stream
+        self._stream = self._database.watch(build_change_stream_pipeline(), **kwargs)
+        if previous_stream is not None:
+            with contextlib.suppress(PyMongoError):
+                previous_stream.close()
+        if self._stop_event.is_set():
+            with contextlib.suppress(PyMongoError):
+                self._stream.close()
+
+    def _set_health(self, health: StreamHealth) -> None:
+        with self._lifecycle_lock:
+            if self._stop_event.is_set() and health is StreamHealth.HEALTHY:
+                health = StreamHealth.CLOSED
+            with self._health_lock:
+                self._cache.set_database_available(
+                    self._database.name, available=health is StreamHealth.HEALTHY
+                )
+                self._health = health
+
+    def _run(self) -> None:
+        while not self._stop_event.is_set():
+            assert self._stream is not None
+            self._cache.record_stream_poll(self._database.name)
+            try:
+                event = self._stream.next()
+            except StopIteration, PyMongoError:
+                self._handle_stream_failure()
+                continue
+            self._resume_token = self._stream.resume_token
+            must_reopen = route_change_event(self._cache, self._database.name, event)
+            self._record_logical_event_bytes(event)
+            if must_reopen:
+                self._reopen_after_invalidate()
+
+    def _record_logical_event_bytes(self, event: Mapping[str, Any]) -> None:
+        try:
+            encoded_length = len(
+                bson.encode(dict(event), codec_options=self._database.codec_options)
+            )
+        except BSONError, TypeError, ValueError:
+            return
+        self._cache.record_logical_event_bytes(self._database.name, encoded_length)
+
+    def _handle_stream_failure(self) -> None:
+        if self._stop_event.is_set():
+            return
+        self._set_health(StreamHealth.RECONNECTING)
+        if self._resume_token is None:
+            self._clear_namespaces_for_database()
+        self._reopen_with_backoff(use_start_after=False)
+
+    def _reopen_after_invalidate(self) -> None:
+        self._set_health(StreamHealth.RECONNECTING)
+        self._reopen_with_backoff(use_start_after=True)
+
+    def _reopen_with_backoff(self, *, use_start_after: bool) -> None:
+        while not self._stop_event.is_set():
+            try:
+                self._open_stream(
+                    resume_token=self._resume_token, use_start_after=use_start_after
+                )
+            except PyMongoError as exc:
+                if isinstance(
+                    exc, OperationFailure
+                ) and is_unresumable_change_stream_error(exc):
+                    self._clear_namespaces_for_database()
+                    self._resume_token = None
+                    use_start_after = False
+                    continue
+                delay = self._backoff.next_delay()
+                logger.warning(
+                    "change stream reconnect failed, retrying with backoff",
+                    extra={"database": self._database.name, "delay_seconds": delay},
+                    exc_info=exc,
+                )
+                if self._stop_event.wait(delay):
+                    return
+                continue
+            else:
+                self._backoff.reset()
+                if not self._stop_event.is_set():
+                    self._set_health(StreamHealth.HEALTHY)
+                return
+
+    def _clear_namespaces_for_database(self) -> None:
+        for namespace in self._cache.namespaces_for_database(self._database.name):
+            self._cache.clear_namespace(namespace)
+        self._cache.reset_stream_cost_statistics(self._database.name)
+
+
+class ChangeStreamCoordinator:
+    __slots__ = (
+        "_cache",
+        "_client",
+        "_closed",
+        "_lock",
+        "_max_await_time_ms",
+        "_supervisors",
+    )
+
+    def __init__(
+        self,
+        client: MongoClient[Any],
+        cache: CacheCore,
+        *,
+        max_await_time_ms: int = DEFAULT_MAX_AWAIT_TIME_MS,
+    ) -> None:
+        self._client = client
+        self._max_await_time_ms = max_await_time_ms
+        self._cache = cache
+        self._supervisors: dict[str, DatabaseStreamSupervisor] = {}
+        self._closed = False
+        self._lock = threading.Lock()
+
+    def activate_database(self, name: str) -> DatabaseStreamSupervisor | None:
+        with self._lock:
+            if self._closed:
+                raise StreamLifecycleError("coordinator is closed")
+            try:
+                supervisor = self._supervisors[name]
+            except KeyError:
+                supervisor = DatabaseStreamSupervisor(
+                    self._client[name],
+                    self._cache,
+                    max_await_time_ms=self._max_await_time_ms,
+                )
+                try:
+                    supervisor.start()
+                except StreamStartupError:
+                    logger.warning(
+                        "change stream startup failed for database %r; reads for "
+                        "this database will bypass the cache",
+                        name,
+                        exc_info=True,
+                    )
+                    return None
+                self._supervisors[name] = supervisor
+            return supervisor
+
+    def close(self) -> None:
+        with self._lock:
+            self._closed = True
+            supervisors = list(self._supervisors.values())
+            self._supervisors.clear()
+        for supervisor in supervisors:
+            supervisor.stop()

client_query_cache-0.1.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.3
+Name: client-query-cache
+Version: 0.1.0
+Summary: Client-side caching for PyMongo, kept coherent using MongoDB change streams.
+Author: Alessio Locatelli
+Author-email: Alessio Locatelli <<software.development@secure.mailbox.org>>
+Requires-Dist: pymongo>=4.18.1
+Requires-Dist: opentelemetry-api>=1.45.0 ; extra == 'otel'
+Requires-Python: >=3.14.6
+Project-URL: Repository, https://github.com/alessio-locatelli/client-query-cache
+Provides-Extra: otel
+Description-Content-Type: text/markdown
+
+# client-query-cache
+
+Client-side caching for PyMongo, kept coherent using MongoDB change streams. For Python applications that already talk to MongoDB through PyMongo directly, it adds a coherent read cache without introducing a separate cache server or changing how you connect. The library supports synchronous and asyncio clients.
+
+It caches reads whose results the manager can invalidate correctly when the underlying data changes, and leaves everything else — including all writes — to go straight to MongoDB. Invalidation is asynchronous: a read running concurrently with a write can still return the previous cached value until the manager processes that write's change-stream event.
+
+**Built for production:** 100% covered, extensively tested from cache-core invariants through real MongoDB deployments, continuously benchmarked, and protected by an automated pull-request performance regression guard.
+
+![Cached reads are up to about 1,200 times faster than a direct read, and roughly the same speed whether the server is local or a real remote deployment. Direct local server read 120 microseconds, direct real deployment (Atlas M0 free tier) read 79.4 milliseconds, cached read about 61 microseconds either way. Bars use a logarithmic scale.](docs/assets/benchmark-latency-light.svg)
+
+Read latency across two different deployments, so you can see the range: the local-server row is the median from one of the [retained local benchmark reports](docs/stream-cost-benchmarks.md); the M0-deployment row is the mean of one batch from the [real-server benchmark](CONTRIBUTING.md#real-server-benchmark) against a free-tier Atlas (M0) cluster — plotted on a logarithmic axis given the size of the gap. Cached-read latency barely moves between the two, since a cache hit never touches the network. Neither number is a universal performance guarantee for your own workload or deployment — see [Stream cost benchmarks](docs/stream-cost-benchmarks.md) for the full local workload matrix and how to reproduce it.
+
+---
+
+## Requirements
+
+`client-query-cache` requires Python 3.14.6 or newer.
+
+Reads and writes work against any MongoDB deployment PyMongo supports. **Effective caching** needs two separate things: a replica set or sharded cluster, since MongoDB only provides change streams on one of those topologies, not a standalone server; and MongoDB 8.0 or newer, a floor this library enforces itself at startup rather than a limit of change streams themselves. Against a deployment that doesn't meet both, the manager doesn't raise: it logs a warning and bypasses the cache for that database, executing every read as a normal, uncached PyMongo call.
+
+## Install
+
+```bash
+uv add client-query-cache
+```
+
+Or with pip: `pip install client-query-cache`.
+
+## Usage
+
+`CacheManager` wraps a `pymongo.MongoClient` (or `pymongo.AsyncMongoClient`) that you construct and own. Its database and collection facades cache a narrow set of PyMongo's own read methods — `find_one`, `find`, `aggregate`, `count_documents`, `estimated_document_count`, and `distinct` — and keep cached results coherent as the underlying data changes. Every other operation, including all writes, is called directly on the facade the same way you'd call it on the wrapped PyMongo object:
+
+```python
+from pymongo import MongoClient
+
+from client_query_cache import CacheManager
+
+with (
+    MongoClient("mongodb://localhost:27017") as client,
+    CacheManager(client) as manager,
+):
+    collection = manager["my_database"]["my_collection"]
+    collection.insert_one({"_id": "example", "value": 42})
+
+    collection.find_one({"_id": "example"})  # cache miss: reads from MongoDB
+    collection.find_one({"_id": "example"})  # cache hit: served from the cache
+
+    # Bridge stats like this into OpenTelemetry:
+    # docs/architecture.md#opentelemetry-metrics
+    print(manager.cache_core.snapshot().hits)  # 1
+
+    collection.create_index("email", unique=True)
+    collection.insert_one({"_id": "user-1", "email": "a@example.com"})
+    collection.find_one({"email": "a@example.com"})  # also cached, like an `_id` lookup
+```
+
+`find_one` caches a lookup by `_id` and by any other field the database enforces as unique, discovered automatically from the collection's own indexes — there's nothing to declare. Only a plain unique index qualifies: a partial, sparse, or hashed unique index, or a read whose collation doesn't match the index's collation, falls back to an uncached read instead.
+
+`CacheManager` starts a background change-stream task the first time a read touches a database, so close it (or use it as a context manager, as above) alongside the client — closing only the client leaves that background task running against a closed connection.
+
+The same facades are available for `pymongo.AsyncMongoClient` under `client_query_cache.asynchronous`, with the same methods as coroutines:
+
+```python
+import asyncio
+
+from pymongo import AsyncMongoClient
+
+from client_query_cache.asynchronous import CacheManager
+
+
+async def main() -> None:
+    async with (
+        AsyncMongoClient("mongodb://localhost:27017") as client,
+        CacheManager(client) as manager,
+    ):
+        collection = manager["my_database"]["my_collection"]
+        await collection.insert_one({"_id": "example", "value": 42})
+
+        await collection.find_one({"_id": "example"})  # cache miss
+        await collection.find_one({"_id": "example"})  # cache hit
+
+
+asyncio.run(main())
+```
+
+A read bypasses the cache instead of using it whenever caching it safely isn't possible — for example, a caller-selected session, read preference, or read concern; a view; a nondeterministic or cross-collection aggregation pipeline; a time-series collection; or a database whose change stream isn't healthy. See [Bypass conditions](docs/api-reference.md#bypass-conditions) in the API reference for the complete list.
+
+## Scope and constraints
+
+- **Writes aren't cached** — only the six read methods listed above are. See [why only reads are cached](docs/architecture.md#why-only-reads-are-cached) for the rationale.
+- **Each `CacheManager` is independent** — it owns its own in-process cache and its own change-stream cursors; nothing is shared between managers or processes. See [capacity planning](docs/architecture.md#capacity-estimation) before creating one per request or one per worker process.
+
+## Documentation
+
+- [API reference](docs/api-reference.md) — the complete public surface: construction, configuration, limits, ownership, and raw fallback.
+- [Architecture and operations](docs/architecture.md) — system requirements, capacity planning, retry/error handling, observability, security, and recovery behavior.
+- [Stream cost benchmarks](docs/stream-cost-benchmarks.md) — whether caching fits your workload, and the controlled benchmark reports backing that guidance.
+
+---
+
+> MongoDB is a registered trademark of MongoDB, Inc. This project is independent and is not affiliated with, sponsored by, or endorsed by MongoDB, Inc.

client_query_cache-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+client_query_cache/__init__.py,sha256=M7VxCKrdtxXbi9F3V9uxDMkI0GR9f4wKWco_gV-mzFs,246
+client_query_cache/_core/__init__.py,sha256=u6RnJIkw78X9bRUOo-euhpWQhleCO5_lbpXVstvjULQ,1206
+client_query_cache/_core/canonical.py,sha256=x7jlufMjneAx4bbCQ3rOI70qeuoME-APjyvLYD7H4Gs,1997
+client_query_cache/_core/codec.py,sha256=gsaLTzPTqGr5cxuEa4tNjevz_GmNPvJOI6n6wuBenoo,1471
+client_query_cache/_core/collation.py,sha256=zDiMlgqj5aQACmyg_qJXp3ibMfI2V2PjKcE05NZdeV8,468
+client_query_cache/_core/collection_metadata.py,sha256=iC9T08Q-I5_IoI9PP8JwDzmbHLGyP7KoyBBf9mY7bUA,1756
+client_query_cache/_core/entries.py,sha256=4sPA7wM1NeymoLbwQbz2Jb9-v2_xm7awVZOZf7SA7KA,777
+client_query_cache/_core/errors.py,sha256=W3GpmO1FQRN-WqhdXqolEYlnTul2o1p3mBaEWmKx8k0,358
+client_query_cache/_core/identity_reads.py,sha256=VqcPzWlsa-l2gO66iDwRDXp9Wag2HCxb31olnvqC2Lk,1615
+client_query_cache/_core/keys.py,sha256=_cAaesjVYq8rZct29HgNpb0aWlQ76QNDrUMO2bFXp-E,1009
+client_query_cache/_core/lifecycle.py,sha256=AMCMnzJKNkHtakWhPwfxXnBtwT5nFT6O9DJ2H90E8VU,132
+client_query_cache/_core/locking.py,sha256=WmulnmWEqYwuOsj_O2cWLYsPah3Hq5AhHcfeNe0GLLM,1114
+client_query_cache/_core/lru.py,sha256=t6yzayAfGFg2Au3TOOu8si7ve3tyCAuzmh_RHnvVk8I,3583
+client_query_cache/_core/manager.py,sha256=hPht6bqBmeOpw7LOjngxi411vJuUx6UjOBrXJDI1ebQ,32984
+client_query_cache/_core/namespace.py,sha256=sXJmhcQ5jEN81A9JlVD3nRSwQk5BBZVGukvUo4XOMs8,1135
+client_query_cache/_core/order_sensitive_keys.py,sha256=qZWN5-pMyqiSBnnd9642yZUQqw0TznF-15LebzNj4I8,2048
+client_query_cache/_core/projection.py,sha256=kCBavYPibKQEFRdBepMMcTW9b8K5JIJh3Op_OPFkyXo,1831
+client_query_cache/_core/read_validation.py,sha256=QgFMMnSNcv8PRYA53Lr1a9Q5IATjUbnyHZ9BiMEhfm4,2556
+client_query_cache/_core/snapshots.py,sha256=ynkdq6si-cR2BKvKYbxozCQw3WacuOm5CoSqtIxRF48,1530
+client_query_cache/_core/stream_cost.py,sha256=X9BDDQErSMAoIg7ZZVmeFOIUy6OvfrHLcePVRXd6z5I,7917
+client_query_cache/_core/stream_events.py,sha256=Jr6hJAs8yaB8ttQ5ifcPAo-yMDdmBGSYxPMLceH0nYM,4990
+client_query_cache/_core/stream_health.py,sha256=myIWEejUlgKgvK_xgWnDh4UnOH1V0DAAOz99F0IcXaw,1301
+client_query_cache/_core/stream_options.py,sha256=1Ds_ziji8q0b7lYAlqeAiN-LeWjdBInXW2NESOYjo9g,543
+client_query_cache/_core/unique_keys.py,sha256=ST6o7gTeYIbcjWOZnlxQghWNYH1-P3h7BLxN59cs0nM,3541
+client_query_cache/asynchronous/__init__.py,sha256=Th1VJmN6Vo2o975yDxobyjt0_JNMGnYgs0Fv1zqyPEU,440
+client_query_cache/asynchronous/collection.py,sha256=06mqdHrrzYALnJI-1CnFT3DFMFAQDXoBr82rO3I4L8o,26043
+client_query_cache/asynchronous/database.py,sha256=n1y4cqawEPxOfQMilI09DeIKbR-y800MhDztlEJQWFg,1923
+client_query_cache/asynchronous/manager.py,sha256=hl8uk5N0dm9DaXvNVrO8akyczO9peyG0--J5xs7eaVE,4406
+client_query_cache/asynchronous/streams.py,sha256=kw2RIRHJNeMaxmWXL2Kd_KODNsNxZg9ZMotNsCHXZaM,11189
+client_query_cache/otel.py,sha256=OY263r51rNSdcFP5zFG9njJNk-3PzvXIYVLFqYwiJmI,6852
+client_query_cache/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+client_query_cache/synchronous/__init__.py,sha256=Th1VJmN6Vo2o975yDxobyjt0_JNMGnYgs0Fv1zqyPEU,440
+client_query_cache/synchronous/collection.py,sha256=1VbFBocneS6O01iBHiQOgVyW7T9lhd5WywP-5YTeRgg,25382
+client_query_cache/synchronous/database.py,sha256=ZZSMLUEhMn8g-lNsi2KWYCJkVxmiyEiSxKvjxxpIwhk,1658
+client_query_cache/synchronous/manager.py,sha256=D-oysms4D6TJ3hZkfcjpd3iJ0ucmx0TjS-qjg-W9Vkk,4294
+client_query_cache/synchronous/streams.py,sha256=lZJU95_pwPuTJxLw5-un-Y97pW3m3KLWjwfcxekeqsg,11046
+client_query_cache-0.1.0.dist-info/WHEEL,sha256=e4_1dyBeezi8ZjfxrZ3bnVOxFDa3ksqVqH0jTHkUZ3k,81
+client_query_cache-0.1.0.dist-info/METADATA,sha256=vaFIE_dQZqnCEri8hj7lBQlDvN45M1Hnwtp-tOfkzJE,7504
+client_query_cache-0.1.0.dist-info/RECORD,,

client_query_cache-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.19
+Root-Is-Purelib: true
+Tag: py3-none-any