dycw-utilities 0.109.2__tar.gz → 0.109.3__tar.gz

{dycw_utilities-0.109.2 → dycw_utilities-0.109.3}/PKG-INFO

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

{dycw_utilities-0.109.2 → dycw_utilities-0.109.3}/pyproject.toml

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

{dycw_utilities-0.109.2 → dycw_utilities-0.109.3}/src/tests/test_parse.py

@@ -135,6 +135,12 @@ class TestParseText:
         result = parse_text(dt.timedelta, text)
         assert result == timedelta
 
+    @given(x=integers(), y=integers())
+    def test_tuple(self, *, x: int, y: int) -> None:
+        text = f"({x}, {y})"
+        result = parse_text(tuple[int, int], text)
+        assert result == (x, y)
+
     @given(truth=sampled_from(["true", "false"]))
     def test_type_literal(self, *, truth: Literal["true", "false"]) -> None:
         result = parse_text(TrueOrFalseFutureTypeLit, truth)
@@ -228,6 +234,19 @@ class TestParseText:
         ):
             _ = parse_text(dt.timedelta, "invalid")
 
+    def test_error_tuple_invalid_text(self) -> None:
+        with raises(
+            ParseTextError, match=r"Unable to parse tuple\[int, int\]; got 'invalid'"
+        ):
+            _ = parse_text(tuple[int, int], "invalid")
+
+    def test_error_tuple_inconsistent_args_and_texts(self) -> None:
+        with raises(
+            ParseTextError,
+            match=r"Unable to parse tuple\[int, int\]; got '\(text1, text2, text3\)'",
+        ):
+            _ = parse_text(tuple[int, int], "(text1, text2, text3)")
+
     def test_error_unknown_annotation(self) -> None:
         with raises(ParseTextError, match=r"Unable to parse int \| str; got 'invalid'"):
             _ = parse_text(int | str, "invalid")

{dycw_utilities-0.109.2 → dycw_utilities-0.109.3}/src/tests/test_typing.py

@@ -55,6 +55,7 @@ from utilities.typing import (
     is_optional_type,
     is_sequence_type,
     is_set_type,
+    is_tuple_type,
     is_union_type,
 )
 
@@ -338,25 +339,63 @@ class TestIsAnnotationOfType:
     @mark.parametrize(
         ("func", "obj", "expected"),
         [
+            param(is_dict_type, Mapping[int, int], False),
+            param(is_dict_type, Sequence[int], False),
             param(is_dict_type, dict[int, int], True),
+            param(is_dict_type, frozenset[int], False),
             param(is_dict_type, list[int], False),
+            param(is_dict_type, set[int], False),
+            param(is_dict_type, tuple[int, int], False),
+            param(is_frozenset_type, Mapping[int, int], False),
+            param(is_frozenset_type, Sequence[int], False),
+            param(is_frozenset_type, dict[int, int], False),
             param(is_frozenset_type, frozenset[int], True),
             param(is_frozenset_type, list[int], False),
+            param(is_frozenset_type, set[int], False),
+            param(is_frozenset_type, tuple[int, int], False),
+            param(is_list_type, Mapping[int, int], False),
+            param(is_list_type, Sequence[int], False),
+            param(is_list_type, dict[int, int], False),
+            param(is_list_type, frozenset[int], False),
             param(is_list_type, list[int], True),
             param(is_list_type, set[int], False),
-            param(is_mapping_type, Mapping[int, int], True),
-            param(is_mapping_type, list[int], False),
+            param(is_list_type, tuple[int, int], False),
             param(is_literal_type, Literal["a", "b", "c"], True),
             param(is_literal_type, list[int], False),
+            param(is_mapping_type, Mapping[int, int], True),
+            param(is_mapping_type, Sequence[int], False),
+            param(is_mapping_type, dict[int, int], False),
+            param(is_mapping_type, frozenset[int], False),
+            param(is_mapping_type, list[int], False),
+            param(is_mapping_type, set[int], False),
+            param(is_mapping_type, tuple[int, int], False),
+            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),
             param(is_optional_type, int | str, False),
-            param(is_optional_type, list[int], False),
             param(is_optional_type, list[int] | None, True),
-            param(is_optional_type, Literal["a", "b", "c"], False),
-            param(is_optional_type, Literal["a", "b", "c"] | None, True),
+            param(is_optional_type, list[int], False),
+            param(is_sequence_type, Mapping[int, int], False),
             param(is_sequence_type, Sequence[int], True),
+            param(is_sequence_type, dict[int, int], False),
+            param(is_sequence_type, frozenset[int], False),
             param(is_sequence_type, list[int], False),
+            param(is_sequence_type, set[int], False),
+            param(is_sequence_type, tuple[int, int], False),
+            param(is_set_type, Mapping[int, int], False),
+            param(is_set_type, Sequence[int], False),
+            param(is_set_type, dict[int, int], False),
+            param(is_set_type, frozenset[int], False),
             param(is_set_type, list[int], False),
+            param(is_set_type, set[int], True),
+            param(is_set_type, tuple[int, int], False),
+            param(is_tuple_type, Mapping[int, int], False),
+            param(is_tuple_type, Sequence[int], False),
+            param(is_tuple_type, dict[int, int], False),
+            param(is_tuple_type, frozenset[int], False),
+            param(is_tuple_type, list[int], False),
+            param(is_tuple_type, set[int], False),
+            param(is_tuple_type, tuple[int, int], True),
             param(is_union_type, int | str, True),
             param(is_union_type, list[int], False),
         ],

