dycw-utilities 0.130.2__tar.gz → 0.131.1__tar.gz

{dycw_utilities-0.130.2 → dycw_utilities-0.131.1}/PKG-INFO

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

{dycw_utilities-0.130.2 → dycw_utilities-0.131.1}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.130.2"
+version = "0.131.1"
 
 [project.optional-dependencies]
 logging = [
@@ -341,7 +341,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.130.2"
+current_version = "0.131.1"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -460,6 +460,7 @@ filterwarnings = [
   "ignore:unclosed <StreamWriter .*>:ResourceWarning",  # redis
   "ignore:unclosed <socket.*socket .*>:ResourceWarning",  # redis
   "ignore:unclosed Connection <redis.*asyncio.*connection.*Connection.*>:ResourceWarning",  # redis
+  "ignore:unclosed connection <asyncpg.*connection.*Connection.*>:ResourceWarning",  # asyncpg
   "ignore:unclosed event loop <_UnixSelectorEventLoop .*>:ResourceWarning",  # redis
   "ignore:unclosed file <_io.*TextIOWrapper .*>:ResourceWarning",  # logging
   "ignore:unclosed transport <_SelectorSocketTransport .*>:ResourceWarning",  # redis

dycw_utilities-0.131.1/src/tests/conftest.py

@@ -0,0 +1,425 @@
+from __future__ import annotations
+
+import re
+from asyncio import sleep
+from contextlib import suppress
+from os import environ
+from re import MULTILINE, Pattern
+from typing import TYPE_CHECKING, Any
+
+from pytest import fixture, mark, param
+from sqlalchemy import text
+
+from utilities.datetime import MINUTE, get_now, parse_datetime_compact
+from utilities.platform import IS_NOT_LINUX, IS_WINDOWS
+from utilities.re import ExtractGroupError, extract_group
+from utilities.text import strip_and_dedent
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+    from _pytest.fixtures import SubRequest
+
+
+FLAKY = mark.flaky(reruns=5, reruns_delay=1)
+IS_CI = "CI" in environ
+SKIPIF_CI = mark.skipif(IS_CI, reason="Skipped for CI")
+IS_CI_AND_WINDOWS = IS_CI and IS_WINDOWS
+SKIPIF_CI_AND_WINDOWS = mark.skipif(IS_CI_AND_WINDOWS, reason="Skipped for CI/Windows")
+SKIPIF_CI_AND_NOT_LINUX = mark.skipif(
+    IS_CI and IS_NOT_LINUX, reason="Skipped for CI/non-Linux"
+)
+
+
+# hypothesis
+
+
+try:
+    from utilities.hypothesis import setup_hypothesis_profiles
+except ModuleNotFoundError:
+    pass
+else:
+    setup_hypothesis_profiles()
+
+
+# fixtures - sqlalchemy
+
+
+@fixture(params=[param("sqlite"), param("postgresql", marks=SKIPIF_CI)])
+async def test_engine(*, request: SubRequest, tmp_path: Path) -> Any:
+    from utilities.sqlalchemy import create_async_engine
+
+    dialect = request.param
+    match dialect:
+        case "sqlite":
+            db_path = tmp_path / "db.sqlite"
+            return create_async_engine("sqlite+aiosqlite", database=str(db_path))
+        case "postgresql":
+            engine = create_async_engine(
+                "postgresql+asyncpg", 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):
+                    async with engine.begin() as conn:
+                        with suppress(Exception):
+                            _ = await conn.execute(
+                                text(f'DROP TABLE IF EXISTS "{table}" CASCADE')
+                            )
+                        await sleep(0.01)
+            return engine
+        case _:
+            msg = f"Unsupported dialect: {dialect}"
+            raise NotImplementedError(msg)
+
+
+def _is_to_drop(table: str, /) -> bool:
+    try:
+        datetime_str = extract_group(r"^(\d{8}T\d{6})_", table)
+    except ExtractGroupError:
+        return True
+    datetime = parse_datetime_compact(datetime_str)
+    now = get_now()
+    return (now - datetime) >= MINUTE
+
+
+# fixtures - traceback
+
+
+@fixture
+def traceback_func_chain() -> Pattern[str]:
+    return re.compile(
+        strip_and_dedent(
+            r"""
+            Date/time \| .+
+            Started   \| .+
+            Duration  \| .+
+            User      \| .+
+            Host      \| .+
+            Version   \|\s
+
+            Exception chain 1/2:
+                Frame 1/1: func_chain_first \(tests\.test_traceback_funcs\.chain\)
+                    Inputs:
+                        args\[0\] = 1
+                        args\[1\] = 2
+                        args\[2\] = 3
+                        args\[3\] = 4
+                        kwargs\[c\] = 5
+                        kwargs\[d\] = 6
+                        kwargs\[e\] = 7
+                    Locals:
+                        a = 2
+                        b = 4
+                        c = 10
+                        args = \(6, 8\)
+                        kwargs = {'d': 12, 'e': 14}
+                        msg = 'Assertion failed: Result \(112\) must be divisible by 10'
+                    Line 19:
+                        raise ValueError\(msg\) from error
+                    Raised:
+                        builtins\.ValueError\(Assertion failed: Result \(112\) must be divisible by 10\)
+
+            Exception chain 2/2:
+                Frame 1/1: func_chain_second \(tests\.test_traceback_funcs\.chain\)
+                    Inputs:
+                        args\[0\] = 2
+                        args\[1\] = 4
+                        args\[2\] = 6
+                        args\[3\] = 8
+                        kwargs\[c\] = 10
+                        kwargs\[d\] = 12
+                        kwargs\[e\] = 14
+                    Locals:
+                        a = 4
+                        b = 8
+                        c = 20
+                        args = \(12, 16\)
+                        kwargs = {'d': 24, 'e': 28}
+                        result = 112
+                    Line 30:
+                        assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"
+                    Raised:
+                        builtins\.AssertionError\(Result \(112\) must be divisible by 10\)
+            """
+        ),
+        flags=MULTILINE,
+    )
+
+
+@fixture
+def traceback_func_one() -> Pattern[str]:
+    return re.compile(
+        strip_and_dedent(
+            r"""
+            Date/time \| .+
+            Started   \| .+
+            Duration  \| .+
+            User      \| .+
+            Host      \| .+
+            Version   \|\s
+
+            Frame 1/1: func_one \(tests\.test_traceback_funcs\.one\)
+                Inputs:
+                    args\[0\] = 1
+                    args\[1\] = 2
+                    args\[2\] = 3
+                    args\[3\] = 4
+                    kwargs\[c\] = 5
+                    kwargs\[d\] = 6
+                    kwargs\[e\] = 7
+                Locals:
+                    a = 2
+                    b = 4
+                    c = 10
+                    args = \(6, 8\)
+                    kwargs = {'d': 12, 'e': 14}
+                    result = 56
+                Line 16:
+                    assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"
+                Raised:
+                    builtins\.AssertionError\(Result \(56\) must be divisible by 10\)
+            """
+        ),
+        flags=MULTILINE,
+    )
+
+
+@fixture
+def traceback_func_many_long() -> Pattern[str]:
+    return re.compile(
+        strip_and_dedent(
+            r"""
+            Date/time \| .+
+            Started   \| .+
+            Duration  \| .+
+            User      \| .+
+            Host      \| .+
+            Version   \|\s
+
+            Frame 1/1: func_many \(tests.test_traceback_funcs.many\)
+                Inputs:
+                    args\[0\] = 1
+                    args\[1\] = 2
+                    args\[2\] = 3
+                    args\[3\] = 4
+                    kwargs\[c\] = 5
+                    kwargs\[d\] = 6
+                    kwargs\[e\] = 7
+                Locals:
+                    a = 2
+                    b = 4
+                    c = 10
+                    args = \(
+                        6,
+                        8,
+                        0,
+                        2,
+                        4,
+                        6,
+                        8,
+                        10,
+                        12,
+                        14,
+                        16,
+                        18,
+                        20,
+                        22,
+                        24,
+                        26,
+                        28,
+                        30,
+                        32,
+                        34,
+                        ... \+82
+                    \)
+                    kwargs = {'d': 12, 'e': 14}
+                    result = 9956
+                Line 16:
+                    assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"
+                Raised:
+                    builtins\.AssertionError\(Result \(9956\) must be divisible by 10\)
+            """
+        ),
+        flags=MULTILINE,
+    )
+
+
+@fixture
+def traceback_func_many_short() -> Pattern[str]:
+    return re.compile(
+        strip_and_dedent(
+            r"""
+            Date/time \| .+
+            Started   \| .+
+            Duration  \| .+
+            User      \| .+
+            Host      \| .+
+            Version   \|\s
+
+            Frame 1/1: func_many \(tests.test_traceback_funcs.many\)
+                Inputs:
+                    args\[0\] = 1
+                    args\[1\] = 2
+                    args\[2\] = 3
+                    args\[3\] = 4
+                    kwargs\[c\] = 5
+                    kwargs\[d\] = 6
+                    kwargs\[e\] = 7
+                Locals:
+                    a = 2
+                    b = 4
+                    c = 10
+                    args = \(6, 8, 0, 2, 4, ... \+97\)
+                    kwargs = {'d': 12, 'e': 14}
+                    result = 9956
+                Line 16:
+                    assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"
+                Raised:
+                    builtins\.AssertionError\(Result \(9956\) must be divisible by 10\)
+            """
+        ),
+        flags=MULTILINE,
+    )
+
+
+@fixture
+def traceback_func_task_group_one() -> Pattern[str]:
+    return re.compile(
+        strip_and_dedent(
+            r"""
+            Date/time \| .+
+            Started   \| .+
+            Duration  \| .+
+            User      \| .+
+            Host      \| .+
+            Version   \|\s
+
+            Exception group:
+                Frame 1/1: func_task_group_one_first \(tests\.test_traceback_funcs\.task_group_one\)
+                    Inputs:
+                        args\[0\] = 1
+                        args\[1\] = 2
+                        args\[2\] = 3
+                        args\[3\] = 4
+                        kwargs\[c\] = 5
+                        kwargs\[d\] = 6
+                        kwargs\[e\] = 7
+                    Locals:
+                        a = 2
+                        b = 4
+                        c = 10
+                        args = \(6, 8\)
+                        kwargs = {'d': 12, 'e': 14}
+                        tg = <TaskGroup cancelling>
+                        _ = <Task finished name='Task-\d+' coro=<func_task_group_one_second\(\) done, defined at .+src.+utilities.+traceback\.py:\d+> exception=AssertionError\('Result \(112\) must be divisible by 10'\)>
+                    Line 18:
+                        async with TaskGroup\(\) as tg:
+                    Raised:
+                        builtins\.ExceptionGroup\(unhandled errors in a TaskGroup \(1 sub-exception\)\)
+
+                Exception group error 1/1:
+                    Frame 1/1: func_task_group_one_second \(tests\.test_traceback_funcs\.task_group_one\)
+                        Inputs:
+                            args\[0\] = 2
+                            args\[1\] = 4
+                            args\[2\] = 6
+                            args\[3\] = 8
+                            kwargs\[c\] = 10
+                            kwargs\[d\] = 12
+                            kwargs\[e\] = 14
+                        Locals:
+                            a = 4
+                            b = 8
+                            c = 20
+                            args = \(12, 16\)
+                            kwargs = {'d': 24, 'e': 28}
+                            result = 112
+                        Line 33:
+                            assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"
+                        Raised:
+                            builtins\.AssertionError\(Result \(112\) must be divisible by 10\)
+            """
+        )
+    )
+
+
+@fixture
+def traceback_func_two() -> Pattern[str]:
+    return re.compile(
+        strip_and_dedent(
+            r"""
+            Date/time \| .+
+            Started   \| .+
+            Duration  \| .+
+            User      \| .+
+            Host      \| .+
+            Version   \|\s
+
+            Frame 1/2: func_two_first \(tests\.test_traceback_funcs\.two\)
+                Inputs:
+                    args\[0\] = 1
+                    args\[1\] = 2
+                    args\[2\] = 3
+                    args\[3\] = 4
+                    kwargs\[c\] = 5
+                    kwargs\[d\] = 6
+                    kwargs\[e\] = 7
+                Locals:
+                    a = 2
+                    b = 4
+                    c = 10
+                    args = \(6, 8\)
+                    kwargs = {'d': 12, 'e': 14}
+                Line 15:
+                    return func_two_second\(a, b, \*args, c=c, \*\*kwargs\)
+
+            Frame 2/2: func_two_second \(tests\.test_traceback_funcs\.two\)
+                Inputs:
+                    args\[0\] = 2
+                    args\[1\] = 4
+                    args\[2\] = 6
+                    args\[3\] = 8
+                    kwargs\[c\] = 10
+                    kwargs\[d\] = 12
+                    kwargs\[e\] = 14
+                Locals:
+                    a = 4
+                    b = 8
+                    c = 20
+                    args = \(12, 16\)
+                    kwargs = {'d': 24, 'e': 28}
+                    result = 112
+                Line 26:
+                    assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"
+                Raised:
+                    builtins\.AssertionError\(Result \(112\) must be divisible by 10\)
+            """
+        ),
+        flags=MULTILINE,
+    )
+
+
+@fixture
+def traceback_func_untraced() -> Pattern[str]:
+    return re.compile(
+        strip_and_dedent(
+            r"""
+            Traceback \(most recent call last\):
+
+              File ".+src.+tests.+test_(logging|sys|traceback)\.py", line \d+, in test_.+
+                _ = func_untraced\(1, 2, 3, 4, c=5, d=6, e=7\)
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+              File ".+src.+tests.+test_traceback_funcs.+untraced\.py", line 13, in func_untraced
+                assert result % 10 == 0, f"Result \({result}\) must be divisible by 10"
+                       ^^^^^^^^^^^^^^^^
+
+            AssertionError: Result \(56\) must be divisible by 10
+            """
+        ).replace("^", r"\^"),
+        flags=MULTILINE,
+    )

{dycw_utilities-0.130.2 → dycw_utilities-0.131.1}/src/tests/test_hypothesis.py

@@ -23,14 +23,11 @@ from hypothesis.strategies import (
     sets,
     timedeltas,
     timezones,
-    uuids,
 )
 from luigi import Task
 from numpy import inf, int64, isfinite, isinf, isnan, ravel, rint
 from pathvalidate import validate_filepath
 from pytest import mark, raises
-from sqlalchemy import Column, Integer, MetaData, Table, insert, select
-from sqlalchemy.ext.asyncio import AsyncEngine
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.datetime import (
@@ -45,7 +42,6 @@ from utilities.datetime import (
 )
 from utilities.functions import ensure_int
 from utilities.hypothesis import (
-    _SQLALCHEMY_ENGINE_DIALECTS,
     MaybeSearchStrategy,
     PlainDateTimesError,
     Shape,
@@ -83,7 +79,6 @@ from utilities.hypothesis import (
     settings_with_reduced_examples,
     setup_hypothesis_profiles,
     slices,
-    sqlalchemy_engines,
     str_arrays,
     temp_dirs,
     temp_paths,
@@ -119,7 +114,6 @@ from utilities.math import (
 from utilities.os import temp_environ
 from utilities.platform import maybe_yield_lower_case
 from utilities.sentinel import Sentinel
-from utilities.sqlalchemy import Dialect, _get_dialect
 from utilities.version import Version
 from utilities.whenever import (
     MAX_SERIALIZABLE_TIMEDELTA,
@@ -134,7 +128,6 @@ from utilities.whenever import (
 if TYPE_CHECKING:
     from collections.abc import Iterable
     from collections.abc import Set as AbstractSet
-    from uuid import UUID
     from zoneinfo import ZoneInfo
 
     from utilities.datetime import Month
@@ -917,38 +910,6 @@ class TestSlices:
             _ = data.draw(slices(iter_len, slice_len=iter_len + 1))
 
 
-class TestSQLAlchemyEngines:
-    @given(
-        data=data(),
-        name=uuids(),
-        dialect=_SQLALCHEMY_ENGINE_DIALECTS,
-        ids=sets(integers(0, 10), min_size=1),
-    )
-    @settings(phases={Phase.generate})
-    async def test_main(
-        self, *, data: DataObject, name: UUID, dialect: Dialect, ids: set[int]
-    ) -> None:
-        table = Table(
-            f"test_{name}", MetaData(), Column("id_", Integer, primary_key=True)
-        )
-        engine = await sqlalchemy_engines(data, table, dialect=dialect)
-        assert isinstance(engine, AsyncEngine)
-        assert _get_dialect(engine) == dialect
-        if dialect == "sqlite":
-            database = engine.url.database
-            assert database is not None
-            assert not Path(database).exists()
-        async with engine.begin() as conn:
-            await conn.run_sync(table.metadata.create_all)
-        ins = insert(table).values([(id_,) for id_ in ids])
-        async with engine.begin() as conn:
-            _ = await conn.execute(ins)
-        sel = select(table.c["id_"])
-        async with engine.begin() as conn:
-            results = (await conn.execute(sel)).scalars().all()
-        assert set(results) == ids
-
-
 class TestStrArrays:
     @given(
         data=data(),

dycw_utilities-0.131.1/src/tests/test_pottery.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from asyncio import TaskGroup, sleep
+from re import search
+from typing import TYPE_CHECKING
+
+from pytest import mark, param, raises
+
+from tests.conftest import SKIPIF_CI_AND_NOT_LINUX
+from tests.test_redis import yield_test_redis
+from utilities.iterables import one
+from utilities.pottery import (
+    _YieldAccessNumLocksError,
+    _YieldAccessUnableToAcquireLockError,
+    yield_access,
+)
+from utilities.text import unique_str
+from utilities.timer import Timer
+
+if TYPE_CHECKING:
+    from redis.asyncio import Redis
+
+
+async def _func_access(num_tasks: int, key: str, /, *, num_locks: int = 1) -> None:
+    async def coroutine() -> None:
+        async with yield_test_redis() as redis, yield_access(redis, key, num=num_locks):
+            await sleep(0.1)
+
+    async with TaskGroup() as tg:
+        _ = [tg.create_task(coroutine()) for _ in range(num_tasks)]
+
+
+class TestYieldAccess:
+    @SKIPIF_CI_AND_NOT_LINUX
+    @mark.parametrize(
+        ("num_tasks", "num_locks", "min_time"),
+        [
+            param(1, 1, 0.1),
+            param(1, 2, 0.1),
+            param(1, 3, 0.1),
+            param(2, 1, 0.2),
+            param(2, 2, 0.1),
+            param(2, 3, 0.1),
+            param(2, 4, 0.1),
+            param(2, 5, 0.1),
+            param(3, 1, 0.3),
+            param(3, 2, 0.2),
+            param(3, 3, 0.1),
+            param(3, 4, 0.1),
+            param(3, 5, 0.1),
+            param(4, 1, 0.4),
+            param(4, 2, 0.2),
+            param(4, 3, 0.2),
+            param(4, 4, 0.1),
+            param(4, 5, 0.1),
+        ],
+    )
+    async def test_main(
+        self, *, num_tasks: int, num_locks: int, min_time: float
+    ) -> None:
+        with Timer() as timer:
+            await _func_access(num_tasks, unique_str(), num_locks=num_locks)
+        assert min_time <= float(timer) <= 3 * min_time
+
+    async def test_error_num_locks(self) -> None:
+        key = unique_str()
+        with raises(
+            _YieldAccessNumLocksError,
+            match=r"Number of locks for '\w+' must be positive; got 0",
+        ):
+            async with yield_test_redis() as redis, yield_access(redis, key, num=0):
+                ...
+
+    @SKIPIF_CI_AND_NOT_LINUX
+    async def test_error_unable_to_acquire_lock(self) -> None:
+        key = unique_str()
+
+        async def coroutine(redis: Redis, key: str, /) -> None:
+            async with yield_access(
+                redis, key, num=1, timeout_acquire=0.1, throttle=0.5
+            ):
+                await sleep(0.1)
+
+        with raises(ExceptionGroup) as exc_info:  # noqa: PT012
+            async with yield_test_redis() as redis, TaskGroup() as tg:
+                _ = tg.create_task(coroutine(redis, key))
+                _ = tg.create_task(coroutine(redis, key))
+        error = one(exc_info.value.exceptions)
+        assert isinstance(error, _YieldAccessUnableToAcquireLockError)
+        assert search(
+            r"Unable to acquire any 1 of 1 locks for '\w+' after 0\.1", str(error)
+        )