apppy-db 0.1.0__tar.gz

apppy_db-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+__generated__/
+dist/
+*.egg-info
+.env
+.env.*
+*.env
+!.env.ci
+.file_store/
+*.pid
+.python-version
+*.secrets
+.secrets
+*.tar.gz
+*.test_output/
+.test_output/
+uv.lock
+*.whl
+
+# System files
+__pycache__
+.DS_Store
+
+# Editor files
+*.sublime-project
+*.sublime-workspace
+.vscode/*
+!.vscode/settings.json
+

apppy_db-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: apppy-db
+Version: 0.1.0
+Summary: Python database definitions for server development
+Project-URL: Homepage, https://github.com/spals/apppy
+Author: Tim Kral
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: apppy-env>=0.1.0
+Requires-Dist: apppy-logger>=0.1.0
+Requires-Dist: fastapi-lifespan-manager==0.1.4
+Requires-Dist: psycopg-pool==3.2.2
+Requires-Dist: psycopg[binary]==3.1.19

apppy_db-0.1.0/db.mk

@@ -0,0 +1,23 @@
+ifndef APPPY_DB_MK_INCLUDED
+APPPY_DB_MK_INCLUDED := 1
+DB_PKG_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
+
+.PHONY: db db-dev db/build db/clean db/install db/install-dev
+
+db: db/clean db/install
+
+db-dev: db/clean db/install-dev
+
+db/build:
+	cd $(DB_PKG_DIR) && uvx --from build pyproject-build
+
+db/clean:
+	cd $(DB_PKG_DIR) && rm -rf dist/ *.egg-info .venv
+
+db/install: db/build
+	cd $(DB_PKG_DIR) && uv pip install dist/*.whl
+
+db/install-dev:
+	cd $(DB_PKG_DIR) && uv pip install -e .
+
+endif # APPPY_DB_MK_INCLUDED

apppy_db-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "apppy-db"
+version = "0.1.0"
+description = "Python database definitions for server development"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [{ name = "Tim Kral" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "apppy-env>=0.1.0",
+    "apppy-logger>=0.1.0",
+    "fastapi-lifespan-manager==0.1.4",
+    "psycopg[binary]==3.1.19",
+    "psycopg-pool==3.2.2"
+]
+
+[project.urls]
+Homepage = "https://github.com/spals/apppy"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/apppy"]

apppy_db-0.1.0/src/apppy/db/migrations.py

@@ -0,0 +1,12 @@
+import abc
+
+
+class Migrations(abc.ABC):
+    @abc.abstractmethod
+    async def head(self) -> str | None:
+        pass
+
+
+class DefaultMigrations(Migrations):
+    async def head(self) -> str | None:
+        return None

apppy_db-0.1.0/src/apppy/db/postgres.py

@@ -0,0 +1,73 @@
+import psycopg
+from fastapi_lifespan_manager import LifespanManager
+from psycopg.rows import DictRow, dict_row
+from psycopg_pool.pool_async import AsyncConnectionPool as DBConnAsyncPool
+from pydantic import Field
+
+from apppy.env import EnvSettings
+from apppy.logger import WithLogger
+
+
+class PostgresClientSettings(EnvSettings):
+    db_conn: str = Field(alias="APP_POSTGRES_DB_CONN")
+    db_host: str = Field(alias="APP_POSTGRES_DB_HOST")
+    db_password: str = Field(alias="APP_POSTGRES_DB_PASSWORD", exclude=True)
+
+    db_pool_min_size: int = Field(alias="APP_POSTGRES_DB_POOL_MIN_SIZE", default=4)
+    db_pool_max_size: int | None = Field(alias="APP_POSTGRES_DB_POOL_MAX_SIZE", default=None)
+    db_pool_timeout: float = Field(alias="APP_POSTGRES_DB_POOL_TIMEOUT", default=30)
+
+
+class PostgresClient(WithLogger):
+    def __init__(self, settings: PostgresClientSettings, lifespan: LifespanManager) -> None:
+        self._settings = settings
+
+        self._conninfo: str = (
+            f"host={settings.db_host} password={settings.db_password} {settings.db_conn}"
+        )
+        self._db_pool_async: DBConnAsyncPool | None = None
+        lifespan.add(self.__open_db_pool_async)
+
+    async def __open_db_pool_async(self):
+        self._logger.info("Opening Postgres psycopg_pool_async")
+        if not self._db_pool_async or self._db_pool_async.closed:
+            self._db_pool_async = DBConnAsyncPool(
+                conninfo=self._conninfo,
+                open=False,
+                min_size=self._settings.db_pool_min_size,
+                max_size=self._settings.db_pool_max_size,
+                timeout=self._settings.db_pool_timeout,
+            )
+            self._logger.info(
+                "Opened Postgres psycopg_pool_async",
+                extra={
+                    "min_size": self._settings.db_pool_min_size,
+                    "max_size": self._settings.db_pool_max_size,
+                },
+            )
+
+        await self._db_pool_async.open(wait=True)
+        yield {"db_pool_async": self._db_pool_async}
+
+        self._logger.info("Closing Postgres psycopg_pool_async")
+        try:
+            await self._db_pool_async.close()
+        except Exception:
+            self._logger.exception("Error while closing Postgres psycopg_pool_async")
+
+    @property
+    def db_pool_async(self) -> DBConnAsyncPool:
+        if self._db_pool_async is None:
+            raise Exception("Postgres db_pool_async is uninitialized")
+
+        return self._db_pool_async
+
+    async def db_query_async(self, query: str, params: dict | None = None) -> list[DictRow]:
+        async with (
+            self.db_pool_async.connection() as db_conn,
+            psycopg.AsyncClientCursor(db_conn, row_factory=dict_row) as db_cursor_async,
+        ):
+            await db_cursor_async.execute(query=query, params=params)
+            result_set = await db_cursor_async.fetchall()
+
+            return result_set