dycw-utilities 0.110.1__tar.gz → 0.110.2__tar.gz

{dycw_utilities-0.110.1 → dycw_utilities-0.110.2}/PKG-INFO

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

{dycw_utilities-0.110.1 → dycw_utilities-0.110.2}/pyproject.toml

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

{dycw_utilities-0.110.1 → dycw_utilities-0.110.2}/src/tests/test_text.py

@@ -20,9 +20,12 @@ from utilities.hypothesis import text_ascii
 from utilities.text import (
     ParseBoolError,
     ParseNoneError,
-    SplitStrError,
     _SplitKeyValuePairsDuplicateKeysError,
     _SplitKeyValuePairsSplitError,
+    _SplitStrClosingBracketMismatchedError,
+    _SplitStrClosingBracketUnmatchedError,
+    _SplitStrCountError,
+    _SplitStrOpeningBracketUnmatchedError,
     join_strs,
     parse_bool,
     parse_none,
@@ -114,7 +117,7 @@ class TestSplitKeyValuePairs:
             _ = split_key_value_pairs("a=1,a=22,a=333", mapping=True)
 
 
-class TestSplitStrAndJoinStr:
+class TestSplitAndJoinStr:
     @given(
         data=data(),
         case=sampled_from([
@@ -126,9 +129,10 @@ class TestSplitStrAndJoinStr:
             ("1,22", 2, ["1", "22"]),
             ("1,22,333", 3, ["1", "22", "333"]),
             ("1,,333", 3, ["1", "", "333"]),
+            ("1,(22,22,22),333", 5, ["1", "(22", "22", "22)", "333"]),
         ]),
     )
-    def test_main(self, *, case: tuple[str, int, list[str]], data: DataObject) -> None:
+    def test_main(self, *, data: DataObject, case: tuple[str, int, list[str]]) -> None:
         text, n, expected = case
         n_use = data.draw(just(n) | none())
         result = split_str(text, n=n_use)
@@ -138,6 +142,29 @@ class TestSplitStrAndJoinStr:
             assert result == tuple(expected)
         assert join_strs(result) == text
 
+    @given(
+        data=data(),
+        case=sampled_from([
+            ("1", 1, ["1"]),
+            ("1,22", 2, ["1", "22"]),
+            ("1,22,333", 3, ["1", "22", "333"]),
+            ("1,(22),333", 3, ["1", "(22)", "333"]),
+            ("1,(22,22),333", 3, ["1", "(22,22)", "333"]),
+            ("1,(22,22,22),333", 3, ["1", "(22,22,22)", "333"]),
+        ]),
+    )
+    def test_brackets(
+        self, *, data: DataObject, case: tuple[str, int, list[str]]
+    ) -> None:
+        text, n, expected = case
+        n_use = data.draw(just(n) | none())
+        result = split_str(text, brackets=[("(", ")")], n=n_use)
+        if n_use is None:
+            assert result == expected
+        else:
+            assert result == tuple(expected)
+        assert join_strs(result) == text
+
     @given(texts=lists(text_ascii()))
     def test_generic(self, *, texts: list[str]) -> None:
         assert split_str(join_strs(texts)) == texts
@@ -146,12 +173,34 @@ class TestSplitStrAndJoinStr:
     def test_sort(self, *, texts: set[str]) -> None:
         assert split_str(join_strs(texts, sort=True)) == sorted(texts)
 
-    def test_error(self) -> None:
+    def test_error_closing_bracket_mismatched(self) -> None:
+        with raises(
+            _SplitStrClosingBracketMismatchedError,
+            match=r"Unable to split '1,\(22\},333'; got mismatched '\(' at position 2 and '}' at position 5",
+        ):
+            _ = split_str("1,(22},333", brackets=[("(", ")"), ("{", "}")])
+
+    def test_error_closing_bracket_unmatched(self) -> None:
         with raises(
-            SplitStrError, match=r"Unable to split '1,22,333' into 4 part\(s\); got 3"
+            _SplitStrClosingBracketUnmatchedError,
+            match=r"Unable to split '1,22\),333'; got unmatched '\)' at position 4",
+        ):
+            _ = split_str("1,22),333", brackets=[("(", ")")])
+
+    def test_error_count(self) -> None:
+        with raises(
+            _SplitStrCountError,
+            match=r"Unable to split '1,22,333' into 4 part\(s\); got 3",
         ):
             _ = split_str("1,22,333", n=4)
 
+    def test_error_opening_bracket(self) -> None:
+        with raises(
+            _SplitStrOpeningBracketUnmatchedError,
+            match=r"Unable to split '1,\(22,333'; got unmatched '\(' at position 2",
+        ):
+            _ = split_str("1,(22,333", brackets=[("(", ")")])
+
 
 class TestSnakeCase:
     @given(

{dycw_utilities-0.110.1 → dycw_utilities-0.110.2}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.110.1"
+__version__ = "0.110.2"

{dycw_utilities-0.110.1 → dycw_utilities-0.110.2}/src/utilities/text.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 import re
+from collections import deque
 from dataclasses import dataclass
-from re import IGNORECASE, Match, search
+from itertools import chain
+from re import IGNORECASE, Match, escape, search
 from textwrap import dedent
 from typing import TYPE_CHECKING, Any, Literal, overload, override
 
-from utilities.iterables import CheckDuplicatesError, check_duplicates
+from utilities.iterables import CheckDuplicatesError, check_duplicates, transpose
 from utilities.reprlib import get_repr
 
 if TYPE_CHECKING:
@@ -167,47 +169,134 @@ class _SplitKeyValuePairsDuplicateKeysError(SplitKeyValuePairsError):
 
 
 @overload
-def split_str(text: str, /, *, separator: str = ",", n: Literal[1]) -> tuple[str]: ...
+def split_str(
+    text: str,
+    /,
+    *,
+    separator: str = ",",
+    brackets: Iterable[tuple[str, str]] | None = None,
+    n: Literal[1],
+) -> tuple[str]: ...
 @overload
 def split_str(
-    text: str, /, *, separator: str = ",", n: Literal[2]
+    text: str,
+    /,
+    *,
+    separator: str = ",",
+    brackets: Iterable[tuple[str, str]] | None = None,
+    n: Literal[2],
 ) -> tuple[str, str]: ...
 @overload
 def split_str(
-    text: str, /, *, separator: str = ",", n: Literal[3]
+    text: str,
+    /,
+    *,
+    separator: str = ",",
+    brackets: Iterable[tuple[str, str]] | None = None,
+    n: Literal[3],
 ) -> tuple[str, str, str]: ...
 @overload
 def split_str(
-    text: str, /, *, separator: str = ",", n: Literal[4]
+    text: str,
+    /,
+    *,
+    separator: str = ",",
+    brackets: Iterable[tuple[str, str]] | None = None,
+    n: Literal[4],
 ) -> tuple[str, str, str, str]: ...
 @overload
 def split_str(
-    text: str, /, *, separator: str = ",", n: Literal[5]
+    text: str,
+    /,
+    *,
+    separator: str = ",",
+    brackets: Iterable[tuple[str, str]] | None = None,
+    n: Literal[5],
 ) -> tuple[str, str, str, str, str]: ...
 @overload
 def split_str(
-    text: str, /, *, separator: str = ",", n: int | None = None
+    text: str,
+    /,
+    *,
+    separator: str = ",",
+    brackets: Iterable[tuple[str, str]] | None = None,
+    n: int | None = None,
 ) -> Sequence[str]: ...
 def split_str(
-    text: str, /, *, separator: str = ",", n: int | None = None
+    text: str,
+    /,
+    *,
+    separator: str = ",",
+    brackets: Iterable[tuple[str, str]] | None = None,
+    n: int | None = None,
 ) -> Sequence[str]:
     """Split a string, with a special provision for the empty string."""
     if text == "":
         texts = []
     elif text == _escape_separator(separator=separator):
         texts = [""]
-    else:
+    elif brackets is None:
         texts = text.split(separator)
+    else:
+        texts = _split_str_brackets(text, brackets, separator=separator)
     if n is None:
         return texts
     if len(texts) != n:
-        raise SplitStrError(text=text, n=n, texts=texts)
+        raise _SplitStrCountError(text=text, n=n, texts=texts)
     return tuple(texts)
 
 
+def _split_str_brackets(
+    text: str, brackets: Iterable[tuple[str, str]], /, *, separator: str = ","
+) -> Sequence[str]:
+    brackets = list(brackets)
+    opens, closes = transpose(brackets)
+    close_to_open = {close: open_ for open_, close in brackets}
+
+    escapes = map(escape, chain(chain.from_iterable(brackets), [separator]))
+    pattern = re.compile("|".join(escapes))
+
+    results: Sequence[str] = []
+    stack: deque[tuple[str, int]] = deque()
+    last = 0
+
+    for match in pattern.finditer(text):
+        token, position = match.group(), match.start()
+        if token in opens:
+            stack.append((token, position))
+        elif token in closes:
+            if len(stack) == 0:
+                raise _SplitStrClosingBracketUnmatchedError(
+                    text=text, token=token, position=position
+                )
+            open_token, open_position = stack.pop()
+            if open_token != close_to_open[token]:
+                raise _SplitStrClosingBracketMismatchedError(
+                    text=text,
+                    opening_token=open_token,
+                    opening_position=open_position,
+                    closing_token=token,
+                    closing_position=position,
+                )
+        elif (token == separator) and (len(stack) == 0):
+            results.append(text[last:position].strip())
+            last = position + 1
+    results.append(text[last:].strip())
+    if len(stack) >= 1:
+        token, position = stack.pop()
+        raise _SplitStrOpeningBracketUnmatchedError(
+            text=text, token=token, position=position
+        )
+    return results
+
+
 @dataclass(kw_only=True, slots=True)
 class SplitStrError(Exception):
     text: str
+
+
+@dataclass(kw_only=True, slots=True)
+class _SplitStrCountError(SplitStrError):
     n: int
     texts: Sequence[str]
 
@@ -216,6 +305,38 @@ class SplitStrError(Exception):
         return f"Unable to split {self.text!r} into {self.n} part(s); got {len(self.texts)}"
 
 
+@dataclass(kw_only=True, slots=True)
+class _SplitStrClosingBracketMismatchedError(SplitStrError):
+    opening_token: str
+    opening_position: int
+    closing_token: str
+    closing_position: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to split {self.text!r}; got mismatched {self.opening_token!r} at position {self.opening_position} and {self.closing_token!r} at position {self.closing_position}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _SplitStrClosingBracketUnmatchedError(SplitStrError):
+    token: str
+    position: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to split {self.text!r}; got unmatched {self.token!r} at position {self.position}"
+
+
+@dataclass(kw_only=True, slots=True)
+class _SplitStrOpeningBracketUnmatchedError(SplitStrError):
+    token: str
+    position: int
+
+    @override
+    def __str__(self) -> str:
+        return f"Unable to split {self.text!r}; got unmatched {self.token!r} at position {self.position}"
+
+
 def join_strs(
     texts: Iterable[str], /, *, sort: bool = False, separator: str = ","
 ) -> str: