dycw-utilities 0.109.5__tar.gz → 0.109.6__tar.gz

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/PKG-INFO

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

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/pyproject.toml

@@ -89,7 +89,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.109.5"
+version = "0.109.6"
 
 [project.optional-dependencies]
 test = [
@@ -332,7 +332,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.109.5"
+current_version = "0.109.6"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/src/tests/test_math.py

@@ -16,7 +16,7 @@ from hypothesis.strategies import (
 from numpy import iinfo, int8, int16, int32, int64, uint8, uint16, uint32, uint64
 from pytest import approx, raises
 
-from utilities.hypothesis import int32s, pairs
+from utilities.hypothesis import int32s, numbers, pairs
 from utilities.math import (
     MAX_INT8,
     MAX_INT16,
@@ -36,6 +36,7 @@ from utilities.math import (
     MIN_UINT64,
     CheckIntegerError,
     NumberOfDecimalsError,
+    ParseNumberError,
     SafeRoundError,
     _EWMParameters,
     _EWMParametersAlphaError,
@@ -91,6 +92,7 @@ from utilities.math import (
     is_zero_or_non_micro_or_nan,
     number_of_decimals,
     order_of_magnitude,
+    parse_number,
     round_,
     round_float_imprecisions,
     round_to_float,
@@ -895,6 +897,18 @@ class TestOrderOfMagnitude:
         assert res_int == exp_int
 
 
+class TestParseNumber:
+    @given(number=numbers())
+    def test_main(self, *, number: Number) -> None:
+        serialized = str(number)
+        result = parse_number(serialized)
+        assert result == number
+
+    def test_error(self) -> None:
+        with raises(ParseNumberError, match="Unable to parse number; got 'invalid'"):
+            _ = parse_number("invalid")
+
+
 class TestRound:
     @given(
         case=sampled_from([

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/src/tests/test_parse.py

@@ -19,7 +19,9 @@ from tests.test_typing_funcs.with_future import (
 )
 from utilities.functions import ensure_path
 from utilities.hypothesis import (
+    datetime_durations,
     local_datetimes,
+    numbers,
     paths,
     text_ascii,
     timedeltas_2w,
@@ -33,10 +35,12 @@ from utilities.parse import (
     parse_text,
 )
 from utilities.sentinel import Sentinel, sentinel
+from utilities.types import Duration, Number
 from utilities.version import Version
 from utilities.whenever import (
     serialize_date,
     serialize_datetime,
+    serialize_duration,
     serialize_time,
     serialize_timedelta,
 )
@@ -61,6 +65,12 @@ class TestParseText:
         result = parse_text(dt.datetime, text)
         assert result == datetime
 
+    @given(duration=datetime_durations(two_way=True))
+    def test_duration(self, *, duration: Duration) -> None:
+        text = serialize_duration(duration)
+        result = parse_text(Duration, text)
+        assert result == duration
+
     @given(truth=sampled_from(TruthEnum))
     def test_enum(self, *, truth: TruthEnum) -> None:
         text = truth.name
@@ -95,17 +105,6 @@ class TestParseText:
         result = parse_text(TrueOrFalseFutureLit, truth)
         assert result == truth
 
-    def test_nullable_int_none(self) -> None:
-        text = str(None)
-        result = parse_text(int | None, text)
-        assert result is None
-
-    @given(value=integers())
-    def test_nullable_int_int(self, *, value: int) -> None:
-        text = str(value)
-        result = parse_text(int | None, text)
-        assert result == value
-
     def test_none(self) -> None:
         text = str(None)
         result = parse_text(None, text)
@@ -116,6 +115,12 @@ class TestParseText:
         result = parse_text(NoneType, text)
         assert result is None
 
+    @given(number=numbers())
+    def test_number(self, *, number: Number) -> None:
+        text = str(number)
+        result = parse_text(Number, text)
+        assert result == number
+
     @given(path=paths())
     def test_path(self, *, path: Path) -> None:
         text = str(path)
@@ -129,6 +134,39 @@ class TestParseText:
         result = ensure_path(parse_text(Path, text))
         assert result == result.expanduser()
 
+    def test_nullable_number_none(self) -> None:
+        text = str(None)
+        result = parse_text(Number | None, text)
+        assert result is None
+
+    @given(number=numbers())
+    def test_nullable_number_number(self, *, number: Number) -> None:
+        text = str(number)
+        result = parse_text(Number | None, text)
+        assert result == number
+
+    def test_nullable_duration_none(self) -> None:
+        text = str(None)
+        result = parse_text(Duration | None, text)
+        assert result is None
+
+    @given(duration=datetime_durations(two_way=True))
+    def test_nullable_duration_duration(self, *, duration: Duration) -> None:
+        text = serialize_duration(duration)
+        result = parse_text(Duration | None, text)
+        assert result == duration
+
+    def test_nullable_int_none(self) -> None:
+        text = str(None)
+        result = parse_text(int | None, text)
+        assert result is None
+
+    @given(value=integers())
+    def test_nullable_int_int(self, *, value: int) -> None:
+        text = str(value)
+        result = parse_text(int | None, text)
+        assert result == value
+
     def test_sentinel(self) -> None:
         text = str(sentinel)
         result = parse_text(Sentinel, text)
@@ -188,6 +226,12 @@ class TestParseText:
         ):
             _ = parse_text(dt.datetime, "invalid")
 
+    def test_error_duration(self) -> None:
+        with raises(
+            _ParseTextParseError, match=r"Unable to parse Duration; got 'invalid'"
+        ):
+            _ = parse_text(Duration, "invalid")
+
     def test_error_enum(self) -> None:
         with raises(
             _ParseTextParseError,
@@ -264,6 +308,12 @@ class TestParseText:
         ):
             _ = parse_text(Iterable[None] | None, "invalid")
 
+    def test_error_number(self) -> None:
+        with raises(
+            _ParseTextParseError, match=r"Unable to parse Number; got 'invalid'"
+        ):
+            _ = parse_text(Number, "invalid")
+
     def test_error_sentinel(self) -> None:
         with raises(
             _ParseTextParseError,
@@ -306,15 +356,17 @@ class TestParseText:
             _ = parse_text(int | str, "invalid")
 
     def test_error_unknown_type(self) -> None:
-        @dataclass(kw_only=True)
-        class Example:
-            pass
-
         with raises(
             _ParseTextParseError,
-            match=r"Unable to parse <class 'tests\.test_parse\.TestParseText\.test_error_unknown_type\.<locals>\.Example'>; got 'invalid'",
+            match=r"Unable to parse <class 'tests\.test_typing_funcs\.with_future\.DataClassFutureInt'>; got 'invalid'",
+        ):
+            _ = parse_text(DataClassFutureInt, "invalid")
+
+    def test_error_unknown_union_type(self) -> None:
+        with raises(
+            _ParseTextParseError, match=r"Unable to parse <class '.*'>; got 'invalid'"
         ):
-            _ = parse_text(Example, "invalid")
+            _ = parse_text(DataClassFutureInt | DataClassFutureInt, "invalid")
 
     def test_error_version(self) -> None:
         with raises(

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.109.5"
+__version__ = "0.109.6"

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/src/utilities/math.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+from contextlib import suppress
 from dataclasses import dataclass
 from math import ceil, exp, floor, isclose, isfinite, isinf, isnan, log, log10, modf
 from re import Match, search
@@ -9,7 +10,8 @@ from typing import TYPE_CHECKING, Literal, assert_never, overload, override
 from utilities.errors import ImpossibleCaseError
 
 if TYPE_CHECKING:
-    from utilities.types import RoundMode
+    from utilities.types import Number, RoundMode
+
 
 MIN_FLOAT32, MAX_FLOAT32 = -3.4028234663852886e38, 3.4028234663852886e38
 MIN_FLOAT64, MAX_FLOAT64 = -1.7976931348623157e308, 1.7976931348623157e308
@@ -681,6 +683,27 @@ def order_of_magnitude(x: float, /, *, round_: bool = False) -> float:
 ##
 
 
+def parse_number(number: str, /) -> Number:
+    """Convert text into a number."""
+    with suppress(ValueError):
+        return int(number)
+    with suppress(ValueError):
+        return float(number)
+    raise ParseNumberError(number=number)
+
+
+@dataclass(kw_only=True, slots=True)
+class ParseNumberError(Exception):
+    number: str
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to parse number; got {self.number!r}"
+
+
+##
+
+
 def round_(
     x: float,
     /,
@@ -887,6 +910,7 @@ __all__ = [
     "MIN_UINT64",
     "CheckIntegerError",
     "EWMParametersError",
+    "ParseNumberError",
     "SafeRoundError",
     "check_integer",
     "ewm_parameters",
@@ -934,6 +958,7 @@ __all__ = [
     "is_zero_or_non_micro_or_nan",
     "number_of_decimals",
     "order_of_magnitude",
+    "parse_number",
     "round_",
     "round_float_imprecisions",
     "round_to_float",

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/src/utilities/parse.py

@@ -13,10 +13,18 @@ from utilities.datetime import is_subclass_date_not_datetime
 from utilities.enum import ParseEnumError, parse_enum
 from utilities.functions import is_subclass_int_not_bool
 from utilities.iterables import OneEmptyError, OneNonUniqueError, one, one_str
+from utilities.math import ParseNumberError, parse_number
 from utilities.re import ExtractGroupError, extract_group
 from utilities.sentinel import ParseSentinelError, Sentinel, parse_sentinel
 from utilities.text import ParseBoolError, ParseNoneError, parse_bool, parse_none
-from utilities.typing import get_args, is_literal_type, is_optional_type, is_tuple_type
+from utilities.types import Duration, Number
+from utilities.typing import (
+    get_args,
+    is_literal_type,
+    is_optional_type,
+    is_tuple_type,
+    is_union_type,
+)
 from utilities.version import ParseVersionError, Version, parse_version
 
 if TYPE_CHECKING:
@@ -31,8 +39,8 @@ def parse_text(
     text: str,
     /,
     *,
-    case_sensitive: bool = False,
     head: bool = False,
+    case_sensitive: bool = False,
     extra: Mapping[type[_T], Callable[[str], _T]] | None = None,
 ) -> Any:
     """Parse text."""
@@ -49,13 +57,12 @@ def parse_text(
         with suppress(ParseNoneError):
             return parse_none(text)
         inner = one(arg for arg in get_args(obj) if arg is not NoneType)
-        if isinstance(
-            inner := one(arg for arg in get_args(obj) if arg is not NoneType), type
-        ):
-            try:
-                return _parse_text_type(inner, text, case_sensitive=case_sensitive)
-            except _ParseTextParseError:
-                raise _ParseTextParseError(obj=obj, text=text) from None
+        try:
+            return parse_text(
+                inner, text, head=head, case_sensitive=case_sensitive, extra=extra
+            )
+        except _ParseTextParseError:
+            raise _ParseTextParseError(obj=obj, text=text) from None
     if is_tuple_type(obj):
         args = get_args(obj)
         try:
@@ -65,9 +72,11 @@ def parse_text(
         if len(args) != len(texts):
             raise _ParseTextParseError(obj=obj, text=text)
         return tuple(
-            parse_text(arg, text, case_sensitive=case_sensitive, head=head)
+            parse_text(arg, text, head=head, case_sensitive=case_sensitive, extra=extra)
             for arg, text in zip(args, texts, strict=True)
         )
+    if is_union_type(obj):
+        return _parse_text_union_type(obj, text)
     raise _ParseTextParseError(obj=obj, text=text) from None
 
 
@@ -161,6 +170,22 @@ def _parse_text_type(
     raise _ParseTextParseError(obj=cls, text=text) from None
 
 
+def _parse_text_union_type(obj: Any, text: str, /) -> Any:
+    if obj is Number:
+        try:
+            return parse_number(text)
+        except ParseNumberError:
+            raise _ParseTextParseError(obj=obj, text=text) from None
+    if obj is Duration:
+        from utilities.whenever import ParseDurationError, parse_duration
+
+        try:
+            return parse_duration(text)
+        except ParseDurationError:
+            raise _ParseTextParseError(obj=obj, text=text) from None
+    raise _ParseTextParseError(obj=obj, text=text) from None
+
+
 @dataclass
 class ParseTextError(Exception):
     obj: Any

{dycw_utilities-0.109.5 → dycw_utilities-0.109.6}/src/utilities/whenever.py

@@ -17,6 +17,7 @@ from utilities.datetime import (
     parse_two_digit_year,
     timedelta_to_microseconds,
 )
+from utilities.math import ParseNumberError, parse_number
 from utilities.re import (
     ExtractGroupError,
     ExtractGroupsError,
@@ -298,10 +299,8 @@ class ParseDateTimeError(Exception):
 
 def parse_duration(duration: str, /) -> Duration:
     """Parse a string into a Duration."""
-    with suppress(ValueError):
-        return int(duration)
-    with suppress(ValueError):
-        return float(duration)
+    with suppress(ParseNumberError):
+        return parse_number(duration)
     try:
         return parse_timedelta(duration)
     except ParseTimedeltaError: