pynamodb-async 0.1.0__py3-none-any.whl

pynamodb_async/__init__.py

@@ -0,0 +1,21 @@
+# AUTO-GENERATED from pynamodb/asyncio/__init__.py by scripts/make_addon.py - DO NOT EDIT
+"""
+Async API for PynamoDB, built on aiobotocore.
+
+Install with ``pip install pynamodb-async`` (Python 3.10+). Usage mirrors the
+sync API: ``from pynamodb_async.models import Model``.
+"""
+import sys
+
+if sys.version_info < (3, 10):  # pragma: no cover
+    raise ImportError("pynamodb_async requires Python 3.10+; install pynamodb-async")
+try:
+    import aiobotocore  # noqa: F401
+except ImportError as e:
+    raise ImportError(
+        "pynamodb_async requires aiobotocore; install pynamodb-async (Python 3.10+)"
+    ) from e
+
+from pynamodb_async.connection.base import connections  # noqa: E402
+
+__all__ = ['connections']

pynamodb_async/_compat.py

@@ -0,0 +1,198 @@
+# AUTO-GENERATED from pynamodb/asyncio/_compat.py by scripts/make_addon.py - DO NOT EDIT
+"""
+Async halves of operations that differ between the sync and async APIs.
+
+Helpers for operations whose synchronous and asynchronous forms cannot be derived
+from one another by rewriting keywords (sleeping, gathering, list building). This is
+the only module in this package allowed to import asyncio.
+
+`alist` is async-only: the generator rewrites `_compat.alist(` to `list(`.
+"""
+import asyncio
+import time
+import weakref
+from typing import Any, AsyncIterable, Dict, Hashable, List, TypeVar
+
+from aiobotocore.config import AioConfig
+
+from pynamodb.constants import SERVICE_NAME
+
+
+class _AsyncTime:
+    """Default clock for RateLimiter: real time, non-blocking sleep."""
+
+    time = staticmethod(time.time)
+
+    @staticmethod
+    async def sleep(seconds: float) -> None:
+        await asyncio.sleep(seconds)
+
+
+TIME_MODULE: Any = _AsyncTime()
+
+
+_T = TypeVar('_T')
+
+
+async def alist(iterable: AsyncIterable[_T]) -> List[_T]:
+    """Collects an async iterable; the generator rewrites `await alist(x)` to `list(x)`."""
+    return [item async for item in iterable]
+
+
+async def sleep(seconds: float) -> None:
+    await asyncio.sleep(seconds)
+
+
+def _has_credentials(client: Any) -> bool:
+    signer = client._request_signer
+    return not (signer and not signer._credentials)
+
+
+def client_usable(connection: Any) -> bool:
+    client = connection._client
+    if not client or not _has_credentials(client):
+        return False
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return False
+    # aiobotocore clients only work on the loop that created them.
+    return _held_loop(connection) is loop
+
+
+class _Entry:
+    __slots__ = ('client', 'refs')
+
+    def __init__(self, client: Any) -> None:
+        self.client = client
+        self.refs = 0
+
+
+# event loop -> {Connection._client_key() -> shared client}. Weak on the loop,
+# but a client that has made a request holds an aiohttp session, which holds
+# the loop, so a finished loop's entry would keep itself alive. open_client
+# therefore prunes entries for closed loops (see _prune_closed_loops).
+_clients: "weakref.WeakKeyDictionary[asyncio.AbstractEventLoop, Dict[Hashable, _Entry]]" = weakref.WeakKeyDictionary()
+
+
+def _prune_closed_loops() -> None:
+    """Drops cache entries of closed loops; their clients cannot be closed any more."""
+    for loop in [loop for loop in list(_clients.keys()) if loop.is_closed()]:
+        _clients.pop(loop, None)
+
+
+def _held_loop(connection: Any) -> Any:
+    ref = getattr(connection, '_client_loop', None)
+    return ref() if ref is not None else None
+
+
+def _held_entry(connection: Any, loop: Any) -> Any:
+    """The usable entry this connection already holds on `loop`, if any."""
+    entry = getattr(connection, '_client_entry', None)
+    if entry is not None and _held_loop(connection) is loop and _has_credentials(entry.client):
+        return entry
+    return None
+
+
+def _make_header_hook(headers: Any) -> Any:
+    # Closes over a copy of the headers, not the connection: the client lives in
+    # a shared cache and must not keep a connection (and so its loop) alive.
+    headers = dict(headers) if headers else None
+
+    def _before_send(request: Any, **_: Any) -> None:
+        if headers:
+            request.headers.update(headers)
+
+    return _before_send
+
+
+async def open_client(connection: Any, config: Any) -> Any:
+    loop = asyncio.get_running_loop()
+    held = _held_entry(connection, loop)
+    if held is not None:
+        return held.client
+    _prune_closed_loops()
+    per_loop = _clients.setdefault(loop, {})
+    key = connection._client_key()
+    entry = per_loop.get(key)
+    if entry is None or not _has_credentials(entry.client):
+        # A poisoned entry is replaced in the cache; connections still holding
+        # it release it when they notice (client_usable) or close.
+        client = await connection.session.create_client(
+            SERVICE_NAME, connection.region, endpoint_url=connection.host, config=AioConfig().merge(config),
+        ).__aenter__()
+        # Another coroutine may have opened a client while we were suspended.
+        held = _held_entry(connection, loop)
+        existing = per_loop.get(key)
+        if held is not None:
+            await client.__aexit__(None, None, None)
+            return held.client
+        if existing is not None and _has_credentials(existing.client):
+            # Take the reference before suspending to close the extra client;
+            # otherwise the last other holder could release (and close) the
+            # existing one meanwhile, leaving this connection on a closed client.
+            _hold(connection, existing, loop)
+            await client.__aexit__(None, None, None)
+            return existing.client
+        # extra_headers is part of the key, so every holder sends the same headers.
+        client.meta.events.register_first('before-send.*.*', _make_header_hook(connection._extra_headers))
+        entry = _Entry(client)
+        per_loop[key] = entry
+    _hold(connection, entry, loop)
+    return entry.client
+
+
+def _hold(connection: Any, entry: _Entry, loop: Any) -> None:
+    entry.refs += 1
+    connection._client_entry = entry
+    connection._client_loop = weakref.ref(loop)
+
+
+async def _release(connection: Any) -> None:
+    entry = getattr(connection, '_client_entry', None)
+    loop = _held_loop(connection)
+    connection._client_entry = None
+    connection._client_loop = None
+    connection._client = None
+    if entry is None:
+        return
+    entry.refs -= 1
+    if entry.refs > 0:
+        return
+    per_loop = _clients.get(loop) if loop is not None else None
+    if per_loop is not None:
+        for key, value in list(per_loop.items()):
+            if value is entry:
+                del per_loop[key]
+    try:
+        running = asyncio.get_running_loop()
+    except RuntimeError:
+        running = None
+    if running is not None and running is loop:
+        await entry.client.__aexit__(None, None, None)
+    # Otherwise the owning loop is gone or different; its sockets cannot be
+    # closed from here, so the client is dropped.
+
+
+async def replace_client(connection: Any) -> None:
+    await _release(connection)
+
+
+async def close_client(connection: Any) -> None:
+    await _release(connection)
+
+
+def client_property(connection: Any) -> Any:
+    if connection._client is None:
+        raise RuntimeError(
+            "The async client is not open yet; use `await connection.get_client()` "
+            "(any awaited operation opens it)"
+        )
+    return connection._client
+
+
+def connection_repr(connection: Any) -> str:
+    # repr must never raise, so it cannot go through the (not yet open) client.
+    if connection._client is not None:
+        return "Connection<{}>".format(connection._client.meta.endpoint_url)
+    return "Connection<{}>".format(connection.host or connection.region)

