dycw-utilities 0.166.0__tar.gz → 0.166.2__tar.gz

{dycw_utilities-0.166.0 → dycw_utilities-0.166.2}/PKG-INFO

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

{dycw_utilities-0.166.0 → dycw_utilities-0.166.2}/pyproject.toml

@@ -233,7 +233,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.166.0"
+version = "0.166.2"
 
 [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.166.0"
+current_version = "0.166.2"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.166.0 → dycw_utilities-0.166.2}/src/tests/test_polars.py

@@ -838,21 +838,20 @@ class TestChoice:
 
 
 class TestColumnsToDict:
-    def test_main(self) -> None:
-        df = DataFrame(
-            data=[{"a": 1, "b": 11}, {"a": 2, "b": 12}, {"a": 3, "b": 13}],
-            schema={"a": Int64, "b": Int64},
-        )
-        mapping = columns_to_dict(df, "a", "b")
-        assert mapping == {1: 11, 2: 12, 3: 13}
+    schema: ClassVar[SchemaDict] = {"x": Int64, "y": Int64}
+
+    @mark.parametrize("x", [param("x"), param(col.x)])
+    @mark.parametrize("y", [param("y"), param(col.y)])
+    def test_main(self, *, x: IntoExprColumn, y: IntoExprColumn) -> None:
+        df = DataFrame(data=[(1, 2), (3, 4), (5, 6)], schema=self.schema, orient="row")
+        mapping = columns_to_dict(df, x, y)
+        expected = {1: 2, 3: 4, 5: 6}
+        assert mapping == expected
 
     def test_error(self) -> None:
-        df = DataFrame(
-            data=[{"a": 1, "b": 11}, {"a": 2, "b": 12}, {"a": 1, "b": 13}],
-            schema={"a": Int64, "b": Int64},
-        )
-        with raises(ColumnsToDictError, match="DataFrame must be unique on 'a':\n\n.*"):
-            _ = columns_to_dict(df, "a", "b")
+        df = DataFrame(data=[(1, 1), (1, 2), (1, 3)], schema=self.schema, orient="row")
+        with raises(ColumnsToDictError, match="DataFrame must be unique on 'x':\n\n.*"):
+            _ = columns_to_dict(df, "x", "y")
 
 
 class TestConcatSeries:

{dycw_utilities-0.166.0 → dycw_utilities-0.166.2}/src/tests/test_whenever.py

@@ -72,7 +72,6 @@ from utilities.whenever import (
     DatePeriodError,
     MeanDateTimeError,
     MinMaxDateError,
-    PeriodDict,
     TimePeriod,
     ToMonthsAndDaysError,
     ToNanosecondsError,
@@ -280,13 +279,8 @@ class TestDatePeriod:
 
     @given(data=data(), period=date_periods())
     def test_to_and_from_dict(self, *, data: DataObject, period: DatePeriod) -> None:
-        dict1 = period.to_dict()
-        dstart, dend = dict1["start"], dict1["end"]
-        dict2 = PeriodDict(
-            start=data.draw(sampled_from([dstart, dstart.py_date()])),
-            end=data.draw(sampled_from([dend, dend.py_date()])),
-        )
-        result = DatePeriod.from_dict(dict2)
+        dict_ = data.draw(sampled_from([period.to_dict(), period.to_py_dict()]))
+        result = DatePeriod.from_dict(dict_)
         assert result == period
 
     @given(dates=pairs(dates(), unique=True, sorted=True))
@@ -853,14 +847,11 @@ class TestTimePeriod:
         )
 
     @given(data=data(), period=time_periods())
-    def test_to_and_from_dict(self, *, data: DataObject, period: TimePeriod) -> None:
-        dict1 = period.to_dict()
-        dstart, dend = dict1["start"], dict1["end"]
-        dict2 = PeriodDict(
-            start=data.draw(sampled_from([dstart, dstart.py_time()])),
-            end=data.draw(sampled_from([dend, dend.py_time()])),
-        )
-        result = TimePeriod.from_dict(dict2)
+    def test_to_dict_and_from_dict(
+        self, *, data: DataObject, period: TimePeriod
+    ) -> None:
+        dict_ = data.draw(sampled_from([period.to_dict(), period.to_py_dict()]))
+        result = TimePeriod.from_dict(dict_)
         assert result == period
 
 
@@ -1695,13 +1686,8 @@ class TestZonedDateTimePeriod:
     ) -> None:
         start, end = datetimes
         period = ZonedDateTimePeriod(start, end)
-        dict1 = period.to_dict()
-        dstart, dend = dict1["start"], dict1["end"]
-        dict2 = PeriodDict(
-            start=data.draw(sampled_from([dstart, dstart.py_datetime()])),
-            end=data.draw(sampled_from([dend, dend.py_datetime()])),
-        )
-        result = ZonedDateTimePeriod.from_dict(dict2)
+        dict_ = data.draw(sampled_from([period.to_dict(), period.to_py_dict()]))
+        result = ZonedDateTimePeriod.from_dict(dict_)
         assert result == period
 
     @given(period=zoned_date_time_periods())

{dycw_utilities-0.166.0 → dycw_utilities-0.166.2}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.166.0"
+__version__ = "0.166.2"

