dycw-utilities 0.131.13__py3-none-any.whl → 0.131.15__py3-none-any.whl

{dycw_utilities-0.131.13.dist-info → dycw_utilities-0.131.15.dist-info}/METADATA

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

{dycw_utilities-0.131.13.dist-info → dycw_utilities-0.131.15.dist-info}/RECORD

@@ -1,4 +1,4 @@
-utilities/__init__.py,sha256=3uDzFx7UMHsyNY8dbs9U0P66UUimaERvIAvdIFvrju8,61
+utilities/__init__.py,sha256=TF72KRTntycdsGaFpyLS49_hW9qrELSmZAvg2kQ0BrA,61
 utilities/aiolimiter.py,sha256=mD0wEiqMgwpty4XTbawFpnkkmJS6R4JRsVXFUaoitSU,628
 utilities/altair.py,sha256=HeZBVUocjkrTNwwKrClppsIqgNFF-ykv05HfZSoHYno,9104
 utilities/asyncio.py,sha256=yfKvAIDCRrWdyQMVZMo4DJQx4nVrXoAcqwhNuF95Ryo,38186
@@ -24,7 +24,7 @@ utilities/getpass.py,sha256=DfN5UgMAtFCqS3dSfFHUfqIMZX2shXvwphOz_6J6f6A,103
 utilities/git.py,sha256=oi7-_l5e9haSANSCvQw25ufYGoNahuUPHAZ6114s3JQ,1191
 utilities/hashlib.py,sha256=SVTgtguur0P4elppvzOBbLEjVM3Pea0eWB61yg2ilxo,309
 utilities/http.py,sha256=WcahTcKYRtZ04WXQoWt5EGCgFPcyHD3EJdlMfxvDt-0,946
-utilities/hypothesis.py,sha256=3mZbEhs5yTcigV2N8PSBqe8pdg2JOYf6e5XOwgGAwjQ,45206
+utilities/hypothesis.py,sha256=hEyuJoLH0c6So0P5OESvyANpfM49Ld1iYXC4bZvacm4,42603
 utilities/importlib.py,sha256=mV1xT_O_zt_GnZZ36tl3xOmMaN_3jErDWY54fX39F6Y,429
 utilities/inflect.py,sha256=DbqB5Q9FbRGJ1NbvEiZBirRMxCxgrz91zy5jCO9ZIs0,347
 utilities/ipython.py,sha256=V2oMYHvEKvlNBzxDXdLvKi48oUq2SclRg5xasjaXStw,763
@@ -33,7 +33,7 @@ utilities/jupyter.py,sha256=ft5JA7fBxXKzP-L9W8f2-wbF0QeYc_2uLQNFDVk4Z-M,2917
 utilities/libcst.py,sha256=Jto5ppzRzsxn4AD32IS8n0lbgLYXwsVJB6EY8giNZyY,4974
 utilities/lightweight_charts.py,sha256=JrkrAZMo6JID2Eoc9QCc05Y_pK4l2zsApIhmii1z2Ig,2764
 utilities/logging.py,sha256=zm5k0Cduxtx2H2o7odxUTJtPNkJS85mqHYN1cS5Kc1w,17863
-utilities/luigi.py,sha256=fpH9MbxJDuo6-k9iCXRayFRtiVbUtibCJKugf7ygpv0,5988
+utilities/luigi.py,sha256=UAt4TDMtinLAN7sipX0jSvH-aZzHUTQbHB3Rwtbq994,4840
 utilities/math.py,sha256=_6vrDyjtaqE_OFE-F2DNWrDG_J_kMl3nFAJsok9v_bY,26862
 utilities/memory_profiler.py,sha256=tf2C51P2lCujPGvRt2Rfc7VEw5LDXmVPCG3z_AvBmbU,962
 utilities/modules.py,sha256=iuvLluJya-hvl1Q25-Jk3dLgx2Es3ck4SjJiEkAlVTs,3195
@@ -80,6 +80,7 @@ utilities/text.py,sha256=ymBFlP_cA8OgNnZRVNs7FAh7OG8HxE6YkiLEMZv5g_A,11297
 utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
 utilities/timer.py,sha256=VeSl3ot8-f4D1d3HjjSsgKvjxHJGXd_sW4KcTExOR64,2475
 utilities/traceback.py,sha256=cMXrCD59CROnezAU8VW67CxZ8Igc5QmaxlV8qrBvNMs,8504
