dycw-utilities 0.166.34__tar.gz → 0.166.36__tar.gz

{dycw_utilities-0.166.34 → dycw_utilities-0.166.36}/PKG-INFO

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

{dycw_utilities-0.166.34 → dycw_utilities-0.166.36}/pyproject.toml

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

dycw_utilities-0.166.36/src/tests/test_jinja2.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from jinja2 import DictLoader
+
+from utilities.jinja2 import EnhancedEnvironment, TemplateJob
+from utilities.text import strip_and_dedent
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class TestEnhancedTemplate:
+    def test_main(self) -> None:
+        env = EnhancedEnvironment(
+            loader=DictLoader({
+                "test.j2": strip_and_dedent("""
+                    text   = '{{ text }}'
+                    kebab  = '{{ text | kebab }}'
+                    pascal = '{{ text | pascal }}'
+                    snake  = '{{ text | snake }}'
+                """)
+            })
+        )
+        result = env.get_template("test.j2").render(text="multi-word string")
+        expected = strip_and_dedent("""
+            text   = 'multi-word string'
+            kebab  = 'multi-word-string'
+            pascal = 'MultiWordString'
+            snake  = 'multi_word_string'
+        """)
+        assert result == expected
+
+
+class TestTemplateJob:
+    def test_main(self, *, tmp_path: Path) -> None:
+        path_template = tmp_path.joinpath("template.j2")
+        _ = path_template.write_text(
+            strip_and_dedent("""
+                text = '{{ text }}'
+            """)
+        )
+        path_target = tmp_path.joinpath("target.txt")
+        job = TemplateJob(
+            template=path_template, kwargs={"text": "example text"}, target=path_target
+        )
+        expected = strip_and_dedent("""
+            text = 'example text'
+        """)
+        assert job.rendered == expected
+        assert not path_target.exists()
+        job.run()
+        assert path_target.exists()
+        assert path_target.read_text() == expected
+
+    def test_append(self, *, tmp_path: Path) -> None:
+        path_template = tmp_path.joinpath("template.j2")
+        _ = path_template.write_text(
+            strip_and_dedent(
+                """
+                new = '{{ text }}'
+                """,
+                trailing=True,
+            )
+        )
+        path_target = tmp_path.joinpath("target.txt")
+        _ = path_target.write_text(
+            strip_and_dedent(
+                """
+                old = 'old text'
+                """,
+                trailing=True,
+            )
+        )
+        job = TemplateJob(
+            template=path_template,
+            kwargs={"text": "new text"},
+            target=path_target,
+            mode="append",
+        )
+        job.run()
+        assert path_target.exists()
+        assert path_target.read_text() == strip_and_dedent("""
+            old = 'old text'
+            new = 'new text'
+        """)

{dycw_utilities-0.166.34 → dycw_utilities-0.166.36}/src/tests/test_text.py

