pynamodb-async 0.1.0__tar.gz

pynamodb_async-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+src/pynamodb_async/_version.py
+dist/
+__pycache__/
+uv.lock

pynamodb_async-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jharrod LaFon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pynamodb_async-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.5
+Name: pynamodb-async
+Version: 0.1.0
+Summary: Native asyncio API for PynamoDB, built on aiobotocore
+Project-URL: Source, https://github.com/zeroae/pynamodb-async
+Project-URL: Issues, https://github.com/zeroae/pynamodb-async/issues
+Project-URL: PynamoDB, https://github.com/pynamodb/PynamoDB
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: aiobotocore>=2.13.0
+Requires-Dist: pynamodb<6.2,>=6.1
+Description-Content-Type: text/markdown
+
+# pynamodb-async
+
+A native asyncio API for [PynamoDB](https://github.com/pynamodb/PynamoDB), built on
+[aiobotocore](https://github.com/aio-libs/aiobotocore). It runs next to official PynamoDB:
+you keep using PynamoDB's attributes, indexes and expressions, and get awaitable models,
+queries, batches and transactions.
+
+```
+pip install pynamodb-async
+```
+
+Needs Python 3.10+. This installs official `pynamodb` (6.1.x) and `aiobotocore`.
+
+## Usage
+
+Declare a model with `Model` from `pynamodb_async.models` and attributes from `pynamodb.attributes`:
+
+```python
+import pynamodb_async
+from pynamodb.attributes import UnicodeAttribute
+from pynamodb_async.models import Model
+
+
+class User(Model):
+    class Meta:
+        table_name = "users"
+        region = "us-east-1"
+
+    email = UnicodeAttribute(hash_key=True)
+    name = UnicodeAttribute(null=True)
+
+
+async def main():
+    async with pynamodb_async.connections():
+        await User("ada@example.com", name="Ada").save()
+        user = await User.get("ada@example.com")
+        async for u in User.query("ada@example.com"):
+            print(u.name)
+```
+
+## Closing clients and event loops
+
+Every async client holds an HTTP session. Close it when you are done with
+`await User.close()`, or wrap your code in `async with pynamodb_async.connections():`, which
+closes every connection opened inside the block. A client belongs to the event loop that
+created it, so use each model and `Connection` from one event loop at a time, and prefer one
+long-lived event loop for the whole program.
+
+## Relationship to PynamoDB
+
+This package works alongside official PynamoDB. Its code is generated from a private source
+repository, a fork that also offers the same async API as a drop-in replacement for `pynamodb`.
+This add-on has its own async `Connection.get_client()`. What it does not have are the fork's
+sync additions: `pynamodb.models.Model.close()`, `pynamodb.connections()` and the sync
+`pynamodb.connection.Connection.get_client()`. It also lacks upstream fixes merged after the
+supported PynamoDB release (for example [#1302](https://github.com/pynamodb/PynamoDB/pull/1302))
+until upstream ships them.
+
+## Contributing
+
+The code here is generated from a private source repository. Please open issues in this
+repository; pull requests are ported over by hand.
+
+## License
+
+MIT, derived from PynamoDB. See `LICENSE`.

pynamodb_async-0.1.0/README.md

@@ -0,0 +1,66 @@
+# pynamodb-async
+
+A native asyncio API for [PynamoDB](https://github.com/pynamodb/PynamoDB), built on
+[aiobotocore](https://github.com/aio-libs/aiobotocore). It runs next to official PynamoDB:
+you keep using PynamoDB's attributes, indexes and expressions, and get awaitable models,
+queries, batches and transactions.
+
+```
+pip install pynamodb-async
+```
+
+Needs Python 3.10+. This installs official `pynamodb` (6.1.x) and `aiobotocore`.
+
+## Usage
+
+Declare a model with `Model` from `pynamodb_async.models` and attributes from `pynamodb.attributes`:
+
+```python
+import pynamodb_async
+from pynamodb.attributes import UnicodeAttribute
+from pynamodb_async.models import Model
+
+
+class User(Model):
+    class Meta:
+        table_name = "users"
+        region = "us-east-1"
+
+    email = UnicodeAttribute(hash_key=True)
+    name = UnicodeAttribute(null=True)
+
+
+async def main():
+    async with pynamodb_async.connections():
+        await User("ada@example.com", name="Ada").save()
+        user = await User.get("ada@example.com")
+        async for u in User.query("ada@example.com"):
+            print(u.name)
+```
+
+## Closing clients and event loops
+
+Every async client holds an HTTP session. Close it when you are done with
+`await User.close()`, or wrap your code in `async with pynamodb_async.connections():`, which
+closes every connection opened inside the block. A client belongs to the event loop that
+created it, so use each model and `Connection` from one event loop at a time, and prefer one
+long-lived event loop for the whole program.
+
+## Relationship to PynamoDB
+
+This package works alongside official PynamoDB. Its code is generated from a private source
+repository, a fork that also offers the same async API as a drop-in replacement for `pynamodb`.
+This add-on has its own async `Connection.get_client()`. What it does not have are the fork's
+sync additions: `pynamodb.models.Model.close()`, `pynamodb.connections()` and the sync
+`pynamodb.connection.Connection.get_client()`. It also lacks upstream fixes merged after the
+supported PynamoDB release (for example [#1302](https://github.com/pynamodb/PynamoDB/pull/1302))
+until upstream ships them.
+
+## Contributing
+
+The code here is generated from a private source repository. Please open issues in this
+repository; pull requests are ported over by hand.
+
+## License
+
+MIT, derived from PynamoDB. See `LICENSE`.

pynamodb_async-0.1.0/RELEASE_NOTES.rst

@@ -0,0 +1,21 @@
+Release Notes
+=============
+
+v0.1.0
+------
+
+First release of ``pynamodb-async``: a native asyncio API for PynamoDB, built on aiobotocore.
+Requires Python 3.10+, official ``pynamodb>=6.1,<6.2`` and ``aiobotocore>=2.13.0``.
+
+* ``pynamodb_async.models.Model`` with awaitable ``get``, ``save``, ``update``, ``delete``,
+  ``refresh``, ``count`` and table operations; ``query``, ``scan`` and ``batch_get`` return
+  async iterators; ``batch_write()`` is an async context manager.
+* Async transactions: ``pynamodb_async.transactions.TransactGet`` / ``TransactWrite``.
+* Close clients with ``await Model.close()`` or ``async with pynamodb_async.connections():``.
+  Models with the same settings on the same event loop share one client.
+
+Known limitations:
+
+* Use each model and connection from one event loop at a time.
+* No built-in concurrency yet (for example parallel scan); gather independent operations
+  yourself.

pynamodb_async-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.24", "hatch-vcs>=0.5", "setuptools-scm>=10"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pynamodb-async"
+dynamic = ["version"]
+description = "Native asyncio API for PynamoDB, built on aiobotocore"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = ["pynamodb>=6.1,<6.2", "aiobotocore>=2.13.0"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Source = "https://github.com/zeroae/pynamodb-async"
+Issues = "https://github.com/zeroae/pynamodb-async/issues"
+PynamoDB = "https://github.com/pynamodb/PynamoDB"
+
+[dependency-groups]
+test = ["pytest>=7", "pytest-asyncio>=0.23", "pytest-env", "pytest-mock", "freezegun", "blinker>=1.3,<2.0", "packaging"]
+
+[tool.hatch.version]
+source = "vcs"
+tag-pattern = '^pynamodb-async-v(?P<version>\d+(?:\.\d+)*(?:(?:a|b|rc|\.post|\.dev)\d+)?)$'
+raw-options = { search_parent_directories = true, fallback_version = "0.1.0.dev0", scm = { git = { describe_command = "git describe --dirty --tags --long --match 'pynamodb-async-v*'" } } }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/pynamodb_async/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pynamodb_async"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "scripts", "README.md", "RELEASE_NOTES.rst", "LICENSE", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+markers = ["ddblocal: requires a DynamoDB Local server on localhost:8000"]
+env = ["AWS_ACCESS_KEY_ID=1", "AWS_SECRET_ACCESS_KEY=2", "AWS_DEFAULT_REGION=us-east-1"]

pynamodb_async-0.1.0/scripts/check_dist.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# AUTO-GENERATED from scripts/check_dist.py by scripts/make_addon.py - DO NOT EDIT
+"""Check built distributions before they are released.
+
+    python scripts/check_dist.py DIST_DIR --name zae-pynamodb --package pynamodb \
+        --requires-python '>=3.7' [--min-version 6.2.0.dev0] [--expect-version 6.2.0] \
+        [--sdist-allow 'src/*' ...]
+
+Checks every wheel and sdist in DIST_DIR: project name, Requires-Python, version (at least
+--min-version; exactly --expect-version, with no local part), wheel files limited to the
+package and its .dist-info, and - when --sdist-allow is given - sdist files limited to those
+globs. Prints one "problem: ..." line per issue and exits 1 if there are any.
+"""
+import argparse
+import fnmatch
+import sys
+import tarfile
+import zipfile
+from email.parser import Parser
+from pathlib import Path
+from typing import List, NamedTuple, Optional, Sequence
+
+from packaging.version import Version
+
+
+class Options(NamedTuple):
+    name: str
+    package: str
+    requires_python: str
+    min_version: Optional[str]
+    expect_version: Optional[str]
+    sdist_allow: List[str]
+
+
+def _check_metadata(label: str, text: str, opts: Options) -> List[str]:
+    meta = Parser().parsestr(text)
+    problems = []
+    if meta.get("Name") != opts.name:
+        problems.append("{}: Name is {!r}, expected {!r}".format(label, meta.get("Name"), opts.name))
+    if meta.get("Requires-Python") != opts.requires_python:
+        problems.append("{}: Requires-Python is {!r}, expected {!r}".format(
+            label, meta.get("Requires-Python"), opts.requires_python))
+    version = Version(meta.get("Version", "0"))
+    if opts.min_version and version < Version(opts.min_version):
+        problems.append("{}: version {} is below {}".format(label, version, opts.min_version))
+    if opts.expect_version and (version != Version(opts.expect_version) or version.local):
+        problems.append("{}: version {} is not exactly {}".format(label, version, opts.expect_version))
+    return problems
+
+
+def check_wheel(path: Path, opts: Options) -> List[str]:
+    with zipfile.ZipFile(str(path)) as zf:
+        names = zf.namelist()
+        meta_names = [n for n in names if n.endswith(".dist-info/METADATA")]
+        if not meta_names:
+            return ["{}: no .dist-info/METADATA".format(path.name)]
+        problems = _check_metadata(path.name, zf.read(meta_names[0]).decode("utf-8"), opts)
+    for name in names:
+        top = name.split("/", 1)[0]
+        if top != opts.package and not top.endswith(".dist-info"):
+            problems.append("{}: unexpected file {}".format(path.name, name))
+    return problems
+
+
+def check_sdist(path: Path, opts: Options) -> List[str]:
+    with tarfile.open(str(path), "r:gz") as tf:
+        members = [m for m in tf.getmembers() if m.isfile()]
+        rel = {m.name: m.name.split("/", 1)[1] if "/" in m.name else m.name for m in members}
+        pkg_info = [m for m in members if rel[m.name] == "PKG-INFO"]
+        if not pkg_info:
+            return ["{}: no PKG-INFO".format(path.name)]
+        handle = tf.extractfile(pkg_info[0])
+        problems = _check_metadata(path.name, handle.read().decode("utf-8") if handle else "", opts)
+    if opts.sdist_allow:
+        for full, name in sorted(rel.items()):
+            if not any(fnmatch.fnmatch(name, pattern) for pattern in opts.sdist_allow):
+                problems.append("{}: file not allowed in sdist: {}".format(path.name, name))
+    return problems
+
+
+def main(argv: Sequence[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("dist_dir")
+    parser.add_argument("--name", required=True)
+    parser.add_argument("--package", required=True)
+    parser.add_argument("--requires-python", required=True)
+    parser.add_argument("--min-version")
+    parser.add_argument("--expect-version")
+    parser.add_argument("--sdist-allow", action="append", default=[])
+    args = parser.parse_args(argv)
+    opts = Options(args.name, args.package, args.requires_python,
+                   args.min_version, args.expect_version, args.sdist_allow)
+    dist = Path(args.dist_dir)
+    wheels = sorted(dist.glob("*.whl"))
+    sdists = sorted(dist.glob("*.tar.gz"))
+    problems = []
+    if not wheels:
+        problems.append("no wheel in {}".format(dist))
+    if not sdists:
+        problems.append("no sdist in {}".format(dist))
+    for w in wheels:
+        problems += check_wheel(w, opts)
+    for s in sdists:
+        problems += check_sdist(s, opts)
+    for p in problems:
+        print("problem: " + p)
+    if not problems:
+        print("ok: {} wheel(s), {} sdist(s)".format(len(wheels), len(sdists)))
+    return 1 if problems else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

pynamodb_async-0.1.0/scripts/release_notes.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# AUTO-GENERATED from scripts/release_notes.py by scripts/make_addon.py - DO NOT EDIT
+"""Print the release-notes section for a version from an .rst file.
+
+    python scripts/release_notes.py docs/release_notes.rst 6.2.0 [--output notes.md]
+
+A section starts at a title line ``v<version>`` underlined with a single repeated character
+(``-``, ``=``, ``~`` or ``^``) and runs until the next underlined title. Exits 1 if the
+section is missing or empty, so a release cannot go out without notes.
+"""
+import argparse
+import sys
+from pathlib import Path
+from typing import List, Optional, Sequence
+
+_UNDERLINE_CHARS = "-=~^"
+
+
+def _is_underline(line: str) -> bool:
+    s = line.strip()
+    return len(s) >= 3 and len(set(s)) == 1 and s[0] in _UNDERLINE_CHARS
+
+
+def _is_title(lines: List[str], i: int) -> bool:
+    return (i + 1 < len(lines) and bool(lines[i].strip())
+            and not _is_underline(lines[i]) and _is_underline(lines[i + 1]))
+
+
+def extract(text: str, version: str) -> Optional[str]:
+    lines = text.splitlines()
+    title = "v" + version
+    start = None
+    for i in range(len(lines)):
+        if lines[i].strip() == title and _is_title(lines, i):
+            start = i + 2
+            break
+    if start is None:
+        return None
+    end = len(lines)
+    for j in range(start, len(lines)):
+        if _is_title(lines, j):
+            end = j
+            break
+    body = "\n".join(lines[start:end]).strip()
+    return body or None
+
+
+def main(argv: Sequence[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("rst_file")
+    parser.add_argument("version")
+    parser.add_argument("--output")
+    args = parser.parse_args(argv)
+    body = extract(Path(args.rst_file).read_text(encoding="utf-8"), args.version)
+    if body is None:
+        print("no non-empty 'v{}' section in {}".format(args.version, args.rst_file), file=sys.stderr)
+        return 1
+    if args.output:
+        Path(args.output).write_text(body + "\n", encoding="utf-8")
+    else:
+        print(body)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

pynamodb_async-0.1.0/scripts/upstream_watch.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# AUTO-GENERATED from scripts/upstream_watch.py by scripts/make_addon.py - DO NOT EDIT
+"""Check whether the latest official pynamodb release is inside the add-on's supported range.
+
+    python scripts/upstream_watch.py --spec '>=6.1,<6.2'
+
+Prints the latest version. Exit 0 when it is supported, 2 when it is outside the range (the
+weekly workflow then opens an issue to port the change and widen the range), 1 on errors.
+"""
+import argparse
+import json
+import sys
+from typing import Callable, Sequence
+from urllib.request import urlopen
+
+from packaging.specifiers import SpecifierSet
+from packaging.version import Version
+
+PYPI_URL = "https://pypi.org/pypi/pynamodb/json"
+
+
+def is_supported(version: str, spec: str) -> bool:
+    return Version(version) in SpecifierSet(spec)
+
+
+def latest_release() -> str:
+    with urlopen(PYPI_URL, timeout=30) as response:
+        return json.load(response)["info"]["version"]
+
+
+def main(argv: Sequence[str], latest: Callable[[], str] = latest_release) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--spec", required=True)
+    args = parser.parse_args(argv)
+    try:
+        version = latest()
+    except Exception as e:
+        print("error: could not read the latest pynamodb release: {}".format(e), file=sys.stderr)
+        return 1
+    print(version)
+    return 0 if is_supported(version, args.spec) else 2
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

pynamodb_async-0.1.0/src/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']