dycw-utilities 0.162.5__tar.gz → 0.162.7__tar.gz

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/PKG-INFO

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

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/pyproject.toml

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

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/src/tests/test_orjson.py

@@ -20,7 +20,6 @@ from hypothesis.strategies import (
     sets,
     tuples,
 )
-from orjson import JSONDecodeError
 from polars import Object, String, UInt64
 from pytest import approx, mark, param, raises
 from whenever import ZonedDateTime
@@ -73,6 +72,7 @@ from utilities.orjson import (
     OrjsonFormatter,
     OrjsonLogRecord,
     Unserializable,
+    _DeserializeInvalidJSONError,
     _DeserializeNoObjectsError,
     _DeserializeObjectNotFoundError,
     _object_hook_get_object,
@@ -428,7 +428,7 @@ class TestGetLogRecords:
         assert result.num_lines_error == 1
         assert result.missing == set()
         assert len(result.other_errors) == 1
-        assert isinstance(one(result.other_errors), JSONDecodeError)
+        assert isinstance(one(result.other_errors), _DeserializeInvalidJSONError)
 
 
 class TestOrjsonFormatter:
@@ -753,6 +753,14 @@ class TestSerialize:
         assert result == expected
 
 
+class TestDeserialize:
+    def test_error_invalid_json(self) -> None:
+        with raises(
+            _DeserializeInvalidJSONError, match="Invalid JSON: b'invalid json'"
+        ):
+            _ = deserialize(b"invalid json")
+
+
 class TestObjectHookGetObject:
     def test_main(self) -> None:
         result = _object_hook_get_object(Sentinel.__qualname__, objects={Sentinel})

dycw_utilities-0.162.7/src/tests/test_testbook.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from json import dumps
+from re import search
+from typing import TYPE_CHECKING, ClassVar
+
+from pytest import mark, param
+
+from utilities.functions import get_class_name
+from utilities.testbook import build_notebook_tester
+from utilities.whenever import HOUR
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from utilities.types import Delta
+
+
+class TestBuildNotebookTester:
+    text: ClassVar[str] = dumps({"cells": []})
+
+    def test_main(self, *, tmp_path: Path) -> None:
+        mapping = {
+            "notebook": "test_notebook",
+            "notebook_with_underscores": "test_notebook_with_underscores",
+            "notebook-with-dashes": "test_notebook_with_dashes",
+        }
+        for stem in mapping:
+            _ = tmp_path.joinpath(f"{stem}.ipynb").write_text(self.text)
+        tester = build_notebook_tester(tmp_path)
+        assert search(r"^TestTestMain\d+$", get_class_name(tester))
+        for name in mapping.values():
+            assert hasattr(tester, name)
+
+    @mark.parametrize("throttle", [param(HOUR), param(None)])
+    def test_throttle(self, *, tmp_path: Path, throttle: Delta | None) -> None:
+        _ = tmp_path.joinpath("notebook.ipynb").write_text(self.text)
+        _ = build_notebook_tester(tmp_path, throttle=throttle)

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/src/tests/test_text.py

@@ -30,6 +30,7 @@ from utilities.text import (
     join_strs,
     parse_bool,
     parse_none,
+    pascal_case,
     repr_encode,
     secret_str,
     snake_case,
@@ -43,8 +44,6 @@ from utilities.text import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
-
     from utilities.sentinel import Sentinel
 
 
@@ -68,20 +67,21 @@ class TestParseBool:
         result = parse_bool(text)
         assert result is value
 
-    @given(
-        text=sampled_from([
-            "00",
-            "11",
-            "ffalsee",
-            "invalid",
-            "nn",
-            "nnoo",
-            "oofff",
-            "oonn",
-            "ttruee",
-            "yy",
-            "yyess",
-        ])
+    @mark.parametrize(
+        "text",
+        [
+            param("00"),
+            param("11"),
+            param("ffalsee"),
+            param("invalid"),
+            param("nn"),
+            param("nnoo"),
+            param("oofff"),
+            param("oonn"),
+            param("ttruee"),
+            param("yy"),
+            param("yyess"),
+        ],
     )
     def test_error(self, *, text: str) -> None:
         with raises(ParseBoolError, match="Unable to parse boolean value; got '.*'"):
@@ -96,7 +96,7 @@ class TestParseNone:
         result = parse_none(text_use)
         assert result is None
 
-    @given(text=sampled_from(["invalid", "nnonee"]))
+    @mark.parametrize("text", [param("invalid"), param("nnonee")])
     def test_error(self, *, text: str) -> None:
         with raises(ParseNoneError, match="Unable to parse null value; got '.*'"):
             _ = parse_none(text)
@@ -110,6 +110,62 @@ class TestReprEncode:
         assert result == expected
 
 
+class TestPascalAndSnakeCase:
+    @mark.parametrize(
+        ("text", "exp_pascal", "exp_snake"),
+        [
+            param("API", "API", "api"),
+            param("APIResponse", "APIResponse", "api_response"),
+            param(
+                "ApplicationController",
+                "ApplicationController",
+                "application_controller",
+            ),
+            param("Area51Controller", "Area51Controller", "area51_controller"),
+            param("FreeBSD", "FreeBSD", "free_bsd"),
+            param("HTML", "HTML", "html"),
+            param("HTMLTidy", "HTMLTidy", "html_tidy"),
+            param("HTMLTidyGenerator", "HTMLTidyGenerator", "html_tidy_generator"),
+            param("HTMLVersion", "HTMLVersion", "html_version"),
+            param("NoHTML", "NoHTML", "no_html"),
+            param("One   Two", "OneTwo", "one_two"),
+            param("One  Two", "OneTwo", "one_two"),
+            param("One Two", "OneTwo", "one_two"),
+            param("OneTwo", "OneTwo", "one_two"),
+            param("One_Two", "OneTwo", "one_two"),
+            param("One__Two", "OneTwo", "one_two"),
+            param("One___Two", "OneTwo", "one_two"),
+            param("Product", "Product", "product"),
+            param("SpecialGuest", "SpecialGuest", "special_guest"),
+            param("Text", "Text", "text"),
+            param("Text123", "Text123", "text123"),
+            param("Text123Text456", "Text123Text456", "text123_text456"),
+            param("_APIResponse_", "APIResponse", "_api_response_"),
+            param("_API_", "API", "_api_"),
+            param("__APIResponse__", "APIResponse", "_api_response_"),
+            param("__API__", "API", "_api_"),
+            param("__impliedVolatility_", "ImpliedVolatility", "_implied_volatility_"),
+            param("_itemID", "ItemID", "_item_id"),
+            param("_lastPrice__", "LastPrice", "_last_price_"),
+            param("_symbol", "Symbol", "_symbol"),
+            param("aB", "AB", "a_b"),
+            param("changePct", "ChangePct", "change_pct"),
+            param("changePct_", "ChangePct", "change_pct_"),
+            param("impliedVolatility", "ImpliedVolatility", "implied_volatility"),
+            param("lastPrice", "LastPrice", "last_price"),
+            param("memMB", "MemMB", "mem_mb"),
+            param("sizeX", "SizeX", "size_x"),
+            param("symbol", "Symbol", "symbol"),
+            param("testNTest", "TestNTest", "test_n_test"),
+            param("text", "Text", "text"),
+            param("text123", "Text123", "text123"),
+        ],
+    )
+    def test_main(self, *, text: str, exp_pascal: str, exp_snake: str) -> None:
+        assert pascal_case(text) == exp_pascal
+        assert snake_case(text) == exp_snake
+
+
 class TestSecretStr:
     def test_main(self) -> None:
         s = secret_str("text")
@@ -124,74 +180,26 @@ class TestSecretStr:
         assert str(s.str) == "text"
 
 
-class TestSnakeCase:
-    @given(
-        case=sampled_from([
-            ("API", "api"),
-            ("APIResponse", "api_response"),
-            ("ApplicationController", "application_controller"),
-            ("Area51Controller", "area51_controller"),
-            ("FreeBSD", "free_bsd"),
-            ("HTML", "html"),
-            ("HTMLTidy", "html_tidy"),
-            ("HTMLTidyGenerator", "html_tidy_generator"),
-            ("HTMLVersion", "html_version"),
-            ("NoHTML", "no_html"),
-            ("One   Two", "one_two"),
-            ("One  Two", "one_two"),
-            ("One Two", "one_two"),
-            ("OneTwo", "one_two"),
-            ("One_Two", "one_two"),
-            ("One__Two", "one_two"),
-            ("One___Two", "one_two"),
-            ("Product", "product"),
-            ("SpecialGuest", "special_guest"),
-            ("Text", "text"),
-            ("Text123", "text123"),
-            ("_APIResponse_", "_api_response_"),
-            ("_API_", "_api_"),
-            ("__APIResponse__", "_api_response_"),
-            ("__API__", "_api_"),
-            ("__impliedVolatility_", "_implied_volatility_"),
-            ("_itemID", "_item_id"),
-            ("_lastPrice__", "_last_price_"),
-            ("_symbol", "_symbol"),
-            ("aB", "a_b"),
-            ("changePct", "change_pct"),
-            ("changePct_", "change_pct_"),
-            ("impliedVolatility", "implied_volatility"),
-            ("lastPrice", "last_price"),
-            ("memMB", "mem_mb"),
-            ("sizeX", "size_x"),
-            ("symbol", "symbol"),
-            ("testNTest", "test_n_test"),
-            ("text", "text"),
-            ("text123", "text123"),
-        ])
-    )
-    def test_main(self, *, case: tuple[str, str]) -> None:
-        text, expected = case
-        result = snake_case(text)
-        assert result == expected
-
-
 class TestSplitKeyValuePairs:
-    @given(
-        case=sampled_from([
-            ("", []),
-            ("a=1", [("a", "1")]),
-            ("a=1,b=22", [("a", "1"), ("b", "22")]),
-            ("a=1,b=22,c=333", [("a", "1"), ("b", "22"), ("c", "333")]),
-            ("=1", [("", "1")]),
-            ("a=", [("a", "")]),
-            ("a=1,=22,c=333", [("a", "1"), ("", "22"), ("c", "333")]),
-            ("a=1,b=,c=333", [("a", "1"), ("b", ""), ("c", "333")]),
-            ("a=1,b=(22,22,22),c=333", [("a", "1"), ("b", "(22,22,22)"), ("c", "333")]),
-            ("a=1,b=(c=22),c=333", [("a", "1"), ("b", "(c=22)"), ("c", "333")]),
-        ])
+    @mark.parametrize(
+        ("text", "expected"),
+        [
+            param("", []),
+            param("a=1", [("a", "1")]),
+            param("a=1,b=22", [("a", "1"), ("b", "22")]),
+            param("a=1,b=22,c=333", [("a", "1"), ("b", "22"), ("c", "333")]),
+            param("=1", [("", "1")]),
+            param("a=", [("a", "")]),
+            param("a=1,=22,c=333", [("a", "1"), ("", "22"), ("c", "333")]),
+            param("a=1,b=,c=333", [("a", "1"), ("b", ""), ("c", "333")]),
+            param(
+                "a=1,b=(22,22,22),c=333",
+                [("a", "1"), ("b", "(22,22,22)"), ("c", "333")],
+            ),
+            param("a=1,b=(c=22),c=333", [("a", "1"), ("b", "(c=22)"), ("c", "333")]),
+        ],
     )
-    def test_main(self, *, case: tuple[str, Sequence[tuple[str, str]]]) -> None:
-        text, expected = case
+    def test_main(self, *, text: str, expected: str) -> None:
         result = split_key_value_pairs(text)
         assert result == expected
 
@@ -223,22 +231,24 @@ class TestSplitKeyValuePairs:
 
 
 class TestSplitAndJoinStr:
-    @given(
-        data=data(),
-        case=sampled_from([
-            ("", 0, []),
-            (r"\,", 1, [""]),
-            (",", 2, ["", ""]),
-            (",,", 3, ["", "", ""]),
-            ("1", 1, ["1"]),
-            ("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"]),
-        ]),
+    @given(data=data())
+    @mark.parametrize(
+        ("text", "n", "expected"),
+        [
+            param("", 0, []),
+            param(r"\,", 1, [""]),
+            param(",", 2, ["", ""]),
+            param(",,", 3, ["", "", ""]),
+            param("1", 1, ["1"]),
+            param("1,22", 2, ["1", "22"]),
+            param("1,22,333", 3, ["1", "22", "333"]),
+            param("1,,333", 3, ["1", "", "333"]),
+            param("1,(22,22,22),333", 5, ["1", "(22", "22", "22)", "333"]),
+        ],
     )
-    def test_main(self, *, data: DataObject, case: tuple[str, int, list[str]]) -> None:
-        text, n, expected = case
+    def test_main(
+        self, *, data: DataObject, text: str, n: int, expected: list[str]
+    ) -> None:
         n_use = data.draw(just(n) | none())
         result = split_str(text, n=n_use)
         if n_use is None:
@@ -247,21 +257,21 @@ class TestSplitAndJoinStr:
             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"]),
-        ]),
+    @given(data=data())
+    @mark.parametrize(
+        ("text", "n", "expected"),
+        [
+            param("1", 1, ["1"]),
+            param("1,22", 2, ["1", "22"]),
+            param("1,22,333", 3, ["1", "22", "333"]),
+            param("1,(22),333", 3, ["1", "(22)", "333"]),
+            param("1,(22,22),333", 3, ["1", "(22,22)", "333"]),
+            param("1,(22,22,22),333", 3, ["1", "(22,22,22)", "333"]),
+        ],
     )
     def test_brackets(
-        self, *, data: DataObject, case: tuple[str, int, list[str]]
+        self, *, data: DataObject, text: str, n: int, expected: 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:

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.162.5"
+__version__ = "0.162.7"

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/src/utilities/orjson.py

@@ -20,6 +20,7 @@ from orjson import (
     OPT_PASSTHROUGH_DATACLASS,
     OPT_PASSTHROUGH_DATETIME,
     OPT_SORT_KEYS,
+    JSONDecodeError,
     dumps,
     loads,
 )
@@ -371,8 +372,12 @@ def deserialize(
     redirects: Mapping[str, type[Any]] | None = None,
 ) -> Any:
     """Deserialize an object."""
+    try:
+        obj = loads(data)
+    except JSONDecodeError:
+        raise _DeserializeInvalidJSONError(data=data) from None
     return _object_hook(
-        loads(data),
+        obj,
         data=data,
         dataclass_hook=dataclass_hook,
         objects=objects,
@@ -380,6 +385,11 @@ def deserialize(
     )
 
 
+@dataclass(kw_only=True, slots=True)
+class DeerializeError(Exception):
+    obj: Any
+
+
 (
     _DATE_PATTERN,
     _DATE_DELTA_PATTERN,
@@ -739,11 +749,19 @@ def _object_hook_get_object(
 @dataclass(kw_only=True, slots=True)
 class DeserializeError(Exception):
     data: bytes
-    qualname: str
+
+
+@dataclass(kw_only=True, slots=True)
+class _DeserializeInvalidJSONError(DeserializeError):
+    @override
+    def __str__(self) -> str:
+        return f"Invalid JSON: {self.data!r}"
 
 
 @dataclass(kw_only=True, slots=True)
 class _DeserializeNoObjectsError(DeserializeError):
+    qualname: str
+
     @override
     def __str__(self) -> str:
         return f"Objects required to deserialize {self.qualname!r} from {self.data!r}"
@@ -751,6 +769,8 @@ class _DeserializeNoObjectsError(DeserializeError):
 
 @dataclass(kw_only=True, slots=True)
 class _DeserializeObjectNotFoundError(DeserializeError):
+    qualname: str
+
     @override
     def __str__(self) -> str:
         return (

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/src/utilities/testbook.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Any
 from testbook import testbook
 
 from utilities.pytest import throttle
+from utilities.text import pascal_case
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -15,16 +16,19 @@ if TYPE_CHECKING:
 
 def build_notebook_tester(
     path: PathLike, /, *, throttle: Delta | None = None, on_try: bool = False
-) -> object:
-    """Build the notebook test class."""
-    name = f"Test{Path(path).stem}"
+) -> type[Any]:
+    """Build the notebook tester class."""
+    path = Path(path)
+    name = f"Test{pascal_case(path.stem)}"
     notebooks = [
         path_i
-        for path_i in Path(path).rglob("**/*.ipynb")
+        for path_i in path.rglob("**/*.ipynb")
         if all(p != ".ipynb_checkpoints" for p in path_i.parts)
     ]
     namespace = {
-        f"test_{p.stem}": _build_test_method(p, delta=throttle, on_try=on_try)
+        f"test_{p.stem.replace('-', '_')}": _build_test_method(
+            p, delta=throttle, on_try=on_try
+        )
         for p in notebooks
     }
     return type(name, (), namespace)
@@ -33,14 +37,14 @@ def build_notebook_tester(
 def _build_test_method(
     path: Path, /, *, delta: Delta | None = None, on_try: bool = False
 ) -> Callable[..., Any]:
+    @testbook(path, execute=True)
     def method(self: Any, tb: Any) -> None:
         _ = (self, tb)  # pragma: no cover
 
     if delta is not None:
         method = throttle(delta=delta, on_try=on_try)(method)
 
-    tbook = testbook(path, execute=True)
-    return tbook(method)
+    return method
 
 
 __all__ = ["build_notebook_tester"]

{dycw_utilities-0.162.5 → dycw_utilities-0.162.7}/src/utilities/text.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from itertools import chain
 from os import getpid
-from re import IGNORECASE, Match, escape, search
+from re import IGNORECASE, VERBOSE, escape, search
 from textwrap import dedent
 from threading import get_ident
 from time import time_ns
@@ -77,6 +77,21 @@ class ParseNoneError(Exception):
 ##
 
 
+def pascal_case(text: str, /) -> str:
+    """Convert text to pascal case."""
+    parts = _SPLIT_TEXT.findall(text)
+    parts = [p for p in parts if len(p) >= 1]
+    parts = list(map(_pascal_case_one, parts))
+    return "".join(parts)
+
+
+def _pascal_case_one(text: str, /) -> str:
+    return text if text.isupper() else text.title()
+
+
+##
+
+
 def repr_encode(obj: Any, /) -> bytes:
     """Return the representation of the object encoded as bytes."""
     return repr(obj).encode()
@@ -85,25 +100,24 @@ def repr_encode(obj: Any, /) -> bytes:
 ##
 
 
-_ACRONYM_PATTERN = re.compile(r"([A-Z\d]+)(?=[A-Z\d]|$)")
-_SPACES_PATTERN = re.compile(r"\s+")
-_SPLIT_PATTERN = re.compile(r"([\-_]*[A-Z][^A-Z]*[\-_]*)")
-
-
 def snake_case(text: str, /) -> str:
     """Convert text into snake case."""
-    text = _SPACES_PATTERN.sub("", text)
-    if not text.isupper():
-        text = _ACRONYM_PATTERN.sub(_snake_case_title, text)
-        text = "_".join(s for s in _SPLIT_PATTERN.split(text) if s)
-    while search("__", text):
-        text = text.replace("__", "_")
-    return text.lower()
-
-
-def _snake_case_title(match: Match[str], /) -> str:
-    return match.group(0).title()
-
+    leading = bool(search(r"^_", text))
+    trailing = bool(search(r"_$", text))
+    parts = _SPLIT_TEXT.findall(text)
+    parts = (p for p in parts if len(p) >= 1)
+    parts = chain([""] if leading else [], parts, [""] if trailing else [])
+    return "_".join(parts).lower()
+
+
+_SPLIT_TEXT = re.compile(
+    r"""
+    [A-Z]+(?=[A-Z][a-z0-9]) | # all caps followed by Upper+lower or digit (API in APIResponse2)
+    [A-Z]?[a-z]+[0-9]*      | # normal words with optional trailing digits (Text123)
+    [A-Z]+[0-9]*            | # consecutive caps with optional trailing digits (ID2)
+    """,
+    flags=VERBOSE,
+)
 
 ##
 
@@ -503,6 +517,7 @@ __all__ = [
     "join_strs",
     "parse_bool",
     "parse_none",
+    "pascal_case",
     "repr_encode",
     "secret_str",
     "snake_case",

dycw_utilities-0.162.5/src/tests/test_testbook.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-from json import dumps
-from typing import TYPE_CHECKING
-
-from pytest import mark, param
-
-from utilities.testbook import build_notebook_tester
-from utilities.whenever import HOUR
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-    from utilities.types import Delta
-
-
-class TestBuildNotebookTester:
-    @mark.parametrize("throttle", [param(HOUR), param(None)])
-    def test_main(self, *, tmp_path: Path, throttle: Delta | None) -> None:
-        data = {"cells": []}
-        _ = tmp_path.joinpath("notebook.ipynb").write_text(dumps(data))
-        _ = build_notebook_tester(tmp_path, throttle=throttle)