@@ -28,6 +28,7 @@ from utilities.text import (
     _SplitStrCountError,
     _SplitStrOpeningBracketUnmatchedError,
     join_strs,
+    kebab_case,
     parse_bool,
     parse_none,
     pascal_case,
@@ -111,60 +112,86 @@ class TestReprEncode:
         assert result == expected
 
 
-class TestPascalAndSnakeCase:
+class TestPascalSnakeAndKebabCase:
     @mark.parametrize(
-        ("text", "exp_pascal", "exp_snake"),
+        ("text", "exp_pascal", "exp_snake", "exp_kebab"),
         [
-            param("API", "API", "api"),
-            param("APIResponse", "APIResponse", "api_response"),
+            param("API", "API", "api", "api"),
+            param("APIResponse", "APIResponse", "api_response", "api-response"),
             param(
                 "ApplicationController",
                 "ApplicationController",
                 "application_controller",
+                "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"),
+            param(
+                "Area51Controller",
+                "Area51Controller",
+                "area51_controller",
+                "area51-controller",
+            ),
+            param("FreeBSD", "FreeBSD", "free_bsd", "free-bsd"),
+            param("HTML", "HTML", "html", "html"),
+            param("HTMLTidy", "HTMLTidy", "html_tidy", "html-tidy"),
+            param(
+                "HTMLTidyGenerator",
+                "HTMLTidyGenerator",
+                "html_tidy_generator",
+                "html-tidy-generator",
+            ),
+            param("HTMLVersion", "HTMLVersion", "html_version", "html-version"),
+            param("NoHTML", "NoHTML", "no_html", "no-html"),
+            param("One   Two", "OneTwo", "one_two", "one-two"),
+            param("One  Two", "OneTwo", "one_two", "one-two"),
+            param("One Two", "OneTwo", "one_two", "one-two"),
+            param("OneTwo", "OneTwo", "one_two", "one-two"),
+            param("One_Two", "OneTwo", "one_two", "one-two"),
+            param("One__Two", "OneTwo", "one_two", "one-two"),
+            param("One___Two", "OneTwo", "one_two", "one-two"),
+            param("Product", "Product", "product", "product"),
+            param("SpecialGuest", "SpecialGuest", "special_guest", "special-guest"),
+            param("Text", "Text", "text", "text"),
+            param("Text123", "Text123", "text123", "text123"),
+            param(
+                "Text123Text456", "Text123Text456", "text123_text456", "text123-text456"
+            ),
+            param("_APIResponse_", "APIResponse", "_api_response_", "-api-response-"),
+            param("_API_", "API", "_api_", "-api-"),
+            param("__APIResponse__", "APIResponse", "_api_response_", "-api-response-"),
+            param("__API__", "API", "_api_", "-api-"),
+            param(
+                "__impliedVolatility_",
+                "ImpliedVolatility",
+                "_implied_volatility_",
+                "-implied-volatility-",
+            ),
+            param("_itemID", "ItemID", "_item_id", "-item-id"),
+            param("_lastPrice__", "LastPrice", "_last_price_", "-last-price-"),
+            param("_symbol", "Symbol", "_symbol", "-symbol"),
+            param("aB", "AB", "a_b", "a-b"),
+            param("changePct", "ChangePct", "change_pct", "change-pct"),
+            param("changePct_", "ChangePct", "change_pct_", "change-pct-"),
+            param(
+                "impliedVolatility",
+                "ImpliedVolatility",
+                "implied_volatility",
+                "implied-volatility",
+            ),
+            param("lastPrice", "LastPrice", "last_price", "last-price"),
+            param("memMB", "MemMB", "mem_mb", "mem-mb"),
+            param("sizeX", "SizeX", "size_x", "size-x"),
+            param("symbol", "Symbol", "symbol", "symbol"),
+            param("testNTest", "TestNTest", "test_n_test", "test-n-test"),
+            param("text", "Text", "text", "text"),
+            param("text123", "Text123", "text123", "text123"),
         ],
     )
-    def test_main(self, *, text: str, exp_pascal: str, exp_snake: str) -> None:
+    def test_main(
+        self, *, text: str, exp_pascal: str, exp_snake: str, exp_kebab: str
+    ) -> None:
         assert pascal_case(text) == exp_pascal
         assert snake_case(text) == exp_snake
+        assert kebab_case(text) == exp_kebab
 
 
 class TestPromptBool:

{dycw_utilities-0.166.34 → dycw_utilities-0.166.36}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.166.34"
+__version__ = "0.166.36"

{dycw_utilities-0.166.34 → dycw_utilities-0.166.36}/src/utilities/jinja2.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, override
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal, assert_never, override
 
-from jinja2 import BaseLoader, BytecodeCache, Environment, Undefined
+from jinja2 import BaseLoader, BytecodeCache, Environment, FileSystemLoader, Undefined
 from jinja2.defaults import (
     BLOCK_END_STRING,
     BLOCK_START_STRING,
@@ -18,13 +19,17 @@ from jinja2.defaults import (
     VARIABLE_START_STRING,
 )
 
-from utilities.text import pascal_case, snake_case
+from utilities.atomicwrites import writer
+from utilities.text import kebab_case, pascal_case, snake_case
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
+    from pathlib import Path
 
     from jinja2.ext import Extension
 
+    from utilities.types import StrMapping
+
 
 class EnhancedEnvironment(Environment):
     """Environment with enhanced features."""
@@ -79,8 +84,37 @@ class EnhancedEnvironment(Environment):
             bytecode_cache,
             enable_async,
         )
-        self.filters["snake"] = snake_case
+        self.filters["kebab"] = kebab_case
         self.filters["pascal"] = pascal_case
+        self.filters["snake"] = snake_case
+
+
+@dataclass(order=True, unsafe_hash=True, kw_only=True, slots=True)
+class TemplateJob:
+    """A template with an associated rendering job."""
+
+    template: Path
+    kwargs: StrMapping
+    target: Path
+    mode: Literal["write", "append"] = "write"
+
+    def run(self) -> None:
+        """Run the job."""
+        match self.mode:
+            case "write":
+                with writer(self.target, overwrite=True) as temp:
+                    _ = temp.write_text(self.rendered)
+            case "append":
+                with self.target.open(mode="a") as fh:
+                    _ = fh.write(self.rendered)
+            case never:
+                assert_never(never)
+
+    @property
+    def rendered(self) -> str:
+        """The template, rendered."""
+        env = EnhancedEnvironment(loader=FileSystemLoader(self.template.parent))
+        return env.get_template(self.template.name).render(self.kwargs)
 
 
-__all__ = ["EnhancedEnvironment"]
+__all__ = ["EnhancedEnvironment", "TemplateJob"]

{dycw_utilities-0.166.34 → dycw_utilities-0.166.36}/src/utilities/text.py

@@ -31,7 +31,15 @@ if TYPE_CHECKING:
     from utilities.types import MaybeCallableBoolLike, MaybeCallableStr, StrStrMapping
 
 
-DEFAULT_SEPARATOR = ","
+_DEFAULT_SEPARATOR = ","
+
+
+##
+
+
+def kebab_case(text: str, /) -> str:
+    """Convert text into kebab case."""
+    return _kebab_snake_case(text, "-")
 
 
 ##
@@ -110,27 +118,13 @@ def repr_encode(obj: Any, /) -> bytes:
 
 def snake_case(text: str, /) -> str:
     """Convert text into snake case."""
-    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()
+    return _kebab_snake_case(text, "_")
 
 
-_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,
-)
-
 ##
 
 
