dycw-utilities 0.131.14__tar.gz → 0.131.15__tar.gz

{dycw_utilities-0.131.14 → dycw_utilities-0.131.15}/PKG-INFO

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

{dycw_utilities-0.131.14 → dycw_utilities-0.131.15}/pyproject.toml

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

{dycw_utilities-0.131.14 → dycw_utilities-0.131.15}/src/tests/test_luigi.py

@@ -1,28 +1,25 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, cast, override
+from typing import TYPE_CHECKING, Any, Literal, cast, override
 
 from hypothesis import given
-from hypothesis.strategies import DataObject, booleans, data, sampled_from, times
-from luigi import BoolParameter, Parameter, Task
+from hypothesis.strategies import booleans
+from luigi import BoolParameter, Task
+from pytest import mark, param
 
-from utilities.hypothesis import namespace_mixins, temp_paths, zoned_datetimes
+from utilities.hypothesis import namespace_mixins, temp_paths, zoned_datetimes_whenever
 from utilities.luigi import (
-    DateHourParameter,
-    DateMinuteParameter,
-    DateSecondParameter,
     ExternalFile,
     ExternalTask,
     PathTarget,
-    TimeParameter,
+    ZonedDateTimeParameter,
     _ExternalTaskDummyTarget,
     build,
 )
-from utilities.whenever import serialize_time, serialize_zoned_datetime
 
 if TYPE_CHECKING:
-    import datetime as dt
+    from whenever import ZonedDateTime
 
 
 class TestBuild:
@@ -34,20 +31,17 @@ class TestBuild:
 
 
 class TestDateTimeParameter:
-    @given(
-        data=data(),
-        param_cls=sampled_from([
-            DateHourParameter,
-            DateMinuteParameter,
-            DateSecondParameter,
-        ]),
-        datetime=zoned_datetimes(),
-    )
+    @given(datetime=zoned_datetimes_whenever())
+    @mark.parametrize("type_", [param("datetime"), param("str")])
     def test_main(
-        self, *, data: DataObject, param_cls: type[Parameter], datetime: dt.datetime
+        self, *, datetime: ZonedDateTime, type_: Literal["datetime", "str"]
     ) -> None:
-        param = param_cls()
-        input_ = data.draw(sampled_from([datetime, serialize_zoned_datetime(datetime)]))
+        param = ZonedDateTimeParameter()
+        match type_:
+            case "datetime":
+                input_ = datetime
+            case "str":
+                input_ = datetime.format_common_iso()
         norm = param.normalize(input_)
         assert param.parse(param.serialize(norm)) == norm
 
@@ -90,12 +84,3 @@ class TestPathTarget:
         assert not target.exists()
         path.touch()
         assert target.exists()
-
-
-class TestTimeParameter:
-    @given(data=data(), time=times())
-    def test_main(self, *, data: DataObject, time: dt.time) -> None:
-        param = TimeParameter()
-        input_ = data.draw(sampled_from([time, serialize_time(time)]))
-        norm = param.normalize(input_)
-        assert param.parse(param.serialize(norm)) == time

{dycw_utilities-0.131.14 → dycw_utilities-0.131.15}/src/utilities/__init__.py

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

dycw_utilities-0.131.15/src/utilities/luigi.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+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 luigi.parameter import ParameterVisibility, _no_value
+from whenever import ZonedDateTime
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
+    from luigi.execution_summary import LuigiRunResult
+
+    from utilities.types import DateTimeRoundUnit, LogLevel, PathLike, ZonedDateTimeLike
+
+
+_T = TypeVar("_T")
+
+
+# parameters
+
+
+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
+
+
+class PathTarget(Target):
+    """A local target whose `path` attribute is a Pathlib instance."""
+
+    def __init__(self, path: PathLike, /) -> None:
+        super().__init__()
+        self.path = Path(path)
+
+    @override
+    def exists(self) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """Check if the target exists."""
+        return self.path.exists()
+
+
+# tasks
+
+
+class ExternalTask(ABC, luigi.ExternalTask):
+    """An external task with `exists()` defined here."""
+
+    @abstractmethod
+    def exists(self) -> bool:
+        """Predicate on which the external task is deemed to exist."""
+        msg = f"{self=}"  # pragma: no cover
+        raise NotImplementedError(msg)  # pragma: no cover
+
+    @override
+    def output(self) -> _ExternalTaskDummyTarget:  # pyright: ignore[reportIncompatibleMethodOverride]
+        return _ExternalTaskDummyTarget(self)
+
+
+class _ExternalTaskDummyTarget(Target):
+    """Dummy target for `ExternalTask`."""
+
+    def __init__(self, task: ExternalTask, /) -> None:
+        super().__init__()
+        self._task = task
+
+    @override
+    def exists(self) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
+        return self._task.exists()
+
+
+class ExternalFile(ExternalTask):
+    """Await an external file on the local disk."""
+
+    path: Path = cast("Any", PathParameter())
+
+    @override
+    def exists(self) -> bool:
+        return self.path.exists()
+
+
+# functions
+
+
+@overload
+def build(
+    task: Iterable[Task],
+    /,
+    *,
+    detailed_summary: Literal[False] = False,
+    local_scheduler: bool = False,
+    log_level: LogLevel | None = None,
+    workers: int | None = None,
+) -> bool: ...
+@overload
+def build(
+    task: Iterable[Task],
+    /,
+    *,
+    detailed_summary: Literal[True],
+    local_scheduler: bool = False,
+    log_level: LogLevel | None = None,
+    workers: int | None = None,
+) -> LuigiRunResult: ...
+def build(
+    task: Iterable[Task],
+    /,
+    *,
+    detailed_summary: bool = False,
+    local_scheduler: bool = False,
+    log_level: LogLevel | None = None,
+    workers: int | None = None,
+) -> bool | LuigiRunResult:
+    """Build a set of tasks."""
+    return _build(
+        task,
+        detailed_summary=detailed_summary,
+        local_scheduler=local_scheduler,
+        **({} if log_level is None else {"log_level": log_level}),
+        **({} if workers is None else {"workers": workers}),
+    )
+
+
+__all__ = [
+    "ExternalFile",
+    "ExternalTask",
+    "PathTarget",
+    "ZonedDateTimeParameter",
+    "build",
+]

dycw_utilities-0.131.14/src/utilities/luigi.py

@@ -1,228 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, cast, overload, override
-
-import luigi
-from luigi import Parameter, PathParameter, Target, Task
-from luigi import build as _build
-
-from utilities.datetime import EPOCH_UTC
-
-if TYPE_CHECKING:
-    import datetime as dt
-    from collections.abc import 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)
-
-
-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)
-
-    @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)
-
-    @override
-    def serialize(self, x: dt.time) -> str:
-        from utilities.whenever import serialize_time
-
-        return serialize_time(x)
-
-
-# targets
-
-
-class PathTarget(Target):
-    """A local target whose `path` attribute is a Pathlib instance."""
-
-    def __init__(self, path: PathLike, /) -> None:
-        super().__init__()
-        self.path = Path(path)
-
-    @override
-    def exists(self) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
-        """Check if the target exists."""
-        return self.path.exists()
-
-
-# tasks
-
-
-class ExternalTask(ABC, luigi.ExternalTask):
-    """An external task with `exists()` defined here."""
-
-    @abstractmethod
-    def exists(self) -> bool:
-        """Predicate on which the external task is deemed to exist."""
-        msg = f"{self=}"  # pragma: no cover
-        raise NotImplementedError(msg)  # pragma: no cover
-
-    @override
-    def output(self) -> _ExternalTaskDummyTarget:  # pyright: ignore[reportIncompatibleMethodOverride]
-        return _ExternalTaskDummyTarget(self)
-
-
-class _ExternalTaskDummyTarget(Target):
-    """Dummy target for `ExternalTask`."""
-
-    def __init__(self, task: ExternalTask, /) -> None:
-        super().__init__()
-        self._task = task
-
-    @override
-    def exists(self) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
-        return self._task.exists()
-
-
-class ExternalFile(ExternalTask):
-    """Await an external file on the local disk."""
-
-    path: Path = cast("Any", PathParameter())
-
-    @override
-    def exists(self) -> bool:
-        return self.path.exists()
-
-
-# functions
-
-
-@overload
-def build(
-    task: Iterable[Task],
-    /,
-    *,
-    detailed_summary: Literal[False] = False,
-    local_scheduler: bool = False,
-    log_level: LogLevel | None = None,
-    workers: int | None = None,
-) -> bool: ...
-@overload
-def build(
-    task: Iterable[Task],
-    /,
-    *,
-    detailed_summary: Literal[True],
-    local_scheduler: bool = False,
-    log_level: LogLevel | None = None,
-    workers: int | None = None,
-) -> LuigiRunResult: ...
-def build(
-    task: Iterable[Task],
-    /,
-    *,
-    detailed_summary: bool = False,
-    local_scheduler: bool = False,
-    log_level: LogLevel | None = None,
-    workers: int | None = None,
-) -> bool | LuigiRunResult:
-    """Build a set of tasks."""
-    return _build(
-        task,
-        detailed_summary=detailed_summary,
-        local_scheduler=local_scheduler,
-        **({} if log_level is None else {"log_level": log_level}),
-        **({} if workers is None else {"workers": workers}),
-    )
-
-
-__all__ = [
-    "DateHourParameter",
-    "DateMinuteParameter",
-    "DateSecondParameter",
-    "ExternalFile",
-    "ExternalTask",
-    "PathTarget",
-    "TimeParameter",
-    "build",
-]