+utilities/typed_settings.py,sha256=zUA0_CmVJT5rwrm3e-dZO83OdPXEel4NfVK24NAD5Vk,1779
 utilities/types.py,sha256=CHQke10ETEpypxppYVhWp1G68S6mvifalrRLolYBcCg,19506
 utilities/typing.py,sha256=VuGuztLSkTicxgVwI5wrVOTcY70OlzwsTU7LcFVjGlY,14169
 utilities/tzdata.py,sha256=fgNVj66yUbCSI_-vrRVzSD3gtf-L_8IEJEPjP_Jel5Y,266
@@ -91,7 +92,7 @@ utilities/whenever.py,sha256=2NQ-0SnLNW2kFpefP9dVE8H0RbaeusXYLPmv282Jpto,16755
 utilities/whenever2.py,sha256=iFVL4CjuIOpzsDU6li5smHnDEqam30-FtTgXWeHuWiE,7510
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=gJPr9l7V8s3Y7TXpCGYEM1S81Rplb9e4MoV9Nvy2VU8,1852
-dycw_utilities-0.131.13.dist-info/METADATA,sha256=BSLseH0v8xkeiTFmvQ2ITtMLy6gHtk6aFRAmuNQEy_k,1585
-dycw_utilities-0.131.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.131.13.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.131.13.dist-info/RECORD,,
+dycw_utilities-0.131.15.dist-info/METADATA,sha256=Aztn9G7ACPHL_tGTOBayxzN6aPT_8gmKwsTUcieAoUA,1585
+dycw_utilities-0.131.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.131.15.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.131.15.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.13"
+__version__ = "0.131.15"

utilities/hypothesis.py