-LIST_SEPARATOR = DEFAULT_SEPARATOR
+LIST_SEPARATOR = _DEFAULT_SEPARATOR
 PAIR_SEPARATOR = "="
 BRACKETS = [("(", ")"), ("[", "]"), ("{", "}")]
 
@@ -140,7 +134,7 @@ def split_key_value_pairs(
     text: str,
     /,
     *,
-    list_separator: str = DEFAULT_SEPARATOR,
+    list_separator: str = _DEFAULT_SEPARATOR,
     pair_separator: str = PAIR_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = BRACKETS,
     mapping: Literal[True],
@@ -150,7 +144,7 @@ def split_key_value_pairs(
     text: str,
     /,
     *,
-    list_separator: str = DEFAULT_SEPARATOR,
+    list_separator: str = _DEFAULT_SEPARATOR,
     pair_separator: str = PAIR_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = BRACKETS,
     mapping: Literal[False] = False,
@@ -160,7 +154,7 @@ def split_key_value_pairs(
     text: str,
     /,
     *,
-    list_separator: str = DEFAULT_SEPARATOR,
+    list_separator: str = _DEFAULT_SEPARATOR,
     pair_separator: str = PAIR_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = BRACKETS,
     mapping: bool = False,
@@ -169,7 +163,7 @@ def split_key_value_pairs(
     text: str,
     /,
     *,
-    list_separator: str = DEFAULT_SEPARATOR,
+    list_separator: str = _DEFAULT_SEPARATOR,
     pair_separator: str = PAIR_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = BRACKETS,
     mapping: bool = False,
@@ -228,7 +222,7 @@ def split_str(
     text: str,
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = None,
     n: Literal[1],
 ) -> tuple[str]: ...
@@ -237,7 +231,7 @@ def split_str(
     text: str,
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = None,
     n: Literal[2],
 ) -> tuple[str, str]: ...
@@ -246,7 +240,7 @@ def split_str(
     text: str,
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = None,
     n: Literal[3],
 ) -> tuple[str, str, str]: ...
@@ -255,7 +249,7 @@ def split_str(
     text: str,
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = None,
     n: Literal[4],
 ) -> tuple[str, str, str, str]: ...
@@ -264,7 +258,7 @@ def split_str(
     text: str,
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = None,
     n: Literal[5],
 ) -> tuple[str, str, str, str, str]: ...
@@ -273,7 +267,7 @@ def split_str(
     text: str,
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = None,
     n: int | None = None,
 ) -> tuple[str, ...]: ...
@@ -281,7 +275,7 @@ def split_str(
     text: str,
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
     brackets: Iterable[tuple[str, str]] | None = None,
     n: int | None = None,
 ) -> tuple[str, ...]:
@@ -306,7 +300,7 @@ def _split_str_brackets(
     brackets: Iterable[tuple[str, str]],
     /,
     *,
-    separator: str = DEFAULT_SEPARATOR,
+    separator: str = _DEFAULT_SEPARATOR,
 ) -> list[str]:
     brackets = list(brackets)
     opens, closes = transpose(brackets)
@@ -397,7 +391,7 @@ class _SplitStrOpeningBracketUnmatchedError(SplitStrError):
 
 
 def join_strs(
-    texts: Iterable[str], /, *, sort: bool = False, separator: str = DEFAULT_SEPARATOR
+    texts: Iterable[str], /, *, sort: bool = False, separator: str = _DEFAULT_SEPARATOR
 ) -> str:
     """Join a collection of strings, with a special provision for the empty list."""
     texts = list(texts)
@@ -410,7 +404,7 @@ def join_strs(
     return separator.join(texts)
 
 
-def _escape_separator(*, separator: str = DEFAULT_SEPARATOR) -> str:
+def _escape_separator(*, separator: str = _DEFAULT_SEPARATOR) -> str:
     return f"\\{separator}"
 
 
@@ -513,9 +507,30 @@ def unique_str() -> str:
     return f"{now}_{pid}_{ident}_{key}"
 
 
+##
+
+
+def _kebab_snake_case(text: str, separator: str, /) -> str:
+    """Convert text into kebab/snake case."""
+    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 separator.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,
+)
+
 __all__ = [
     "BRACKETS",
-    "DEFAULT_SEPARATOR",
     "LIST_SEPARATOR",
     "PAIR_SEPARATOR",
     "ParseBoolError",
@@ -523,6 +538,7 @@ __all__ = [
     "SplitKeyValuePairsError",
     "SplitStrError",
     "join_strs",
+    "kebab_case",
     "parse_bool",
     "parse_none",
     "pascal_case",

dycw_utilities-0.166.34/src/tests/test_jinja2.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from jinja2 import DictLoader
-
-from utilities.jinja2 import EnhancedEnvironment
-from utilities.text import strip_and_dedent
-
-
-class TestEnhancedTemplate:
-    def test_main(self) -> None:
-        env = EnhancedEnvironment(
-            loader=DictLoader({
-                "test.j2": strip_and_dedent("""
-                    text   = '{{ text }}'
-                    pascal = '{{ text | pascal }}'
-                    snake  = '{{ text | snake }}'
-                """)
-            })
-        )
-        result = env.get_template("test.j2").render(text="multi-word string")
-        expected = strip_and_dedent("""
-            text   = 'multi-word string'
-            pascal = 'MultiWordString'
-            snake  = 'multi_word_string'
-        """)
-        assert result == expected