dycw-utilities 0.131.18__tar.gz → 0.131.19__tar.gz

{dycw_utilities-0.131.18 → dycw_utilities-0.131.19}/PKG-INFO

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

{dycw_utilities-0.131.18 → dycw_utilities-0.131.19}/pyproject.toml

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.131.18"
+version = "0.131.19"
 
 [project.optional-dependencies]
 logging = [
@@ -121,7 +121,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.131.18"
+current_version = "0.131.19"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

dycw_utilities-0.131.19/src/tests/conftest.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from asyncio import sleep
+from contextlib import AbstractContextManager, contextmanager, suppress
+from logging import LogRecord, setLogRecordFactory
+from os import environ
+from typing import TYPE_CHECKING, Any
+
+from hypothesis import HealthCheck
+from pytest import fixture, mark, param
+from sqlalchemy import text
+from whenever import PlainDateTime
+
+from utilities.platform import IS_NOT_LINUX, IS_WINDOWS
+from utilities.re import ExtractGroupError, extract_group
+from utilities.tzlocal import LOCAL_TIME_ZONE_NAME
+from utilities.whenever2 import MINUTE, get_now
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, 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(suppress_health_check={HealthCheck.differing_executors})
+
+
+# fixture - logging
+
+
+@fixture
+def set_log_factory() -> AbstractContextManager[None]:
+    @contextmanager
+    def cm() -> Iterator[None]:
+        try:
+            yield
+        finally:
+            setLogRecordFactory(LogRecord)
+
+    return cm()
+
+
+# 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 = PlainDateTime.parse_common_iso(datetime_str).assume_tz(
+        LOCAL_TIME_ZONE_NAME
+    )
+    now = get_now()
+    return (now - datetime) >= MINUTE

{dycw_utilities-0.131.18 → dycw_utilities-0.131.19}/src/tests/test_altair.py

