dycw-utilities 0.131.0__tar.gz → 0.131.2__tar.gz

{dycw_utilities-0.131.0 → dycw_utilities-0.131.2}/PKG-INFO

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

{dycw_utilities-0.131.0 → dycw_utilities-0.131.2}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.0"
+version = "0.131.2"
 
 [project.optional-dependencies]
 logging = [
@@ -341,7 +341,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.0"
+current_version = "0.131.2"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -354,6 +354,7 @@ search = "__version__ = \"{current_version}\""
 [tool.coverage.coverage_conditional_plugin.rules]
 skipif-ci = '"CI" in os_environ'
 skipif-ci-and-not-linux = '("CI" in os_environ) and (sys_platform != "linux")'
+skipif-ci-and-not-windows = '("CI" in os_environ) and (sys_platform != "windows")'
 skipif-ci-and-windows = '("CI" in os_environ) and (sys_platform != "windows")'
 skipif-linux = 'sys_platform == "linux"'
 skipif-mac = 'sys_platform == "darwin"'
@@ -460,6 +461,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.2/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.131.0 → dycw_utilities-0.131.2}/src/tests/test_hypothesis.py

@@ -23,14 +23,12 @@ 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 whenever import Date, DateDelta, PlainDateTime, ZonedDateTime
 
 from tests.conftest import SKIPIF_CI_AND_WINDOWS
 from utilities.datetime import (
@@ -45,7 +43,6 @@ from utilities.datetime import (
 )
 from utilities.functions import ensure_int
 from utilities.hypothesis import (
-    _SQLALCHEMY_ENGINE_DIALECTS,
     MaybeSearchStrategy,
     PlainDateTimesError,
     Shape,
@@ -54,8 +51,10 @@ from utilities.hypothesis import (
     _Draw2InputResolvedToSentinelError,
     assume_does_not_raise,
     bool_arrays,
+    date_deltas_whenever,
     date_durations,
     dates_two_digit_year,
+    dates_whenever,
     datetime_durations,
     draw2,
     float32s,
@@ -77,13 +76,13 @@ from utilities.hypothesis import (
     pairs,
     paths,
     plain_datetimes,
+    plain_datetimes_whenever,
     random_states,
     sentinels,
     sets_fixed_length,
     settings_with_reduced_examples,
     setup_hypothesis_profiles,
     slices,
-    sqlalchemy_engines,
     str_arrays,
     temp_dirs,
     temp_paths,
@@ -99,6 +98,7 @@ from utilities.hypothesis import (
     uint64s,
     versions,
     zoned_datetimes,
+    zoned_datetimes_whenever,
 )
 from utilities.math import (
     MAX_FLOAT32,
@@ -119,7 +119,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 +133,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
@@ -185,6 +183,31 @@ class TestBoolArrays:
         assert array.shape == shape
 
 
+class TestDateDeltas:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(date_deltas_whenever() | none())
+        max_value = data.draw(date_deltas_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            delta = data.draw(
+                date_deltas_whenever(min_value=min_value, max_value=max_value)
+            )
+        assert isinstance(delta, DateDelta)
+        years, months, days = delta.in_years_months_days()
+        assert years == 0
+        assert months == 0
+        if min_value is not None:
+            min_years, min_months, min_days = min_value.in_years_months_days()
+            assert min_years == 0
+            assert min_months == 0
+            assert days >= min_days
+        if max_value is not None:
+            max_years, max_months, max_days = max_value.in_years_months_days()
+            assert max_years == 0
+            assert max_months == 0
+            assert days <= max_days
+
+
 class TestDateDurations:
     @given(
         data=data(),
@@ -264,6 +287,20 @@ class TestDatesTwoDigitYear:
         assert date.year == parsed
 
 
+class TestDatesWhenever:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(dates_whenever() | none())
+        max_value = data.draw(dates_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            date = data.draw(dates_whenever(min_value=min_value, max_value=max_value))
+        assert isinstance(date, Date)
+        if min_value is not None:
+            assert date >= min_value
+        if max_value is not None:
+            assert date <= max_value
+
+
 class TestDateTimeDurations:
     @given(
         data=data(),
@@ -847,6 +884,22 @@ class TestPlainDateTimes:
             _ = data.draw(plain_datetimes(round_="standard"))
 
 
+class TestPlainDateTimesWhenever:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_value = data.draw(plain_datetimes_whenever() | none())
+        max_value = data.draw(plain_datetimes_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            datetime = data.draw(
+                plain_datetimes_whenever(min_value=min_value, max_value=max_value)
+            )
+        assert isinstance(datetime, PlainDateTime)
+        if min_value is not None:
+            assert datetime >= min_value
+        if max_value is not None:
+            assert datetime <= max_value
+
+
 class TestRandomStates:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
@@ -917,38 +970,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(),
@@ -1237,3 +1258,23 @@ class TestZonedDateTimes:
             ZonedDateTimesError, match="Rounding requires a timedelta; got None"
         ):
             _ = data.draw(zoned_datetimes(round_="standard"))
+
+
+class TestZonedDateTimesWhenever:
+    @given(data=data(), time_zone=timezones())
+    @settings(suppress_health_check={HealthCheck.filter_too_much})
+    def test_main(self, *, data: DataObject, time_zone: ZoneInfo) -> None:
+        min_value = data.draw(zoned_datetimes_whenever() | none())
+        max_value = data.draw(zoned_datetimes_whenever() | none())
+        with assume_does_not_raise(InvalidArgument):
+            datetime = data.draw(
+                zoned_datetimes_whenever(
+                    min_value=min_value, max_value=max_value, time_zone=time_zone
+                )
+            )
+        assert isinstance(datetime, ZonedDateTime)
+        assert datetime.tz == time_zone.key
+        if min_value is not None:
+            assert datetime >= min_value
+        if max_value is not None:
+            assert datetime <= max_value