pynamodb_async/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

pynamodb_async/connection/__init__.py

@@ -0,0 +1,13 @@
+# AUTO-GENERATED from pynamodb/asyncio/connection/__init__.py by scripts/make_addon.py - DO NOT EDIT
+"""
+PynamoDB lowest level connection
+"""
+
+from pynamodb_async.connection.base import Connection
+from pynamodb_async.connection.table import TableConnection
+
+
+__all__ = [
+    "Connection",
+    "TableConnection",
+]

pynamodb_async/connection/_botocore_private.py

@@ -0,0 +1,30 @@
+# AUTO-GENERATED from pynamodb/asyncio/connection/_botocore_private.py by scripts/make_addon.py - DO NOT EDIT
+"""
+Type-annotates the private aiobotocore APIs that we're currently relying on.
+"""
+from typing import Dict
+
+import botocore.credentials
+import botocore.endpoint
+import botocore.hooks
+import botocore.signers
+from aiobotocore.client import AioBaseClient
+
+
+class BotocoreEndpointPrivate(botocore.endpoint.Endpoint):
+    _event_emitter: botocore.hooks.HierarchicalEmitter
+
+
+class BotocoreRequestSignerPrivate(botocore.signers.RequestSigner):
+    _credentials: botocore.credentials.Credentials
+
+
+class BotocoreBaseClientPrivate(AioBaseClient):
+    _endpoint: BotocoreEndpointPrivate
+    _request_signer: BotocoreRequestSignerPrivate
+
+    async def _make_api_call(        self,
+        operation_name: str,
+        operation_kwargs: Dict,
+    ) -> Dict:
+        raise NotImplementedError