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

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

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

{dycw_utilities-0.153.6 → 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.6"
+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.6"
+current_version = "0.153.8"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.153.6 → 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.6 → dycw_utilities-0.153.8}/src/tests/test_functions.py

@@ -6,6 +6,8 @@ from functools import cache, cached_property, lru_cache, partial, wraps
 from itertools import chain
 from operator import neg
 from pathlib import Path
+from subprocess import check_output
+from sys import executable
 from types import NoneType
 from typing import TYPE_CHECKING, Any, ClassVar, cast
 
@@ -22,7 +24,7 @@ from hypothesis.strategies import (
     permutations,
     sampled_from,
 )
-from pytest import raises
+from pytest import mark, param, raises
 
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import (
@@ -95,6 +97,7 @@ from utilities.functions import (
     yield_object_properties,
 )
 from utilities.sentinel import sentinel
+from utilities.text import parse_bool, strip_and_dedent
 from utilities.whenever import NOW_UTC, ZERO_TIME, get_now, get_today
 
 if TYPE_CHECKING:
@@ -131,40 +134,40 @@ class TestApplyDecorators:
         assert counter == 1
 
 
-class TestEnsureBytes:
-    @given(case=sampled_from([(b"", False), (b"", True), (None, True)]))
-    def test_main(self, *, case: tuple[bytes | None, bool]) -> None:
+class TestEnsureBool:
+    @given(case=sampled_from([(True, False), (True, True), (None, True)]))
+    def test_main(self, *, case: tuple[bool | None, bool]) -> None:
         obj, nullable = case
-        _ = ensure_bytes(obj, nullable=nullable)
+        _ = ensure_bool(obj, nullable=nullable)
 
     @given(
         case=sampled_from([
-            (False, "Object '.*' of type '.*' must be a byte string"),
-            (True, "Object '.*' of type '.*' must be a byte string or None"),
+            (False, "Object '.*' of type '.*' must be a boolean"),
+            (True, "Object '.*' of type '.*' must be a boolean or None"),
         ])
     )
     def test_error(self, *, case: tuple[bool, str]) -> None:
         nullable, match = case
-        with raises(EnsureBytesError, match=match):
-            _ = ensure_bytes(sentinel, nullable=nullable)
+        with raises(EnsureBoolError, match=match):
+            _ = ensure_bool(sentinel, nullable=nullable)
 
 
-class TestEnsureBool:
-    @given(case=sampled_from([(True, False), (True, True), (None, True)]))
-    def test_main(self, *, case: tuple[bool | None, bool]) -> None:
+class TestEnsureBytes:
+    @given(case=sampled_from([(b"", False), (b"", True), (None, True)]))
+    def test_main(self, *, case: tuple[bytes | None, bool]) -> None:
         obj, nullable = case
-        _ = ensure_bool(obj, nullable=nullable)
+        _ = ensure_bytes(obj, nullable=nullable)
 
     @given(
         case=sampled_from([
-            (False, "Object '.*' of type '.*' must be a boolean"),
-            (True, "Object '.*' of type '.*' must be a boolean or None"),
+            (False, "Object '.*' of type '.*' must be a byte string"),
+            (True, "Object '.*' of type '.*' must be a byte string or None"),
         ])
     )
     def test_error(self, *, case: tuple[bool, str]) -> None:
         nullable, match = case
-        with raises(EnsureBoolError, match=match):
-            _ = ensure_bool(sentinel, nullable=nullable)
+        with raises(EnsureBytesError, match=match):
+            _ = ensure_bytes(sentinel, nullable=nullable)
 
 
 class TestEnsureClass:
@@ -915,6 +918,31 @@ class TestSecond:
         assert second(pair) == y
 
 
+class TestSkipIfOptimize:
+    @mark.parametrize("optimize", [param(True), param(False)])
+    def test_main(self, *, optimize: bool) -> None:
+        code = strip_and_dedent("""
+            from utilities.functions import skip_if_optimize
+
+            is_run = False
+
+            @skip_if_optimize
+            def func() -> None:
+                global is_run
+                is_run = True
+
+            func()
+            print(is_run)
+        """)
+
+        args = [executable]
+        if optimize:
+            args.append("-O")
+        args.extend(["-c", code])
+        is_run = parse_bool(check_output(args, text=True))
+        assert is_run is not optimize
+
+
 class TestYieldObjectAttributes:
     @given(n=integers())
     def test_main(self, *, n: int) -> None:

{dycw_utilities-0.153.6 → 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.6 → dycw_utilities-0.153.8}/src/utilities/__init__.py

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

{dycw_utilities-0.153.6 → dycw_utilities-0.153.8}/src/utilities/functions.py

@@ -935,6 +935,21 @@ def second[U](pair: tuple[Any, U], /) -> U:
 ##
 
 
+def skip_if_optimize[**P](func: Callable[P, None], /) -> Callable[P, None]:
+    """Skip a function if we are in the optimized mode."""
+    if __debug__:
+        return func
+
+    @wraps(func)
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> None:
+        _ = (args, kwargs)
+
+    return wrapped
+
+
+##
+
+
 def yield_object_attributes(
     obj: Any,
     /,
@@ -1043,6 +1058,7 @@ __all__ = [
     "min_nullable",
     "not_func",
     "second",
+    "skip_if_optimize",
     "yield_object_attributes",
     "yield_object_cached_properties",
     "yield_object_properties",

{dycw_utilities-0.153.6 → 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",