dycw-utilities 0.149.10__tar.gz → 0.150.0__tar.gz

{dycw_utilities-0.149.10 → dycw_utilities-0.150.0}/PKG-INFO

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

{dycw_utilities-0.149.10 → dycw_utilities-0.150.0}/pyproject.toml

@@ -83,7 +83,7 @@ scipy = ["scipy >= 1.16.0, < 1.17"]
 sklearn = ["scikit-learn >= 1.7.0, < 1.8"]
 slack-sdk = ["slack-sdk >= 3.36.0, < 3.37"]
 slack-sdk-test = ["aiohttp"]
-sqlalchemy = ["sqlalchemy >= 2.0.41, < 2.1"]
+sqlalchemy = ["sqlalchemy >= 2.0.41, < 2.1", "psycopg"]
 sqlalchemy-polars = ["sqlalchemy", "polars"]
 sqlalchemy-polars-test = ["aiosqlite", "asyncpg", "greenlet"]
 sqlalchemy-test = ["aiosqlite", "asyncpg", "greenlet"]
@@ -103,7 +103,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.149.10"
+version = "0.150.0"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -136,7 +136,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.149.10"
+current_version = "0.150.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.149.10 → dycw_utilities-0.150.0}/src/tests/conftest.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from asyncio import sleep
 from contextlib import AbstractContextManager, suppress
 from logging import LogRecord, setLogRecordFactory
 from os import environ
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from hypothesis import HealthCheck
 from pytest import fixture, mark, param, skip
@@ -22,6 +21,8 @@ if TYPE_CHECKING:
 
     from _pytest.fixtures import SubRequest
     from redis.asyncio import Redis
+    from sqlalchemy import Engine, TextClause
+    from sqlalchemy.ext.asyncio import AsyncEngine
 
 
 FLAKY = mark.flaky(reruns=5, reruns_delay=1)
@@ -81,31 +82,68 @@ async def test_redis() -> AsyncIterator[Redis]:
 
 
 @fixture(params=[param("sqlite"), param("postgresql", marks=SKIPIF_CI)])
-async def test_engine(*, request: SubRequest, tmp_path: Path) -> Any:
-    from sqlalchemy import text
+def test_engine(*, request: SubRequest, tmp_path: Path) -> Engine:
+    from sqlalchemy.exc import OperationalError
 
-    from utilities.sqlalchemy import create_async_engine
+    from utilities.sqlalchemy import create_engine
 
     dialect = request.param
     match dialect:
         case "sqlite":
             db_path = tmp_path / "db.sqlite"
-            return create_async_engine("sqlite+aiosqlite", database=str(db_path))
+            return create_engine("sqlite", database=str(db_path))
         case "postgresql":
-            engine = create_async_engine(
-                "postgresql+asyncpg", host="localhost", port=5432, database="testing"
+            engine = create_engine(
+                "postgresql+psycopg", host="localhost", port=5432, database="testing"
             )
-            query = text("SELECT tablename FROM pg_tables")
-            async with engine.begin() as conn:
-                tables: Sequence[str] = (await conn.execute(query)).scalars().all()
-            for table in tables:
-                if _is_to_drop(table):
+            try:
+                with engine.begin() as conn:
+                    tables: Sequence[str] = (
+                        conn.execute(_select_tables()).scalars().all()
+                    )
+            except OperationalError:
+                ...
+            else:
+                for table in filter(_is_to_drop, tables):
+                    with engine.begin() as conn, suppress(Exception):
+                        _ = conn.execute(_drop_table(table))
+            return engine
+        case _:
+            msg = f"Unsupported dialect: {dialect}"
+            raise NotImplementedError(msg)
+
+
+@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
+
+    dialect = request.param
+    match dialect:
+        case "sqlite":
+            db_path = tmp_path / "db.sqlite"
+            return create_engine("sqlite+aiosqlite", database=str(db_path), async_=True)
+        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(
-                                text(f'DROP TABLE IF EXISTS "{table}" CASCADE')
-                            )
-                        await sleep(0.01)
+                            _ = await conn.execute(_drop_table(table))
             return engine
         case _:
             msg = f"Unsupported dialect: {dialect}"
@@ -122,3 +160,15 @@ def _is_to_drop(table: str, /) -> bool:
     )
     now = get_now()
     return (now - datetime) >= MINUTE
+
+
+def _select_tables() -> TextClause:
+    from sqlalchemy import text
+
+    return text("SELECT tablename FROM pg_tables")
+
+
+def _drop_table(table: str, /) -> TextClause:
+    from sqlalchemy import text
+
+    return text(f'DROP TABLE IF EXISTS "{table}" CASCADE')

{dycw_utilities-0.149.10 → dycw_utilities-0.150.0}/src/tests/test_pottery.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from asyncio import TaskGroup
+from contextvars import ContextVar
 from typing import TYPE_CHECKING, ClassVar
 
 from pottery import AIORedlock
@@ -39,16 +40,27 @@ class TestTryYieldCoroutineLooper:
     delta: ClassVar[TimeDelta] = 0.1 * SECOND
 
     @mark.parametrize("use_logger", [param(True), param(False)])
+    @mark.parametrize("use_context", [param(True), param(False)])
     async def test_main(
-        self, *, caplog: LogCaptureFixture, use_logger: bool, test_redis: Redis
+        self,
+        *,
+        caplog: LogCaptureFixture,
+        use_logger: bool,
+        use_context: bool,
+        test_redis: Redis,
     ) -> None:
         caplog.set_level("DEBUG", logger=(name := unique_str()))
         lst: list[None] = []
         logger = name if use_logger else None
+        context = ContextVar(unique_str(), default=False) if use_context else None
 
         async with TaskGroup() as tg:
-            _ = tg.create_task(self.now(test_redis, name, lst, logger=logger))
-            _ = tg.create_task(self.delayed(test_redis, name, lst, logger=logger))
+            _ = tg.create_task(
+                self.now(test_redis, name, lst, logger=logger, context=context)
+            )
+            _ = tg.create_task(
+                self.delayed(test_redis, name, lst, logger=logger, context=context)
+            )
 
         assert len(lst) == 1
         if use_logger:
@@ -68,9 +80,10 @@ class TestTryYieldCoroutineLooper:
         /,
         *,
         logger: LoggerOrName | None = None,
+        context: ContextVar[bool] | None = None,
     ) -> None:
         async with try_yield_coroutine_looper(
-            redis, key, timeout_acquire=self.delta, logger=logger
+            redis, key, timeout_acquire=self.delta, logger=logger, context=context
         ) as looper:
             if looper is not None:
                 assert await looper(self.func_main, lst)
@@ -83,9 +96,10 @@ class TestTryYieldCoroutineLooper:
         /,
         *,
         logger: LoggerOrName | None = None,
+        context: ContextVar[bool] | None = None,
     ) -> None:
         await sleep_td(self.delta)
-        await self.now(redis, key, lst, logger=logger)
+        await self.now(redis, key, lst, logger=logger, context=context)
 
     @mark.parametrize("use_logger", [param(True), param(False)])
     async def test_error(