@@ -716,85 +716,6 @@ def lists_fixed_length(
 ##
 
 
-@composite
-def min_and_max_datetimes(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[dt.datetime | None] = None,
-    max_value: MaybeSearchStrategy[dt.datetime | None] = None,
-    time_zone: MaybeSearchStrategy[ZoneInfo | timezone] = UTC,
-    round_: MathRoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-    valid: bool = False,
-) -> tuple[dt.datetime, dt.datetime]:
-    """Strategy for generating min/max datetimes."""
-    match min_value, max_value:
-        case None, None:
-            return draw(
-                pairs(
-                    zoned_datetimes(
-                        time_zone=time_zone,
-                        round_=round_,
-                        timedelta=timedelta,
-                        rel_tol=rel_tol,
-                        abs_tol=abs_tol,
-                        valid=valid,
-                    ),
-                    sorted=True,
-                )
-            )
-        case None, dt.datetime():
-            min_value_ = draw(
-                zoned_datetimes(
-                    max_value=max_value,
-                    time_zone=time_zone,
-                    round_=round_,
-                    timedelta=timedelta,
-                    rel_tol=rel_tol,
-                    abs_tol=abs_tol,
-                    valid=valid,
-                )
-            )
-            return min_value_, max_value
-        case dt.datetime(), None:
-            max_value_ = draw(
-                zoned_datetimes(
-                    min_value=min_value,
-                    time_zone=time_zone,
-                    round_=round_,
-                    timedelta=timedelta,
-                    rel_tol=rel_tol,
-                    abs_tol=abs_tol,
-                    valid=valid,
-                )
-            )
-            return min_value, max_value_
-        case dt.datetime(), dt.datetime():
-            _ = assume(min_value <= max_value)
-            return min_value, max_value
-        case _, _:
-            strategy = zoned_datetimes(
-                time_zone=time_zone,
-                round_=round_,
-                timedelta=timedelta,
-                rel_tol=rel_tol,
-                abs_tol=abs_tol,
-                valid=valid,
-            )
-            min_value_ = draw2(draw, min_value, strategy)
-            max_value_ = draw2(draw, max_value, strategy)
-            _ = assume(min_value_ <= max_value_)
-            return min_value_, max_value_
-        case _ as never:
-            assert_never(never)
-
-
-##
-
-
 @composite
 def months(
     draw: DrawFn,
@@ -1561,14 +1482,12 @@ __all__ = [
     "int64s",
     "int_arrays",
     "lists_fixed_length",
-    "min_and_max_datetimes",
     "months",
     "namespace_mixins",
     "numbers",
     "pairs",
     "paths",
     "plain_datetimes",
-    "plain_datetimes",
     "plain_datetimes_whenever",
     "random_states",
     "sentinels",

utilities/luigi.py

@@ -2,121 +2,91 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, cast, overload, override
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    TypeVar,
+    assert_never,
+    cast,
+    overload,
+    override,
+)
 
 import luigi
 from luigi import Parameter, PathParameter, Target, Task
 from luigi import build as _build
-
-from utilities.datetime import EPOCH_UTC
+from luigi.parameter import ParameterVisibility, _no_value
+from whenever import ZonedDateTime
 
 if TYPE_CHECKING:
-    import datetime as dt
-    from collections.abc import Iterable
+    from collections.abc import Callable, Iterable
 
     from luigi.execution_summary import LuigiRunResult
 
-    from utilities.types import LogLevel, MaybeStr, PathLike
-
-
-# parameters
-
-
-class DateHourParameter(luigi.DateHourParameter):
-    """A parameter which takes the value of an hourly `dt.datetime`."""
-
-    def __init__(self, interval: int = 1, **kwargs: Any) -> None:
-        super().__init__(interval, EPOCH_UTC, **kwargs)
-
-    @override
-    def normalize(self, dt: MaybeStr[dt.datetime]) -> dt.datetime:
-        from utilities.whenever import ensure_zoned_datetime
-
-        return ensure_zoned_datetime(dt)
-
-    @override
-    def parse(self, s: str) -> dt.datetime:
-        from utilities.whenever import parse_zoned_datetime
-
-        return parse_zoned_datetime(s)
-
-    @override
-    def serialize(self, dt: dt.datetime) -> str:
-        from utilities.whenever import serialize_zoned_datetime
-
-        return serialize_zoned_datetime(dt)
-
-
-class DateMinuteParameter(luigi.DateMinuteParameter):
-    """A parameter which takes the value of a minutely `dt.datetime`."""
-
-    def __init__(self, interval: int = 1, **kwargs: Any) -> None:
-        super().__init__(interval=interval, start=EPOCH_UTC, **kwargs)
-
-    @override
-    def normalize(self, dt: MaybeStr[dt.datetime]) -> dt.datetime:
-        from utilities.whenever import ensure_zoned_datetime
-
-        return ensure_zoned_datetime(dt)
-
-    @override
-    def parse(self, s: str) -> dt.datetime:
-        from utilities.whenever import parse_zoned_datetime
-
-        return parse_zoned_datetime(s)
-
-    @override
-    def serialize(self, dt: dt.datetime) -> str:
-        from utilities.whenever import serialize_zoned_datetime
-
-        return serialize_zoned_datetime(dt)
-
+    from utilities.types import DateTimeRoundUnit, LogLevel, PathLike, ZonedDateTimeLike
 
-class DateSecondParameter(luigi.DateSecondParameter):
-    """A parameter which takes the value of a secondly `dt.datetime`."""
 
-    def __init__(self, interval: int = 1, **kwargs: Any) -> None:
-        super().__init__(interval, EPOCH_UTC, **kwargs)
+_T = TypeVar("_T")
 
-    @override
-    def normalize(self, dt: MaybeStr[dt.datetime]) -> dt.datetime:
-        from utilities.whenever import ensure_zoned_datetime
-
-        return ensure_zoned_datetime(dt)
-
-    @override
-    def parse(self, s: str) -> dt.datetime:
-        from utilities.whenever import parse_zoned_datetime
-
-        return parse_zoned_datetime(s)
 
-    @override
-    def serialize(self, dt: dt.datetime) -> str:
-        from utilities.whenever import serialize_zoned_datetime
-
-        return serialize_zoned_datetime(dt)
-
-
-class TimeParameter(Parameter):
-    """A parameter which takes the value of a `dt.time`."""
-
-    @override
-    def normalize(self, x: MaybeStr[dt.time]) -> dt.time:
-        from utilities.whenever import ensure_time
-
-        return ensure_time(x)
-
-    @override
-    def parse(self, x: str) -> dt.time:
-        from utilities.whenever import parse_time
-
-        return parse_time(x)
+# parameters
 
-    @override
-    def serialize(self, x: dt.time) -> str:
-        from utilities.whenever import serialize_time
 
-        return serialize_time(x)
+class ZonedDateTimeParameter(Parameter):
+    """A parameter which takes the value of a zoned datetime."""
+
+    _unit: DateTimeRoundUnit
+    _increment: int
+
+    @override
+    def __init__(
+        self,
+        default: Any = _no_value,
+        is_global: bool = False,
+        significant: bool = True,
+        description: str | None = None,
+        config_path: None = None,
+        positional: bool = True,
+        always_in_help: bool = False,
+        batch_method: Callable[[Iterable[_T]], _T] | None = None,
+        visibility: ParameterVisibility = ParameterVisibility.PUBLIC,
+        *,
+        unit: DateTimeRoundUnit = "second",
+        increment: int = 1,
+    ) -> None:
+        super().__init__(
+            default,
+            is_global,
+            significant,
+            description,
+            config_path,
+            positional,
+            always_in_help,
+            batch_method,
+            visibility,
+        )
+        self._unit = unit
+        self._increment = increment
+
+    @override
+    def normalize(self, x: ZonedDateTimeLike) -> ZonedDateTime:
+        match x:
+            case ZonedDateTime() as date_time:
+                ...
+            case str() as text:
+                date_time = ZonedDateTime.parse_common_iso(text)
+            case _ as never:
+                assert_never(never)
+        return date_time.round(self._unit, increment=self._increment, mode="floor")
+
+    @override
+    def parse(self, x: str) -> ZonedDateTime:
+        return ZonedDateTime.parse_common_iso(x)
+
+    @override
+    def serialize(self, x: ZonedDateTime) -> str:
+        return x.format_common_iso()
 
 
 # targets
@@ -217,12 +187,9 @@ def build(
 
 
 __all__ = [
-    "DateHourParameter",
-    "DateMinuteParameter",
-    "DateSecondParameter",
     "ExternalFile",
     "ExternalTask",
     "PathTarget",
-    "TimeParameter",
+    "ZonedDateTimeParameter",
     "build",
 ]

utilities/typed_settings.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, TypeVar, override
+
+from typed_settings.converters import TSConverter
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+_T = TypeVar("_T")
+
+
+class ExtendedTSConverter(TSConverter):
+    """An extension of the TSConverter for custom types."""
+
+    @override
+    def __init__(
+        self,
+        *,
+        resolve_paths: bool = True,
+        strlist_sep: str | Callable[[str], list] | None = ":",
+    ) -> None:
+        super().__init__(resolve_paths=resolve_paths, strlist_sep=strlist_sep)
+        cases: list[tuple[type[Any], Callable[..., Any]]] = [
+            (Date, Date.parse_common_iso),
+            (DateDelta, DateDelta.parse_common_iso),
+            (DateTimeDelta, DateTimeDelta.parse_common_iso),
+            (PlainDateTime, PlainDateTime.parse_common_iso),
+            (Time, Time.parse_common_iso),
+            (TimeDelta, TimeDelta.parse_common_iso),
+            (ZonedDateTime, ZonedDateTime.parse_common_iso),
+        ]
+        extras = {cls: _make_converter(cls, func) for cls, func in cases}
+        self.scalar_converters |= extras
+
+
+def _make_converter(
+    cls: type[_T], parser: Callable[[str], _T], /
+) -> Callable[[Any, type[Any]], Any]:
+    def hook(value: _T | str, _: type[_T] = cls, /) -> Any:
+        if not isinstance(value, (cls, str)):  # pragma: no cover
+            msg = f"Invalid type {type(value).__name__!r}; expected '{cls.__name__}' or 'str'"
+            raise TypeError(msg)
+        if isinstance(value, str):
+            return parser(value)
+        return value
+
+    return hook
+
+
+__all__ = ["ExtendedTSConverter"]