{dycw_utilities-0.109.2 → dycw_utilities-0.109.3}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.109.2"
+__version__ = "0.109.3"

{dycw_utilities-0.109.2 → dycw_utilities-0.109.3}/src/utilities/parse.py

@@ -5,6 +5,7 @@ from contextlib import suppress
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
+from re import DOTALL
 from types import NoneType
 from typing import Any, override
 
@@ -12,9 +13,10 @@ 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 one, one_str
+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
+from utilities.typing import get_args, is_literal_type, is_optional_type, is_tuple_type
 from utilities.version import ParseVersionError, Version, parse_version
 
 
@@ -42,6 +44,18 @@ def parse_text(
                 return _parse_text_type(inner, text, case_sensitive=case_sensitive)
             except ParseTextError:
                 raise ParseTextError(obj=obj, text=text) from None
+    if is_tuple_type(obj):
+        args = get_args(obj)
+        try:
+            texts = extract_group(r"^\((.*)\)$", text, flags=DOTALL).split(", ")
+        except ExtractGroupError:
+            raise ParseTextError(obj=obj, text=text) from None
+        if len(args) != len(texts):
+            raise ParseTextError(obj=obj, text=text)
+        return tuple(
+            parse_text(arg, text, case_sensitive=case_sensitive, head=head)
+            for arg, text in zip(args, texts, strict=True)
+        )
     raise ParseTextError(obj=obj, text=text) from None
 
 

{dycw_utilities-0.109.2 → dycw_utilities-0.109.3}/src/utilities/typing.py

@@ -182,6 +182,14 @@ def is_set_type(obj: Any, /) -> bool:
 ##
 
 
+def is_tuple_type(obj: Any, /) -> bool:
+    """Check if an object is a tuple type annotation."""
+    return _is_annotation_of_type(obj, tuple)
+
+
+##
+
+
 def is_union_type(obj: Any, /) -> bool:
     """Check if an object is a union type annotation."""
     is_old_union = _is_annotation_of_type(obj, Union)  # pyright: ignore[reportDeprecated]
@@ -212,5 +220,6 @@ __all__ = [
     "is_optional_type",
     "is_sequence_type",
     "is_set_type",
+    "is_tuple_type",
     "is_union_type",
 ]