dycw-utilities 0.165.1__tar.gz → 0.165.3__tar.gz

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/PKG-INFO

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

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/pyproject.toml

@@ -233,7 +233,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.165.1"
+version = "0.165.3"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -266,7 +266,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.165.1"
+current_version = "0.165.3"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/src/tests/test_polars.py

@@ -194,6 +194,7 @@ from utilities.polars import (
     reify_exprs,
     replace_time_zone,
     round_to_float,
+    search_period,
     select_exact,
     serialize_dataframe,
     serialize_series,
@@ -224,6 +225,7 @@ from utilities.whenever import (
     get_now,
     get_now_plain,
     get_today,
+    to_zoned_date_time,
 )
 from utilities.zoneinfo import UTC, to_time_zone_name
 
@@ -2474,6 +2476,94 @@ class TestRoundToFloat:
             _ = round_to_float(cast("Any", x), cast("Any", y))
 
 
+class TestSearchPeriod:
+    @mark.parametrize(
+        ("time", "exp_start", "exp_end"),
+        [
+            param(whenever.Time(8, 58), None, None),
+            param(whenever.Time(8, 59), None, None),
+            param(whenever.Time(9), 0, None),
+            param(whenever.Time(9, 1), 0, 0),
+            param(whenever.Time(9, 59), 0, 0),
+            param(whenever.Time(10), 1, 0),
+            param(whenever.Time(10, 1), 1, 1),
+            param(whenever.Time(10, 59), 1, 1),
+            param(whenever.Time(11), 2, 1),
+            param(whenever.Time(11, 1), 2, 2),
+            param(whenever.Time(11, 59), 2, 2),
+            param(whenever.Time(12), None, 2),
+            param(whenever.Time(12, 1), None, None),
+            param(whenever.Time(12, 59), None, None),
+            param(whenever.Time(13), 3, None),
+            param(whenever.Time(13, 1), 3, 3),
+            param(whenever.Time(13, 59), 3, 3),
+            param(whenever.Time(14), None, 3),
+            param(whenever.Time(14, 1), None, None),
+            param(whenever.Time(14, 59), None, None),
+            param(whenever.Time(15), 4, None),
+            param(whenever.Time(15, 1), 4, 4),
+            param(whenever.Time(15, 59), 4, 4),
+            param(whenever.Time(16), None, 4),
+            param(whenever.Time(16, 1), None, None),
+            param(whenever.Time(16, 2), None, None),
+        ],
+    )
+    @mark.parametrize("start_or_end", [param("start"), param("end")])
+    def test_main(
+        self,
+        *,
+        time: whenever.Time,
+        start_or_end: Literal["start", "end"],
+        exp_start: int | None,
+        exp_end: int | None,
+    ) -> None:
+        date = whenever.Date(2000, 1, 1)
+        sr = DataFrame(
+            data=[
+                (
+                    date.at(whenever.Time(s)).py_datetime(),
+                    date.at(whenever.Time(e)).py_datetime(),
+                )
+                for s, e in [(9, 10), (10, 11), (11, 12), (13, 14), (15, 16)]
+            ],
+            schema={"start": DatetimeUTC, "end": DatetimeUTC},
+            orient="row",
+        ).with_columns(datetime=struct("start", "end"))["datetime"]
+        assert len(sr) == 5
+        date_time = date.at(time).assume_tz(UTC.key)
+        match start_or_end:
+            case "start":
+                expected = exp_start
+            case "end":
+                expected = exp_end
+            case never:
+                assert_never(never)
+        index = search_period(sr, date_time, start_or_end=start_or_end)
+        if expected is None:
+            assert index is None
+        else:
+            assert index is not None
+            assert 0 <= index <= (len(sr) - 1)
+            start, end = map(
+                to_zoned_date_time, cast("Iterable[dt.datetime]", sr[index].values())
+            )
+            match start_or_end:
+                case "start":
+                    assert start <= date_time < end
+                case "end":
+                    assert start < date_time <= end
+                case never:
+                    assert_never(never)
+            if index > 0:
+                prev_end = to_zoned_date_time(cast("dt.datetime", sr[index - 1]["end"]))
+                assert prev_end <= date_time
+            if index < (len(sr) - 1):
+                next_start = to_zoned_date_time(
+                    cast("dt.datetime", sr[index + 1]["start"])
+                )
+                assert date_time <= next_start
+
+
 class TestSelectExact:
     df: ClassVar[DataFrame] = DataFrame(
         data=[(True, False), (False, None), (None, True)],

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/src/tests/test_typing.py

@@ -10,9 +10,11 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Final,
+    ForwardRef,
     Literal,
     NamedTuple,
-    TypedDict,
+    NotRequired,
+    _TypedDictMeta,  # pyright: ignore[reportAttributeAccessIssue]
     assert_never,
 )
 from uuid import UUID
@@ -50,6 +52,8 @@ from tests.test_typing_funcs.no_future import (
     DataClassNoFutureNestedInnerFirstOuter,
     DataClassNoFutureNestedOuterFirstInner,
     DataClassNoFutureNestedOuterFirstOuter,
+    TypedDictNoFutureIntFloat,
+    TypedDictNoFutureIntFloatOptional,
 )
 from tests.test_typing_funcs.with_future import (
     DataClassFutureDate,
@@ -80,10 +84,11 @@ from tests.test_typing_funcs.with_future import (
     TrueOrFalseFutureLit,
     TrueOrFalseFutureTypeLit,
     TypedDictFutureIntFloat,
+    TypedDictFutureIntFloatOptional,
 )
 from utilities.hypothesis import text_ascii
 from utilities.sentinel import Sentinel
-from utilities.types import LogLevel, Number, Parallelism, Seed
+from utilities.types import LogLevel, Number, Parallelism, Seed, StrMapping
 from utilities.typing import (
     IsInstanceGenError,
     IsSubclassGenError,
@@ -92,6 +97,7 @@ from utilities.typing import (
     _GetUnionTypeClassesInternalTypeError,
     _GetUnionTypeClassesUnionTypeError,
     get_args,
+    get_forward_ref_args,
     get_literal_elements,
     get_type_classes,
     get_type_hints,
@@ -107,6 +113,8 @@ from utilities.typing import (
     is_mapping_type,
     is_namedtuple_class,
     is_namedtuple_instance,
+    is_not_required_annotation,
+    is_not_required_type,
     is_optional_type,
     is_sequence_of,
     is_sequence_of_tuple_or_str_mapping,
@@ -158,6 +166,13 @@ class TestGetArgs:
         assert result == expected
 
 
+class TestGetForwardRefArgs:
+    def test_main(self) -> None:
+        args = get_forward_ref_args(TypedDictFutureIntFloat)
+        expected = {"int_": "int", "float_": "float"}
+        assert args == expected
+
+
 type _PlusOrMinusOneLit = Literal[1, -1]
 type _TruthLit = Literal["true", "false"]
 type _True = Literal["true"]
@@ -495,13 +510,23 @@ class TestGetTypeHints:
         expected = {"truth": TrueOrFalseFutureTypeLit}
         assert hints == expected
 
-    def test_typed_dict(self) -> None:
-        class Example(TypedDict):
-            int_: int
-            float_: float
-
-        hints = get_type_hints(Example)
-        expected = {"int_": int, "float_": float}
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(TypedDictNoFutureIntFloat, {"int_": int, "float_": float}),
+            param(TypedDictFutureIntFloat, {"int_": int, "float_": float}),
+            param(
+                TypedDictNoFutureIntFloatOptional,
+                {"int_": int, "float_": NotRequired[float]},
+            ),
+            param(
+                TypedDictFutureIntFloatOptional,
+                {"int_": int, "float_": NotRequired[float]},
+            ),
+        ],
+    )
+    def test_typed_dict(self, *, obj: _TypedDictMeta, expected: StrMapping) -> None:
+        hints = get_type_hints(obj)
         assert hints == expected
 
     @given(data=data())
@@ -637,6 +662,8 @@ class TestIsAnnotationOfType:
             param(is_mapping_type, list[int], False),
             param(is_mapping_type, set[int], False),
             param(is_mapping_type, tuple[int, int], False),
+            param(is_not_required_type, NotRequired, True),
+            param(is_not_required_type, NotRequired[int], True),
             param(is_optional_type, Literal["a", "b", "c"] | None, True),
             param(is_optional_type, Literal["a", "b", "c"], False),
             param(is_optional_type, int | None, True),
@@ -824,8 +851,39 @@ class TestIsInstanceGen:
             param({"int_": 0, "float_": 0.0, "extra": None}, True),
         ],
     )
-    def test_typed_dict(self, *, obj: Any, expected: bool) -> None:
-        result = is_instance_gen(obj, TypedDictFutureIntFloat)
+    @mark.parametrize(
+        "cls", [param(TypedDictNoFutureIntFloat), param(TypedDictFutureIntFloat)]
+    )
+    def test_typed_dict(self, *, obj: Any, cls: _TypedDictMeta, expected: bool) -> None:
+        result = is_instance_gen(obj, cls)
+        assert result is expected
+
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(None, False),
+            param({}, False),
+            param({None: False}, False),
+            param({"int_": None}, False),
+            param({"int_": 0}, True),
+            param({"int_": None, "float_": None}, False),
+            param({"int_": 0, "float_": None}, True),
+            param({"int_": None, "float_": 0.0}, False),
+            param({"int_": 0, "float_": 0.0}, True),
+            param({"int_": 0, "float_": 0.0, "extra": None}, True),
+        ],
+    )
+    @mark.parametrize(
+        "cls",
+        [
+            param(TypedDictNoFutureIntFloatOptional),
+            param(TypedDictFutureIntFloatOptional),
+        ],
+    )
+    def test_typed_dict_optional(
+        self, *, obj: Any, cls: _TypedDictMeta, expected: bool
+    ) -> None:
+        result = is_instance_gen(obj, cls)
         assert result is expected
 
     def test_error(self) -> None:
