dycw-utilities 0.153.7__tar.gz → 0.153.8__tar.gz

{dycw_utilities-0.153.7 → dycw_utilities-0.153.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.153.7
+Version: 0.153.8
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.153.7 → dycw_utilities-0.153.8}/pyproject.toml

@@ -229,7 +229,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.153.7"
+version = "0.153.8"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -262,7 +262,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.153.7"
+current_version = "0.153.8"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.153.7 → dycw_utilities-0.153.8}/src/tests/conftest.py

@@ -114,42 +114,61 @@ def test_engine(*, request: SubRequest, tmp_path: Path) -> Engine:
 
 
 @fixture(params=[param("sqlite"), param("postgresql", marks=SKIPIF_CI)])
-async def test_async_engine(*, request: SubRequest, tmp_path: Path) -> AsyncEngine:
-    from utilities.sqlalchemy import create_engine
-
+async def test_async_engine(
+    *,
+    request: SubRequest,
+    test_async_sqlite_engine: AsyncEngine,
+    test_async_postgres_engine: AsyncEngine,
+) -> AsyncEngine:
     dialect = request.param
     match dialect:
         case "sqlite":
-            db_path = tmp_path / "db.sqlite"
-            return create_engine("sqlite+aiosqlite", database=str(db_path), async_=True)
+            return test_async_sqlite_engine
         case "postgresql":
-            from asyncpg.exceptions import InvalidCatalogNameError
-
-            engine = create_engine(
-                "postgresql+asyncpg",
-                host="localhost",
-                port=5432,
-                database="testing",
-                async_=True,
-            )
-            try:
-                async with engine.begin() as conn:
-                    tables: Sequence[str] = (
-                        (await conn.execute(_select_tables())).scalars().all()
-                    )
-            except InvalidCatalogNameError:
-                ...
-            else:
-                for table in filter(_is_to_drop, tables):
-                    async with engine.begin() as conn:
-                        with suppress(Exception):
-                            _ = await conn.execute(_drop_table(table))
-            return engine
+            return test_async_postgres_engine
         case _:
             msg = f"Unsupported dialect: {dialect}"
             raise NotImplementedError(msg)
 
 
+@fixture
+async def test_async_sqlite_engine(*, tmp_path: Path) -> AsyncEngine:
+    from utilities.sqlalchemy import create_engine
+
+    db_path = tmp_path / "db.sqlite"
+    return create_engine("sqlite+aiosqlite", database=str(db_path), async_=True)
+
+
+@fixture
+async def test_async_postgres_engine() -> AsyncEngine:
+    from asyncpg.exceptions import InvalidCatalogNameError
+
+    from utilities.sqlalchemy import create_engine
+
+    if IS_CI:
+        skip(reason="Skipped for CI")
+    engine = create_engine(
+        "postgresql+asyncpg",
+        host="localhost",
+        port=5432,
+        database="testing",
+        async_=True,
+    )
+    try:
+        async with engine.begin() as conn:
+            tables: Sequence[str] = (
+                (await conn.execute(_select_tables())).scalars().all()
+            )
+    except InvalidCatalogNameError:
+        ...
+    else:
+        for table in filter(_is_to_drop, tables):
+            async with engine.begin() as conn:
+                with suppress(Exception):
+                    _ = await conn.execute(_drop_table(table))
+    return engine
+
+
 def _is_to_drop(table: str, /) -> bool:
     try:
         datetime_str = extract_group(r"^(\d{8}T\d{6})_", table)

{dycw_utilities-0.153.7 → dycw_utilities-0.153.8}/src/tests/test_sqlalchemy.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+from asyncio import sleep
 from enum import Enum, StrEnum, auto
+from getpass import getuser
 from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal, cast, overload, override
 from uuid import uuid4
@@ -29,6 +31,7 @@ from sqlalchemy.orm import (
     relationship,
 )
 
+from tests.conftest import SKIPIF_CI
 from utilities.hypothesis import int32s, pairs, urls
 from utilities.iterables import one
 from utilities.modules import is_installed
@@ -72,6 +75,8 @@ from utilities.sqlalchemy import (
     columnwise_max,
     columnwise_min,
     create_engine,
+    ensure_database_created,
+    ensure_database_dropped,
     ensure_tables_created,
     ensure_tables_dropped,
     enum_name,
@@ -253,6 +258,35 @@ class TestCreateEngine:
         assert isinstance(engine, cls)
 
 
+@SKIPIF_CI
+class TestEnsureDatabaseCreatedAndDropped:
+    async def test_main(self) -> None:
+        url = URL.create(
+            "postgresql+asyncpg",
+            username=getuser(),
+            password="password",  # noqa: S106
+            host="localhost",
+            port=5432,
+            database="postgres",
+        )
+        database = f"testing_{_table_names()}"
+        for _ in range(2):
+            await ensure_database_created(url, database)
+            await sleep(0.1)
+        for _ in range(2):
+            await ensure_database_dropped(url, database)
+            await sleep(0.1)
+
+    async def _run_test(
+        self, engine: AsyncEngine, table_or_orm: TableOrORMInstOrClass, /
+    ) -> None:
+        for _ in range(2):
+            await ensure_tables_created(engine, table_or_orm)
+        sel = select(get_table(table_or_orm))
+        async with engine.begin() as conn:
+            _ = (await conn.execute(sel)).all()
+
+
 class TestEnsureTablesCreated:
     async def test_table(self, *, test_async_engine: AsyncEngine) -> None:
         table = Table(

{dycw_utilities-0.153.7 → dycw_utilities-0.153.8}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.153.7"
+__version__ = "0.153.8"

{dycw_utilities-0.153.7 → dycw_utilities-0.153.8}/src/utilities/sqlalchemy.py

@@ -30,7 +30,6 @@ from typing import (
 )
 
 import sqlalchemy
-import sqlalchemy.ext.asyncio
 from sqlalchemy import (
     URL,
     Column,
@@ -63,7 +62,7 @@ from sqlalchemy.exc import (
     OperationalError,
     ProgrammingError,
 )
-from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, create_async_engine
 from sqlalchemy.orm import (
     DeclarativeBase,
     InstrumentedAttribute,
@@ -311,7 +310,7 @@ def create_engine(
         case False:
             return sqlalchemy.create_engine(url, poolclass=poolclass)
         case True:
-            return sqlalchemy.ext.asyncio.create_async_engine(url, poolclass=poolclass)
+            return create_async_engine(url, poolclass=poolclass)
         case never:
             assert_never(never)
 
@@ -319,6 +318,27 @@ def create_engine(
 ##
 
 
+async def ensure_database_created(super_: URL, database: str, /) -> None:
+    """Ensure a database is created."""
+    engine = create_async_engine(super_, isolation_level="AUTOCOMMIT")
+    async with engine.begin() as conn:
+        try:
+            _ = await conn.execute(text(f"CREATE DATABASE {database}"))
+        except (OperationalError, ProgrammingError) as error:
+            if not search('database ".*" already exists', ensure_str(one(error.args))):
+                raise
+
+
+async def ensure_database_dropped(super_: URL, database: str, /) -> None:
+    """Ensure a database is dropped."""
+    engine = create_async_engine(super_, isolation_level="AUTOCOMMIT")
+    async with engine.begin() as conn:
+        _ = await conn.execute(text(f"DROP DATABASE IF EXISTS {database}"))
+
+
+##
+
+
 async def ensure_tables_created(
     engine: AsyncEngine,
     /,
@@ -1284,6 +1304,8 @@ __all__ = [
     "columnwise_max",
     "columnwise_min",
     "create_engine",
+    "ensure_database_created",
+    "ensure_database_dropped",
     "ensure_tables_created",
     "ensure_tables_dropped",
     "enum_name",