dycw-utilities 0.150.9__tar.gz → 0.150.11__tar.gz

{dycw_utilities-0.150.9 → dycw_utilities-0.150.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.150.9
+Version: 0.150.11
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -12,7 +12,7 @@ Provides-Extra: logging
 Requires-Dist: coloredlogs<15.1,>=15.0.1; extra == 'logging'
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.137,>=6.136.0; extra == 'test'
+Requires-Dist: hypothesis<6.137,>=6.136.1; extra == 'test'
 Requires-Dist: pudb<2025.2,>=2025.1; extra == 'test'
 Requires-Dist: pytest-asyncio<1.2,>=1.1.0; extra == 'test'
 Requires-Dist: pytest-cov<6.3,>=6.2.1; extra == 'test'

{dycw_utilities-0.150.9 → dycw_utilities-0.150.11}/pyproject.toml

@@ -41,7 +41,7 @@ fastapi-test = ["httpx", "uvicorn"]
 fpdf2 = ["fpdf2 >= 2.8.3, < 2.9"]
 hashlib-test = ["orjson"]
 http-test = ["orjson"]
-hypothesis = ["hypothesis >= 6.136.0, < 6.137"]
+hypothesis = ["hypothesis >= 6.136.1, < 6.137"]
 hypothesis-test = ["libcst", "pathvalidate", "numpy", "pytest-rerunfailures"]
 inflect = ["inflect >= 7.5.0, < 7.6"]
 jupyter-test = ["pandas", "polars"]
@@ -103,7 +103,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.150.9"
+version = "0.150.11"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -115,7 +115,7 @@ logging = [
 ]
 test = [
   "dycw-pytest-only >= 2.1.1, < 2.2",
-  "hypothesis >= 6.136.0, < 6.137",
+  "hypothesis >= 6.136.1, < 6.137",
   "pudb >= 2025.1, < 2025.2",
   "pytest >= 8.4.1, < 8.5",
   "pytest-asyncio >= 1.1.0, < 1.2",
@@ -136,7 +136,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.150.9"
+current_version = "0.150.11"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.150.9 → dycw_utilities-0.150.11}/src/tests/test_period.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, cast
 from hypothesis import HealthCheck, given, settings
 from hypothesis.strategies import DataObject, data
 from pytest import mark, param, raises
-from whenever import Date, ZonedDateTime
+from whenever import Date, Time, ZonedDateTime
 
 from utilities.hypothesis import (
     assume_does_not_raise,
@@ -15,10 +15,12 @@ from utilities.hypothesis import (
     pairs,
     plain_datetimes,
     time_deltas,
+    times,
     zoned_datetimes,
 )
 from utilities.period import (
     DatePeriod,
+    TimePeriod,
     ZonedDateTimePeriod,
     _PeriodAsDict,
     _PeriodExactEqArgumentsError,
@@ -26,7 +28,7 @@ from utilities.period import (
     _PeriodTimeZoneError,
 )
 from utilities.tzdata import USCentral, USEastern
-from utilities.whenever import DAY
+from utilities.whenever import DAY, SECOND
 from utilities.zoneinfo import UTC, get_time_zone_name
 
 if TYPE_CHECKING:
@@ -46,6 +48,31 @@ class TestDatePeriod:
         expected = DatePeriod(start + delta, end + delta)
         assert result == expected
 
+    @given(dates=pairs(dates(), sorted=True), time=times())
+    def test_at_time(self, *, dates: tuple[Date, Date], time: Time) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        result = period.at(time)
+        expected = ZonedDateTimePeriod(
+            start.at(time).assume_tz(UTC.key), end.at(time).assume_tz(UTC.key)
+        )
+        assert result.exact_eq(expected)
+
+    @given(dates=pairs(dates(), sorted=True), times=pairs(times()))
+    def test_at_times(
+        self, *, dates: tuple[Date, Date], times: tuple[Time, Time]
+    ) -> None:
+        start_date, end_date = dates
+        period = DatePeriod(start_date, end_date)
+        start_time, end_time = times
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at((start_time, end_time))
+        expected = ZonedDateTimePeriod(
+            start_date.at(start_time).assume_tz(UTC.key),
+            end_date.at(end_time).assume_tz(UTC.key),
+        )
+        assert result.exact_eq(expected)
+
     @given(date=dates(), dates=pairs(dates(), sorted=True))
     def test_contains(self, *, date: Date, dates: tuple[Date, Date]) -> None:
         start, end = dates
@@ -82,6 +109,14 @@ class TestDatePeriod:
         period = DatePeriod(start, end)
         _ = hash(period)
 
+    @given(dates=pairs(dates(), sorted=True))
+    def test_replace(self, *, dates: tuple[Date, Date]) -> None:
+        start, end = dates
+        period = DatePeriod(start, end)
+        new = period.replace(start=start - DAY, end=end + DAY)
+        assert new.start == (start - DAY)
+        assert new.end == (end + DAY)
+
     @given(dates=pairs(dates(), sorted=True))
     @mark.parametrize("func", [param(repr), param(str)])
     def test_repr(self, *, dates: tuple[Date, Date], func: Callable[..., str]) -> None:
@@ -125,6 +160,79 @@ class TestDatePeriod:
             _ = DatePeriod(end, start)
 
 
+class TestTimePeriod:
+    @given(times=pairs(times()), date=dates())
+    def test_at_day(self, *, times: tuple[Time, Time], date: Date) -> None:
+        start, end = times
+        period = TimePeriod(start, end)
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at(date)
+        expected = ZonedDateTimePeriod(
+            date.at(start).assume_tz(UTC.key), date.at(end).assume_tz(UTC.key)
+        )
+        assert result.exact_eq(expected)
+
+    @given(times=pairs(times()), dates=pairs(dates(), sorted=True))
+    def test_at_days(
+        self, *, times: tuple[Time, Time], dates: tuple[Date, Date]
+    ) -> None:
+        start_time, end_time = times
+        period = TimePeriod(start_time, end_time)
+        start_date, end_date = dates
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at((start_date, end_date))
+        expected = ZonedDateTimePeriod(
+            start_date.at(start_time).assume_tz(UTC.key),
+            end_date.at(end_time).assume_tz(UTC.key),
+        )
+        assert result.exact_eq(expected)
+
+    @given(dates=pairs(dates(), sorted=True), times=pairs(times()))
+    def test_at_times(
+        self, *, dates: tuple[Date, Date], times: tuple[Time, Time]
+    ) -> None:
+        start_date, end_date = dates
+        period = DatePeriod(start_date, end_date)
+        start_time, end_time = times
+        with assume_does_not_raise(_PeriodInvalidError):
+            result = period.at((start_time, end_time))
+        expected = ZonedDateTimePeriod(
+            start_date.at(start_time).assume_tz(UTC.key),
+            end_date.at(end_time).assume_tz(UTC.key),
+        )
+        assert result.exact_eq(expected)
+
+    @given(times=pairs(times()), new_times=pairs(times()))
+    def test_replace(
+        self, *, times: tuple[Time, Time], new_times: tuple[Time, Time]
+    ) -> None:
+        start, end = times
+        period = TimePeriod(start, end)
+        new_start, new_end = new_times
+        new = period.replace(start=new_start, end=new_end)
+        assert new.start == new_start
+        assert new.end == new_end
+
+    @given(times=pairs(times()))
+    @mark.parametrize("func", [param(repr), param(str)])
+    def test_repr(self, *, times: tuple[Time, Time], func: Callable[..., str]) -> None:
+        start, end = times
+        period = TimePeriod(start, end)
+        result = func(period)
+        assert search(
+            r"^TimePeriod\(\d{2}:\d{2}:\d{2}(\.\d{1,6})?, \d{2}:\d{2}:\d{2}(\.\d{1,6})?\)$",
+            result,
+        )
+
+    @given(times=pairs(times()))
+    def test_to_dict(self, *, times: tuple[Time, Time]) -> None:
+        start, end = times
+        period = TimePeriod(start, end)
+        result = period.to_dict()
+        expected = _PeriodAsDict(start=start, end=end)
+        assert result == expected
+
+
 class TestZonedDateTimePeriod:
     @given(datetimes=pairs(zoned_datetimes(), sorted=True), delta=time_deltas())
     @settings(suppress_health_check={HealthCheck.filter_too_much})
@@ -292,6 +400,14 @@ class TestZonedDateTimePeriod:
         period = ZonedDateTimePeriod(start, end)
         _ = hash(period)
 
+    @given(datetimes=pairs(zoned_datetimes(), sorted=True))
+    def test_replace(self, *, datetimes: tuple[ZonedDateTime, ZonedDateTime]) -> None:
+        start, end = datetimes
+        period = ZonedDateTimePeriod(start, end)
+        new = period.replace(start=start - SECOND, end=end + SECOND)
+        assert new.start == (start - SECOND)
+        assert new.end == (end + SECOND)
+
     @given(data=data(), datetimes=pairs(zoned_datetimes(), sorted=True))
     @mark.parametrize("func", [param(repr), param(str)])
     def test_repr(

{dycw_utilities-0.150.9 → dycw_utilities-0.150.11}/src/tests/test_text.py

@@ -112,6 +112,13 @@ class TestSecretStr:
         assert repr(s) == secret_str._REPR
         assert str(s) == secret_str._REPR
 
+    def test_open(self) -> None:
+        s = secret_str("text")
+        assert isinstance(s.str, str)
+        assert not isinstance(s.str, secret_str)
+        assert repr(s.str) == repr("text")
+        assert str(s.str) == "text"
+
 
 class TestSnakeCase:
     @given(

{dycw_utilities-0.150.9 → dycw_utilities-0.150.11}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.150.9"
+__version__ = "0.150.11"

{dycw_utilities-0.150.9 → dycw_utilities-0.150.11}/src/utilities/period.py

@@ -1,22 +1,22 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Self, TypedDict, overload, override
+from typing import TYPE_CHECKING, Any, Self, TypedDict, assert_never, overload, override
 from zoneinfo import ZoneInfo
 
-from whenever import Date, DateDelta, PlainDateTime, TimeDelta, ZonedDateTime
+from whenever import Date, DateDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime
 
 from utilities.dataclasses import replace_non_sentinel
 from utilities.functions import get_class_name
 from utilities.sentinel import Sentinel, sentinel
 from utilities.whenever import format_compact
-from utilities.zoneinfo import get_time_zone_name
+from utilities.zoneinfo import UTC, ensure_time_zone, get_time_zone_name
 
 if TYPE_CHECKING:
     from utilities.types import TimeZoneLike
 
 
-class _PeriodAsDict[T: (Date, ZonedDateTime)](TypedDict):
+class _PeriodAsDict[T: (Date, Time, ZonedDateTime)](TypedDict):
     start: T
     end: T
 
@@ -49,6 +49,22 @@ class DatePeriod:
         """Offset the period."""
         return self.replace(start=self.start - other, end=self.end - other)
 
+    def at(
+        self, obj: Time | tuple[Time, Time], /, *, time_zone: TimeZoneLike = UTC
+    ) -> ZonedDateTimePeriod:
+        """Combine a date with a time to create a datetime."""
+        match obj:
+            case Time() as time:
+                start = end = time
+            case Time() as start, Time() as end:
+                ...
+            case _ as never:
+                assert_never(never)
+        tz = ensure_time_zone(time_zone).key
+        return ZonedDateTimePeriod(
+            self.start.at(start).assume_tz(tz), self.end.at(end).assume_tz(tz)
+        )
+
     @property
     def delta(self) -> DateDelta:
         """The delta of the period."""
@@ -76,6 +92,42 @@ class DatePeriod:
         return _PeriodAsDict(start=self.start, end=self.end)
 
 
+@dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
+class TimePeriod:
+    """A period of times."""
+
+    start: Time
+    end: Time
+
+    @override
+    def __repr__(self) -> str:
+        cls = get_class_name(self)
+        return f"{cls}({self.start}, {self.end})"
+
+    def replace(
+        self, *, start: Time | Sentinel = sentinel, end: Time | Sentinel = sentinel
+    ) -> Self:
+        """Replace elements of the period."""
+        return replace_non_sentinel(self, start=start, end=end)
+
+    def at(
+        self, obj: Date | tuple[Date, Date], /, *, time_zone: TimeZoneLike = UTC
+    ) -> ZonedDateTimePeriod:
+        """Combine a date with a time to create a datetime."""
+        match obj:
+            case Date() as date:
+                start = end = date
+            case Date() as start, Date() as end:
+                ...
+            case _ as never:
+                assert_never(never)
+        return DatePeriod(start, end).at((self.start, self.end), time_zone=time_zone)
+
+    def to_dict(self) -> _PeriodAsDict[Time]:
+        """Convert the period to a dictionary."""
+        return _PeriodAsDict(start=self.start, end=self.end)
+
+
 @dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
 class ZonedDateTimePeriod:
     """A period of time."""
@@ -234,4 +286,4 @@ class _PeriodExactEqArgumentsError(PeriodError):
         return f"Invalid arguments; got {self.args}"
 
 
-__all__ = ["DatePeriod", "PeriodError", "ZonedDateTimePeriod"]
+__all__ = ["DatePeriod", "PeriodError", "TimePeriod", "ZonedDateTimePeriod"]

{dycw_utilities-0.150.9 → dycw_utilities-0.150.11}/src/utilities/text.py

@@ -388,9 +388,13 @@ def _escape_separator(*, separator: str = DEFAULT_SEPARATOR) -> str:
 class secret_str(str):  # noqa: N801
     """A string with an obfuscated representation."""
 
-    __slots__ = ()
+    __slots__ = ("_text",)
     _REPR: ClassVar[str] = "***"
 
+    def __init__(self, text: str, /) -> None:
+        super().__init__()
+        self._text = text
+
     @override
     def __repr__(self) -> str:
         return self._REPR
@@ -399,6 +403,10 @@ class secret_str(str):  # noqa: N801
     def __str__(self) -> str:
         return self._REPR
 
+    @property
+    def str(self) -> str:
+        return self._text
+
 
 ##