sql-athame 0.4.0a10__tar.gz → 0.4.0a12__tar.gz

sql_athame-0.4.0a12/.bumpversion.cfg

@@ -0,0 +1,19 @@
+[bumpversion]
+current_version = 0.4.0-alpha-12
+parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(-(?P<release>.*)-(?P<build>\d+))?
+serialize = 
+	{major}.{minor}.{patch}-{release}-{build}
+	{major}.{minor}.{patch}
+commit = True
+
+[bumpversion:file:pyproject.toml]
+
+[bumpversion:part:release]
+first_value = regular
+optional_value = regular
+values = 
+	alpha
+	beta
+	rc
+	test
+	regular

sql_athame-0.4.0a12/.editorconfig

@@ -0,0 +1,7 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4

sql_athame-0.4.0a12/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: publish
+
+on:
+  push:
+    tags:
+      - 'v**'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    env:
+      UV_PUBLISH_TOKEN: ${{ secrets.POETRY_PYPI_TOKEN_PYPI }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.6.6"
+          enable-cache: true
+          python-version: '3.12'
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - run: uv build
+      - run: uv publish

sql_athame-0.4.0a12/.github/workflows/test.yml

@@ -0,0 +1,49 @@
+name: test
+
+on:
+  push:
+    branches:
+      - '**'
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        python-version:
+          - '3.9'
+          - '3.10'
+          - '3.11'
+          - '3.12'
+          - '3.13'
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:16
+        ports:
+          - 5432:5432
+        env:
+          POSTGRES_PASSWORD: password
+    env:
+      PGPORT: 5432
+      UV_LOCKED: 1
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.6.6"
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - run: uv sync
+      - run: uv run ruff check
+      - run: uv run ruff format --diff
+        if: success() || failure()
+      - run: uv run mypy sql_athame/**.py tests/**.py
+        if: success() || failure()
+      - run: uv run pytest
+        if: success() || failure()

sql_athame-0.4.0a12/.gitignore

@@ -0,0 +1,9 @@
+*.egg-info
+.*_cache
+.coverage
+.venv
+__pycache__
+pip-wheel-metadata
+
+/dist
+/results

{sql_athame-0.4.0a10 → sql_athame-0.4.0a12}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019, 2020 Brian Downing
+Copyright (c) 2019-2025 Brian Downing
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{sql_athame-0.4.0a10 → sql_athame-0.4.0a12}/PKG-INFO

@@ -1,22 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sql-athame
-Version: 0.4.0a10
+Version: 0.4.0a12
 Summary: Python tool for slicing and dicing SQL
-Home-page: https://github.com/bdowning/sql-athame
+Project-URL: homepage, https://github.com/bdowning/sql-athame
+Project-URL: repository, https://github.com/bdowning/sql-athame
+Author-email: Brian Downing <bdowning@lavos.net>
 License: MIT
-Author: Brian Downing
-Author-email: bdowning@lavos.net
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: asyncpg
-Requires-Dist: asyncpg ; extra == "asyncpg"
+License-File: LICENSE
+Requires-Python: <4.0,>=3.9
 Requires-Dist: typing-extensions
-Project-URL: Repository, https://github.com/bdowning/sql-athame
+Provides-Extra: asyncpg
+Requires-Dist: asyncpg; extra == 'asyncpg'
 Description-Content-Type: text/markdown
 
 # sql-athame
@@ -404,5 +398,4 @@ TODO, for now read the [source](sql_athame/dataclasses.py).
 MIT.
 
 ---
-Copyright (c) 2019, 2020 Brian Downing
-
+Copyright (c) 2019–2025 Brian Downing

{sql_athame-0.4.0a10 → sql_athame-0.4.0a12}/README.md

@@ -383,4 +383,4 @@ TODO, for now read the [source](sql_athame/dataclasses.py).
 MIT.
 
 ---
-Copyright (c) 2019, 2020 Brian Downing
+Copyright (c) 2019–2025 Brian Downing

sql_athame-0.4.0a12/docker-compose.yml

@@ -0,0 +1,9 @@
+version: "2"
+
+services:
+  postgres:
+    image: postgres:12
+    ports:
+      - 29329:5432
+    environment:
+      POSTGRES_PASSWORD: password

{sql_athame-0.4.0a10 → sql_athame-0.4.0a12}/pyproject.toml

@@ -1,37 +1,42 @@
-[tool.poetry]
+[project]
+authors = [
+    {name = "Brian Downing", email = "bdowning@lavos.net"},
+]
+license = {text = "MIT"}
+requires-python = "<4.0,>=3.9"
+dependencies = [
+    "typing-extensions",
+]
 name = "sql-athame"
-version = "0.4.0-alpha-10"
+version = "0.4.0-alpha-12"
 description = "Python tool for slicing and dicing SQL"
-authors = ["Brian Downing <bdowning@lavos.net>"]
-license = "MIT"
 readme = "README.md"
+
+[project.urls]
 homepage = "https://github.com/bdowning/sql-athame"
 repository = "https://github.com/bdowning/sql-athame"
 
-[tool.poetry.extras]
-asyncpg = ["asyncpg"]
-
-[tool.poetry.dependencies]
-python = "^3.9"
-asyncpg = { version = "*", optional = true }
-typing-extensions = "*"
+[project.optional-dependencies]
+asyncpg = [
+    "asyncpg",
+]
 
-[tool.poetry.group.dev.dependencies]
-pytest = "*"
-mypy = "*"
-flake8 = "*"
-ipython = "*"
-pytest-cov = "*"
-bump2version = "*"
-asyncpg = "*"
-pytest-asyncio = "*"
-grip = "*"
-SQLAlchemy = "*"
-ruff = "*"
+[dependency-groups]
+dev = [
+    "SQLAlchemy",
+    "asyncpg",
+    "bump2version",
+    "ipython",
+    "mypy",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "ruff",
+]
 
 [build-system]
-requires = ["poetry>=0.12"]
-build-backend = "poetry.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
 [tool.ruff]
 target-version = "py39"
@@ -60,9 +65,6 @@ select = [
 flake8-comprehensions.allow-dict-calls-with-keyword-arguments = true
 ignore = [
     "E501",    # line too long
-    "E721",    # type checks, currently broken
-    "ISC001",  # conflicts with ruff format
-    "PT004",   # Fixture `...` does not return anything, add leading underscore
     "RET505",  # Unnecessary `else` after `return` statement
     "RET506",  # Unnecessary `else` after `raise` statement
 ]

sql_athame-0.4.0a12/run

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+usage=()
+
+usage+=("  $0 tests - run tests")
+tests() {
+    uv run pytest "$@"
+    lint
+}
+
+usage+=("  $0 refmt - reformat code")
+refmt() {
+    uv run ruff check --select I --fix
+    uv run ruff format
+}
+
+usage+=("  $0 lint - run linting")
+lint() {
+    uv run ruff check
+    uv run ruff format --diff
+    uv run mypy sql_athame/**.py tests/**.py
+}
+
+usage+=("  $0 bump2version {major|minor|patch} - bump version number")
+bump2version() {
+    uv run bump2version "$@"
+}
+
+cmd=$1
+shift
+
+if ! declare -f "$cmd" >/dev/null; then
+    echo "Usage:"
+    for line in "${usage[@]}"; do echo "$line"; done
+    exit 1
+fi
+
+set -o xtrace
+
+"$cmd" "$@"

{sql_athame-0.4.0a10 → sql_athame-0.4.0a12}/sql_athame/dataclasses.py

@@ -157,7 +157,7 @@ class ModelBase:
     _cache: dict[tuple, Any]
     table_name: str
     primary_key_names: tuple[str, ...]
-    array_safe_insert: bool
+    insert_multiple_mode: str
 
     def __init_subclass__(
         cls,
@@ -169,12 +169,9 @@ class ModelBase:
     ):
         cls._cache = {}
         cls.table_name = table_name
-        if insert_multiple_mode == "array_safe":
-            cls.array_safe_insert = True
-        elif insert_multiple_mode == "unnest":
-            cls.array_safe_insert = False
-        else:
+        if insert_multiple_mode not in ("array_safe", "unnest", "executemany"):
             raise ValueError("Unknown `insert_multiple_mode`")
+        cls.insert_multiple_mode = insert_multiple_mode
         if isinstance(primary_key, str):
             cls.primary_key_names = (primary_key,)
         else:
@@ -233,8 +230,21 @@ class ModelBase:
 
     @classmethod
     def field_names_sql(
-        cls, *, prefix: Optional[str] = None, exclude: FieldNamesSet = ()
+        cls,
+        *,
+        prefix: Optional[str] = None,
+        exclude: FieldNamesSet = (),
+        as_prepended: Optional[str] = None,
     ) -> list[Fragment]:
+        if as_prepended:
+            return [
+                sql(
+                    "{} AS {}",
+                    sql.identifier(f, prefix=prefix),
+                    sql.identifier(f"{as_prepended}{f}"),
+                )
+                for f in cls.field_names(exclude=exclude)
+            ]
         return [
             sql.identifier(f, prefix=prefix) for f in cls.field_names(exclude=exclude)
         ]
@@ -303,6 +313,16 @@ class ModelBase:
         cls.from_mapping = from_mapping_fn  # type: ignore
         return from_mapping_fn(mapping)
 
+    @classmethod
+    def from_prepended_mapping(
+        cls: type[T], mapping: Mapping[str, Any], prepend: str
+    ) -> T:
+        filtered_dict: dict[str, Any] = {}
+        for k, v in mapping.items():
+            if k.startswith(prepend):
+                filtered_dict[k[len(prepend) :]] = v
+        return cls.from_mapping(filtered_dict)
+
     @classmethod
     def ensure_model(cls: type[T], row: Union[T, Mapping[str, Any]]) -> T:
         if isinstance(row, cls):
@@ -357,7 +377,17 @@ class ModelBase:
         return query
 
     @classmethod
-    async def select_cursor(
+    async def cursor_from(
+        cls: type[T],
+        connection: Connection,
+        query: Fragment,
+        prefetch: int = 1000,
+    ) -> AsyncGenerator[T, None]:
+        async for row in connection.cursor(*query, prefetch=prefetch):
+            yield cls.from_mapping(row)
+
+    @classmethod
+    def select_cursor(
         cls: type[T],
         connection: Connection,
         order_by: Union[FieldNames, str] = (),
@@ -365,11 +395,19 @@ class ModelBase:
         where: Where = (),
         prefetch: int = 1000,
     ) -> AsyncGenerator[T, None]:
-        async for row in connection.cursor(
-            *cls.select_sql(order_by=order_by, for_update=for_update, where=where),
+        return cls.cursor_from(
+            connection,
+            cls.select_sql(order_by=order_by, for_update=for_update, where=where),
             prefetch=prefetch,
-        ):
-            yield cls.from_mapping(row)
+        )
+
+    @classmethod
+    async def fetch_from(
+        cls: type[T],
+        connection_or_pool: Union[Connection, Pool],
+        query: Fragment,
+    ) -> list[T]:
+        return [cls.from_mapping(row) for row in await connection_or_pool.fetch(*query)]
 
     @classmethod
     async def select(
@@ -379,12 +417,10 @@ class ModelBase:
         for_update: bool = False,
         where: Where = (),
     ) -> list[T]:
-        return [
-            cls.from_mapping(row)
-            for row in await connection_or_pool.fetch(
-                *cls.select_sql(order_by=order_by, for_update=for_update, where=where)
-            )
-        ]
+        return await cls.fetch_from(
+            connection_or_pool,
+            cls.select_sql(order_by=order_by, for_update=for_update, where=where),
+        )
 
     @classmethod
     def create_sql(cls: type[T], **kwargs: Any) -> Fragment:
@@ -506,6 +542,37 @@ class ModelBase:
             ),
         )
 
+    @classmethod
+    def insert_multiple_executemany_chunk_sql(
+        cls: type[T], chunk_size: int
+    ) -> Fragment:
+        def generate() -> Fragment:
+            columns = len(cls.column_info())
+            values = ", ".join(
+                f"({', '.join(f'${i}' for i in chunk)})"
+                for chunk in chunked(range(1, columns * chunk_size + 1), columns)
+            )
+            return sql(
+                "INSERT INTO {table} ({fields}) VALUES {values}",
+                table=cls.table_name_sql(),
+                fields=sql.list(cls.field_names_sql()),
+                values=sql.literal(values),
+            ).flatten()
+
+        return cls._cached(
+            ("insert_multiple_executemany_chunk", chunk_size),
+            generate,
+        )
+
+    @classmethod
+    async def insert_multiple_executemany(
+        cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+    ) -> None:
+        args = [r.field_values() for r in rows]
+        query = cls.insert_multiple_executemany_chunk_sql(1).query()[0]
+        if args:
+            await connection_or_pool.executemany(query, args)
+
     @classmethod
     async def insert_multiple_unnest(
         cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
@@ -527,11 +594,28 @@ class ModelBase:
     async def insert_multiple(
         cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
-        if cls.array_safe_insert:
+        if cls.insert_multiple_mode == "executemany":
+            await cls.insert_multiple_executemany(connection_or_pool, rows)
+            return "INSERT"
+        elif cls.insert_multiple_mode == "array_safe":
             return await cls.insert_multiple_array_safe(connection_or_pool, rows)
         else:
             return await cls.insert_multiple_unnest(connection_or_pool, rows)
 
+    @classmethod
+    async def upsert_multiple_executemany(
+        cls: type[T],
+        connection_or_pool: Union[Connection, Pool],
+        rows: Iterable[T],
+        insert_only: FieldNamesSet = (),
+    ) -> None:
+        args = [r.field_values() for r in rows]
+        query = cls.upsert_sql(
+            cls.insert_multiple_executemany_chunk_sql(1), exclude=insert_only
+        ).query()[0]
+        if args:
+            await connection_or_pool.executemany(query, args)
+
     @classmethod
     async def upsert_multiple_unnest(
         cls: type[T],
@@ -566,7 +650,12 @@ class ModelBase:
         rows: Iterable[T],
         insert_only: FieldNamesSet = (),
     ) -> str:
-        if cls.array_safe_insert:
+        if cls.insert_multiple_mode == "executemany":
+            await cls.upsert_multiple_executemany(
+                connection_or_pool, rows, insert_only=insert_only
+            )
+            return "INSERT"
+        elif cls.insert_multiple_mode == "array_safe":
             return await cls.upsert_multiple_array_safe(
                 connection_or_pool, rows, insert_only=insert_only
             )