@@ -2,15 +2,12 @@ from __future__ import annotations
 
 import datetime as dt
 from math import inf
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING
 
 import polars as pl
 from hypothesis import HealthCheck, given, settings
 from hypothesis.strategies import (
-    DataObject,
     booleans,
-    data,
-    dates,
     floats,
     integers,
     just,
@@ -19,7 +16,7 @@ from hypothesis.strategies import (
     sampled_from,
     tuples,
 )
-from polars import DataFrame, Date, Float64, datetime_range, int_range
+from polars import DataFrame, Float64, datetime_range, int_range
 from pytest import fixture
 
 from utilities.altair import (
@@ -30,7 +27,7 @@ from utilities.altair import (
     vconcat_charts,
 )
 from utilities.functions import ensure_class
-from utilities.hypothesis import text_ascii, zoned_datetimes
+from utilities.hypothesis import dates_whenever, text_ascii, zoned_datetimes_whenever
 from utilities.polars import DatetimeUTC, zoned_datetime
 from utilities.tzdata import HongKong, Tokyo
 from utilities.whenever2 import get_now
@@ -40,6 +37,9 @@ if TYPE_CHECKING:
     from pathlib import Path
     from zoneinfo import ZoneInfo
 
+    import whenever
+    from whenever import ZonedDateTime
+
 
 @fixture
 def time_series() -> DataFrame:
@@ -105,19 +105,25 @@ class TestPlotDataFrames:
         expected = dt.datetime(2000, 1, 1, 12, tzinfo=time_zone).replace(tzinfo=None)
         assert datetime == expected
 
-    @given(data=data(), case=sampled_from(["date", "datetime"]))
-    def test_tooltip_format(
-        self, *, data: DataObject, case: Literal["date", "datetime"]
+    @given(data=lists(tuples(dates_whenever(), floats(-10, 10))))
+    def test_tooltip_format_date(
+        self, *, data: list[tuple[whenever.Date, float]]
+    ) -> None:
+        df = DataFrame(
+            data=[(d.py_date(), v) for d, v in data],
+            schema={"index": pl.Date, "value": Float64},
+            orient="row",
+        )
+        _ = plot_dataframes(df, x="index", y="value")
+
+    @given(data=lists(tuples(zoned_datetimes_whenever(), floats(-10, 10))))
+    def test_tooltip_format_date_time(
+        self, *, data: list[tuple[ZonedDateTime, float]]
     ) -> None:
-        match case:
-            case "date":
-                values = data.draw(lists(tuples(dates(), floats(-10, 10))))
-                dtype = Date()
-            case "datetime":
-                values = data.draw(lists(tuples(zoned_datetimes(), floats(-10, 10))))
-                dtype = DatetimeUTC
         df = DataFrame(
-            data=values, schema={"index": dtype, "value": Float64}, orient="row"
+            data=[(d.py_datetime(), v) for d, v in data],
+            schema={"index": DatetimeUTC, "value": Float64},
+            orient="row",
         )
         _ = plot_dataframes(df, x="index", y="value")
 

dycw_utilities-0.131.19/src/tests/test_datetime.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import datetime as dt
+from re import search
+from typing import TYPE_CHECKING
+
+from hypothesis import assume, given
+from hypothesis.strategies import DataObject, data, dates, integers, sampled_from
+from pytest import mark, param, raises
+
+from utilities.datetime import (
+    EnsureMonthError,
+    Month,
+    MonthError,
+    ParseMonthError,
+    _ParseTwoDigitYearInvalidIntegerError,
+    _ParseTwoDigitYearInvalidStringError,
+    date_to_month,
+    ensure_month,
+    maybe_sub_pct_y,
+    parse_month,
+    parse_two_digit_year,
+    serialize_month,
+)
+from utilities.hypothesis import months, text_clean
+from utilities.zoneinfo import UTC
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class TestDateToMonth:
+    @given(date=dates())
+    def test_main(self, *, date: dt.date) -> None:
+        result = date_to_month(date).to_date(day=date.day)
+        assert result == date
+
+
+class TestMaybeSubPctY:
+    @given(text=text_clean())
+    def test_main(self, *, text: str) -> None:
+        result = maybe_sub_pct_y(text)
+        _ = assume(not search("%Y", result))
+        assert not search("%Y", result)
+
+
+class TestMonth:
+    @mark.parametrize(
+        ("month", "n", "expected"),
+        [
+            param(Month(2000, 1), -2, Month(1999, 11)),
+            param(Month(2000, 1), -1, Month(1999, 12)),
+            param(Month(2000, 1), 0, Month(2000, 1)),
+            param(Month(2000, 1), 1, Month(2000, 2)),
+            param(Month(2000, 1), 2, Month(2000, 3)),
+            param(Month(2000, 1), 11, Month(2000, 12)),
+            param(Month(2000, 1), 12, Month(2001, 1)),
+        ],
+    )
+    def test_add(self, *, month: Month, n: int, expected: Month) -> None:
+        result = month + n
+        assert result == expected
+
+    @mark.parametrize(
+        ("x", "y", "expected"),
+        [
+            param(Month(2000, 1), Month(1999, 11), 2),
+            param(Month(2000, 1), Month(1999, 12), 1),
+            param(Month(2000, 1), Month(2000, 1), 0),
+            param(Month(2000, 1), Month(2000, 2), -1),
+            param(Month(2000, 1), Month(2000, 3), -2),
+            param(Month(2000, 1), Month(2000, 12), -11),
+            param(Month(2000, 1), Month(2001, 1), -12),
+        ],
+    )
+    def test_diff(self, *, x: Month, y: Month, expected: int) -> None:
+        result = x - y
+        assert result == expected
+
+    @given(month=months())
+    def test_hashable(self, *, month: Month) -> None:
+        _ = hash(month)
+
+    @mark.parametrize("func", [param(repr), param(str)])
+    def test_repr(self, *, func: Callable[..., str]) -> None:
+        result = func(Month(2000, 12))
+        expected = "2000-12"
+        assert result == expected
+
+    @mark.parametrize(
+        ("month", "n", "expected"),
+        [
+            param(Month(2000, 1), -2, Month(2000, 3)),
+            param(Month(2000, 1), -1, Month(2000, 2)),
+            param(Month(2000, 1), 0, Month(2000, 1)),
+            param(Month(2000, 1), 1, Month(1999, 12)),
+            param(Month(2000, 1), 2, Month(1999, 11)),
+            param(Month(2000, 1), 12, Month(1999, 1)),
+            param(Month(2000, 1), 13, Month(1998, 12)),
+        ],
+    )
+    def test_subtract(self, *, month: Month, n: int, expected: Month) -> None:
+        result = month - n
+        assert result == expected
+
+    @given(date=dates())
+    def test_to_and_from_date(self, *, date: dt.date) -> None:
+        month = Month.from_date(date)
+        result = month.to_date(day=date.day)
+        assert result == date
+
+    def test_error(self) -> None:
+        with raises(MonthError, match=r"Invalid year and month: \d+, \d+"):
+            _ = Month(2000, 13)
+
+
+class TestSerializeAndParseMonth:
+    @given(month=months())
+    def test_main(self, *, month: Month) -> None:
+        serialized = serialize_month(month)
+        result = parse_month(serialized)
+        assert result == month
+
+    def test_error_parse(self) -> None:
+        with raises(ParseMonthError, match="Unable to parse month; got 'invalid'"):
+            _ = parse_month("invalid")
+
+    @given(data=data(), month=months())
+    def test_ensure(self, *, data: DataObject, month: Month) -> None:
+        str_or_value = data.draw(sampled_from([month, serialize_month(month)]))
+        result = ensure_month(str_or_value)
+        assert result == month
+
+    def test_error_ensure(self) -> None:
+        with raises(EnsureMonthError, match="Unable to ensure month; got 'invalid'"):
+            _ = ensure_month("invalid")
+
+
+class TestParseTwoDigitYear:
+    @given(data=data(), year=integers(0, 99))
+    def test_main(self, *, data: DataObject, year: int) -> None:
+        input_ = data.draw(sampled_from([year, str(year)]))
+        result = parse_two_digit_year(input_)
+        expected = (
+            dt.datetime.strptime(format(year, "02d"), "%y").replace(tzinfo=UTC).year
+        )
+        assert result == expected
+
+    @given(year=integers(max_value=-1) | integers(min_value=100))
+    def test_error_int(self, *, year: int) -> None:
+        with raises(
+            _ParseTwoDigitYearInvalidIntegerError, match="Unable to parse year; got .*"
+        ):
+            _ = parse_two_digit_year(year)
+
+    @given(year=(integers(max_value=-1) | integers(min_value=100)).map(str))
+    def test_error_str(self, *, year: str) -> None:
+        with raises(
+            _ParseTwoDigitYearInvalidStringError, match="Unable to parse year; got .*"
+        ):
+            _ = parse_two_digit_year(year)

{dycw_utilities-0.131.18 → dycw_utilities-0.131.19}/src/tests/test_functions.py

@@ -24,14 +24,12 @@ from hypothesis.strategies import (
 )
 from pytest import raises
 
-from utilities.datetime import ZERO_TIME, get_now, get_today
 from utilities.errors import ImpossibleCaseError
 from utilities.functions import (
     EnsureBoolError,
     EnsureBytesError,
     EnsureClassError,
     EnsureDateError,
-    EnsureDateTimeError,
     EnsureFloatError,
     EnsureHashableError,
     EnsureIntError,
@@ -39,11 +37,13 @@ from utilities.functions import (
     EnsureNotNoneError,
     EnsureNumberError,
     EnsurePathError,
+    EnsurePlainDateTimeError,
     EnsureSizedError,
     EnsureSizedNotStrError,
     EnsureStrError,
     EnsureTimeDeltaError,
     EnsureTimeError,
+    EnsureZonedDateTimeError,
     MaxNullableError,
     MinNullableError,
     apply_decorators,
@@ -51,7 +51,6 @@ from utilities.functions import (
     ensure_bytes,
     ensure_class,
     ensure_date,
-    ensure_datetime,
     ensure_float,
     ensure_hashable,
     ensure_int,
@@ -59,11 +58,13 @@ from utilities.functions import (
     ensure_not_none,
     ensure_number,
     ensure_path,
+    ensure_plain_date_time,
     ensure_sized,
     ensure_sized_not_str,
     ensure_str,
     ensure_time,
-    ensure_timedelta,
+    ensure_time_delta,
+    ensure_zoned_date_time,
     first,
     get_class,
     get_class_name,
@@ -94,11 +95,14 @@ from utilities.functions import (
     yield_object_properties,
 )
 from utilities.sentinel import sentinel
+from utilities.whenever2 import NOW_UTC, ZERO_TIME, get_now, get_today
 
 if TYPE_CHECKING:
     import datetime as dt
     from collections.abc import Callable, Iterable
 
+    from whenever import PlainDateTime, TimeDelta, ZonedDateTime
+
     from utilities.types import Number
 
 
@@ -212,24 +216,6 @@ class TestEnsureDate:
             _ = ensure_date(sentinel, nullable=nullable)
 
 
-class TestEnsureDateTime:
-    @given(case=sampled_from([(get_now(), False), (get_now(), True), (None, True)]))
-    def test_main(self, *, case: tuple[dt.datetime | None, bool]) -> None:
-        obj, nullable = case
-        _ = ensure_datetime(obj, nullable=nullable)
-
-    @given(
-        case=sampled_from([
-            (False, "Object '.*' of type '.*' must be a datetime"),
-            (True, "Object '.*' of type '.*' must be a datetime or None"),
-        ])
-    )
-    def test_error(self, *, case: tuple[bool, str]) -> None:
-        nullable, match = case
-        with raises(EnsureDateTimeError, match=match):
-            _ = ensure_datetime(sentinel, nullable=nullable)
-
-
 class TestEnsureFloat:
     @given(case=sampled_from([(0.0, False), (0.0, True), (None, True)]))
     def test_main(self, *, case: tuple[float | None, bool]) -> None:
@@ -355,6 +341,30 @@ class TestEnsurePath:
             _ = ensure_path(sentinel, nullable=nullable)
 
 
+class TestEnsurePlainDateTime:
+    @given(
+        case=sampled_from([
+            (NOW_UTC.to_plain(), False),
+            (NOW_UTC.to_plain(), True),
+            (None, True),
+        ])
+    )
+    def test_main(self, *, case: tuple[PlainDateTime | None, bool]) -> None:
+        obj, nullable = case
+        _ = ensure_plain_date_time(obj, nullable=nullable)
+
+    @given(
+        case=sampled_from([
+            (False, "Object '.*' of type '.*' must be a plain date-time"),
+            (True, "Object '.*' of type '.*' must be a plain date-time or None"),
+        ])
+    )
+    def test_error(self, *, case: tuple[bool, str]) -> None:
+        nullable, match = case
+        with raises(EnsurePlainDateTimeError, match=match):
+            _ = ensure_plain_date_time(sentinel, nullable=nullable)
+
+
 class TestEnsureSized:
     @given(obj=sampled_from([[], (), ""]))
     def test_main(self, *, obj: Any) -> None:
@@ -423,20 +433,38 @@ class TestEnsureTime:
 
 class TestEnsureTimeDelta:
     @given(case=sampled_from([(ZERO_TIME, False), (ZERO_TIME, True), (None, True)]))
-    def test_main(self, *, case: tuple[dt.timedelta | None, bool]) -> None:
+    def test_main(self, *, case: tuple[TimeDelta | None, bool]) -> None:
         obj, nullable = case
-        _ = ensure_timedelta(obj, nullable=nullable)
+        _ = ensure_time_delta(obj, nullable=nullable)
 
     @given(
         case=sampled_from([
-            (False, "Object '.*' of type '.*' must be a timedelta"),
-            (True, "Object '.*' of type '.*' must be a timedelta or None"),
+            (False, "Object '.*' of type '.*' must be a time-delta"),
+            (True, "Object '.*' of type '.*' must be a time-delta or None"),
         ])
     )
     def test_error(self, *, case: tuple[bool, str]) -> None:
         nullable, match = case
         with raises(EnsureTimeDeltaError, match=match):
-            _ = ensure_timedelta(sentinel, nullable=nullable)
+            _ = ensure_time_delta(sentinel, nullable=nullable)
+
+
+class TestEnsureZonedDateTime:
+    @given(case=sampled_from([(NOW_UTC, False), (NOW_UTC, True), (None, True)]))
+    def test_main(self, *, case: tuple[ZonedDateTime | None, bool]) -> None:
+        obj, nullable = case
+        _ = ensure_zoned_date_time(obj, nullable=nullable)
+
+    @given(
+        case=sampled_from([
+            (False, "Object '.*' of type '.*' must be a zoned date-time"),
+            (True, "Object '.*' of type '.*' must be a zoned date-time or None"),
+        ])
+    )
+    def test_error(self, *, case: tuple[bool, str]) -> None:
+        nullable, match = case
+        with raises(EnsureZonedDateTimeError, match=match):
+            _ = ensure_zoned_date_time(sentinel, nullable=nullable)
 
 
 class TestFirst:

{dycw_utilities-0.131.18 → dycw_utilities-0.131.19}/src/tests/test_http.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 from ipaddress import IPv4Address
 
-from utilities.datetime import MINUTE
 from utilities.http import get_public_ip, yield_connection
 from utilities.pytest import throttle
+from utilities.whenever2 import MINUTE
 
 
 class TestGetPublicIP:
-    @throttle(duration=5 * MINUTE)
+    @throttle(delta=5 * MINUTE)
     def test_main(self) -> None:
         ip = get_public_ip(timeout=10.0)
         assert isinstance(ip, IPv4Address)