@@ -884,6 +942,27 @@ class TestIsNamedTuple:
         assert not is_namedtuple_instance(Example(x=0))
 
 
+class TestIsNotRequiredAnnotation:
+    @mark.parametrize(
+        ("obj", "expected"),
+        [
+            param(NotRequired, True),
+            param(NotRequired[int], True),
+            param(int, False),
+            param("NotRequired", True),
+            param("NotRequired[int]", True),
+            param("int", False),
+            param(ForwardRef("NotRequired"), True),
+            param(ForwardRef("NotRequired[int]"), True),
+            param(ForwardRef("int"), False),
+            param(None, False),
+        ],
+    )
+    def test_main(self, *, obj: Any, expected: bool) -> None:
+        result = is_not_required_annotation(obj)
+        assert result is expected
+
+
 class TestIsSequenceOf:
     @mark.parametrize(
         ("obj", "expected"),

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/src/tests/test_typing_funcs/no_future.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Literal
+from typing import Literal, NotRequired, TypedDict
 
 TrueOrFalseNoFutureLit = Literal["true", "false"]
 type TrueOrFalseNoFutureTypeLit = Literal["true", "false"]
@@ -33,3 +33,13 @@ class DataClassNoFutureNestedOuterFirstOuter:
 @dataclass(kw_only=True)
 class DataClassNoFutureNestedOuterFirstInner:
     int_: int
+
+
+class TypedDictNoFutureIntFloat(TypedDict):
+    int_: int
+    float_: float
+
+
+class TypedDictNoFutureIntFloatOptional(TypedDict):
+    int_: int
+    float_: NotRequired[float]

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/src/tests/test_typing_funcs/with_future.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Literal, TypedDict, override
+from typing import TYPE_CHECKING, Literal, NotRequired, TypedDict, override
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -239,3 +239,8 @@ class DataClassFutureZonedDateTimePeriod:
 class TypedDictFutureIntFloat(TypedDict):
     int_: int
     float_: float
+
+
+class TypedDictFutureIntFloatOptional(TypedDict):
+    int_: int
+    float_: NotRequired[float]

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.165.1"
+__version__ = "0.165.3"

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/src/utilities/polars.py

@@ -105,6 +105,7 @@ from utilities.whenever import (
 from utilities.zoneinfo import UTC, to_time_zone_name
 
 if TYPE_CHECKING:
+    import datetime as dt
     from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
     from collections.abc import Set as AbstractSet
 
@@ -2460,6 +2461,34 @@ class RoundToFloatError(Exception):
 ##
 
 
+def search_period(
+    series: Series,
+    date_time: ZonedDateTime,
+    /,
+    *,
+    start_or_end: Literal["start", "end"] = "end",
+) -> int | None:
+    """Search a series of periods for the one containing a given date-time."""
+    start, end = [series.struct[k] for k in ["start", "end"]]
+    py_date_time = date_time.py_datetime()
+    match start_or_end:
+        case "start":
+            index = end.search_sorted(py_date_time, side="right")
+            if index >= len(series):
+                return None
+            item: dt.datetime = series[index]["start"]
+            return index if py_date_time >= item else None
+        case "end":
+            index = end.search_sorted(py_date_time, side="left")
+            if index >= len(series):
+                return None
+            item: dt.datetime = series[index]["start"]
+            return index if py_date_time > item else None
+
+
+##
+
+
 def select_exact(
     df: DataFrame, /, *columns: IntoExprColumn, drop: MaybeIterable[str] | None = None
 ) -> DataFrame:
@@ -2750,6 +2779,7 @@ __all__ = [
     "read_series",
     "replace_time_zone",
     "round_to_float",
+    "search_period",
     "select_exact",
     "serialize_dataframe",
     "set_first_row_as_columns",

{dycw_utilities-0.165.1 → dycw_utilities-0.165.3}/src/utilities/typing.py

@@ -6,12 +6,14 @@ from dataclasses import dataclass, is_dataclass
 from functools import partial
 from itertools import chain
 from pathlib import Path
+from re import search
 from types import NoneType, UnionType
 from typing import (
     Any,
     ForwardRef,
     Literal,
     NamedTuple,
+    NotRequired,
     Optional,  # pyright: ignore[reportDeprecated]
     TypeAliasType,
     TypeGuard,
@@ -56,6 +58,18 @@ def get_args(obj: Any, /, *, optional_drop_none: bool = False) -> tuple[Any, ...
 ##
 
 
+def get_forward_ref_args(obj: Any, /) -> Mapping[str, str]:
+    """Get the forward args."""
+    return {
+        k: v.__forward_arg__
+        for k, v in obj.__annotations__.items()
+        if isinstance(v, ForwardRef)
+    }
+
+
+##
+
+
 def get_literal_elements(obj: Any, /) -> list[Any]:
     """Get the elements of a literal annotation."""
     return _get_literal_elements_inner(obj)
@@ -151,21 +165,20 @@ def get_type_hints(
     globalns_use = globals() | ({} if globalns is None else dict(globalns))
     localns_use = {} if localns is None else dict(localns)
     result: dict[str, Any] = obj.__annotations__
-    result = {
-        k: v.__forward_arg__ if isinstance(v, ForwardRef) else v
-        for k, v in result.items()
-    }
+    result = result | dict(get_forward_ref_args(obj))
     try:
-        hints = _get_type_hints(obj, globalns=globalns_use, localns=localns_use)
+        hints = _get_type_hints(
+            obj, globalns=globalns_use, localns=localns_use, include_extras=True
+        )
     except NameError as error:
         if warn_name_errors:
             warn(f"Error getting type hints for {obj!r}; {error}", stacklevel=2)
     else:
-        result.update({
+        result = result | {
             key: value
             for key, value in hints.items()
             if (key not in result) or isinstance(result[key], str)
-        })
+        }
     return result
 
 
@@ -393,17 +406,21 @@ def _is_instance_typed_dict[T: _TypedDictMeta](
     hints = get_type_hints(
         type_, globalns=globalns, localns=localns, warn_name_errors=warn_name_errors
     )
-    if not set(obj).issuperset(hints):
+    optional = {
+        k for k, v in type_.__annotations__.items() if is_not_required_annotation(v)
+    }
+    required = {k: v for k, v in hints.items() if k not in optional}
+    if not set(obj).issuperset(required):
         return False
     return all(
         is_instance_gen(
             obj[k],
-            hints[k],
+            required[k],
             globalns=globalns,
             localns=localns,
             warn_name_errors=warn_name_errors,
         )
-        for k in hints
+        for k in required
     )
 
 
@@ -577,6 +594,30 @@ def _is_namedtuple_core(obj: Any, /) -> bool:
 ##
 
 
+def is_not_required_annotation(obj: Any) -> bool:
+    """Check if an annotation is not required."""
+    if is_not_required_type(obj):
+        return True
+    match obj:
+        case str() as text:
+            return bool(search("NotRequired", text))
+        case ForwardRef() as fr:
+            return is_not_required_annotation(fr.__forward_arg__)
+        case _:
+            return False
+
+
+##
+
+
+def is_not_required_type(obj: Any, /) -> bool:
+    """Check if an object is a not-required type annotation."""
+    return (obj is NotRequired) or _is_annotation_of_type(obj, NotRequired)
+
+
+##
+
+
 def is_optional_type(obj: Any, /) -> bool:
     """Check if an object is an optional type annotation."""
     is_optional = _is_annotation_of_type(obj, Optional)  # pyright: ignore[reportDeprecated]
@@ -889,6 +930,8 @@ __all__ = [
     "is_mapping_type",
     "is_namedtuple_class",
     "is_namedtuple_instance",
+    "is_not_required_annotation",
+    "is_not_required_type",
     "is_optional_type",
     "is_sequence_of",
     "is_sequence_of_tuple_or_str_mapping",