{dycw_utilities-0.166.0 → dycw_utilities-0.166.2}/src/utilities/polars.py

@@ -830,13 +830,15 @@ def choice(
 ##
 
 
-def columns_to_dict(df: DataFrame, key: str, value: str, /) -> dict[Any, Any]:
+def columns_to_dict(
+    df: DataFrame, key: IntoExprColumn, value: IntoExprColumn, /
+) -> dict[Any, Any]:
     """Map a pair of columns into a dictionary. Must be unique on `key`."""
-    col_key = df[key]
-    if col_key.is_duplicated().any():
-        raise ColumnsToDictError(df=df, key=key)
-    col_value = df[value]
-    return dict(zip(col_key, col_value, strict=True))
+    df = df.select(key, value)
+    key_col, value_col = [df[get_expr_name(df, expr)] for expr in [key, value]]
+    if key_col.is_duplicated().any():
+        raise ColumnsToDictError(df=df, key=key_col.name)
+    return dict(zip(key_col, value_col, strict=True))
 
 
 @dataclass(kw_only=True, slots=True)

{dycw_utilities-0.166.0 → dycw_utilities-0.166.2}/src/utilities/whenever.py

@@ -13,7 +13,6 @@ from typing import (
     Self,
     SupportsFloat,
     TypedDict,
-    TypeVar,
     assert_never,
     cast,
     overload,
@@ -146,9 +145,6 @@ def sub_year_month(x: YearMonth, /, *, years: int = 0, months: int = 0) -> YearM
 ##
 
 
-_TDate_co = TypeVar("_TDate_co", bound=Date | dt.date, covariant=True)
-
-
 @dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
 class DatePeriod:
     """A period of dates."""
@@ -210,7 +206,7 @@ class DatePeriod:
         return f"{fc(start)}-{fc(end)}"
 
     @classmethod
-    def from_dict(cls, mapping: PeriodDict[_TDate_co], /) -> Self:
+    def from_dict(cls, mapping: PeriodDict[Date] | PeriodDict[dt.date], /) -> Self:
         """Convert the dictionary to a period."""
         match mapping["start"]:
             case Date() as start:
@@ -238,6 +234,10 @@ class DatePeriod:
         """Convert the period to a dictionary."""
         return PeriodDict(start=self.start, end=self.end)
 
+    def to_py_dict(self) -> PeriodDict[dt.date]:
+        """Convert the period to a dictionary."""
+        return PeriodDict(start=self.start.py_date(), end=self.end.py_date())
+
 
 @dataclass(kw_only=True, slots=True)
 class DatePeriodError(Exception):
@@ -788,9 +788,6 @@ class _RoundDateOrDateTimeDateTimeIntraDayWithWeekdayError(RoundDateOrDateTimeEr
 ##
 
 
-_TTime_co = TypeVar("_TTime_co", bound=Time | dt.time, covariant=True)
-
-
 @dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
 class TimePeriod:
     """A period of times."""
@@ -817,7 +814,7 @@ class TimePeriod:
         return DatePeriod(start, end).at((self.start, self.end), time_zone=time_zone)
 
     @classmethod
-    def from_dict(cls, mapping: PeriodDict[_TTime_co], /) -> Self:
+    def from_dict(cls, mapping: PeriodDict[Time] | PeriodDict[dt.time], /) -> Self:
         """Convert the dictionary to a period."""
         match mapping["start"]:
             case Time() as start:
@@ -845,6 +842,10 @@ class TimePeriod:
         """Convert the period to a dictionary."""
         return PeriodDict(start=self.start, end=self.end)
 
+    def to_py_dict(self) -> PeriodDict[dt.time]:
+        """Convert the period to a dictionary."""
+        return PeriodDict(start=self.start.py_time(), end=self.end.py_time())
+
 
 ##
 
@@ -1726,11 +1727,6 @@ class WheneverLogRecord(LogRecord):
 ##
 
 
-_TDateTime_co = TypeVar(
-    "_TDateTime_co", bound=ZonedDateTime | dt.datetime, covariant=True
-)
-
-
 @dataclass(repr=False, order=True, unsafe_hash=True, kw_only=False)
 class ZonedDateTimePeriod:
     """A period of time."""
@@ -1833,7 +1829,9 @@ class ZonedDateTimePeriod:
         return f"{fc(start.to_plain())}-{fc(end, fmt='%Y%m%dT%H')}"
 
     @classmethod
-    def from_dict(cls, mapping: PeriodDict[_TDateTime_co], /) -> Self:
+    def from_dict(
+        cls, mapping: PeriodDict[ZonedDateTime] | PeriodDict[dt.datetime], /
+    ) -> Self:
         """Convert the dictionary to a period."""
         match mapping["start"]:
             case ZonedDateTime() as start:
@@ -1869,6 +1867,10 @@ class ZonedDateTimePeriod:
         """Convert the period to a dictionary."""
         return PeriodDict(start=self.start, end=self.end)
 
+    def to_py_dict(self) -> PeriodDict[dt.datetime]:
+        """Convert the period to a dictionary."""
+        return PeriodDict(start=self.start.py_datetime(), end=self.end.py_datetime())
+
     def to_tz(self, time_zone: TimeZoneLike, /) -> Self:
         """Convert the time zone."""
         tz = to_time_zone_name(time_zone)