Start to clean up

Author: davepeck

README.md

@@ -599,15 +599,12 @@ used internally by the `html()` function but can also be used independently:
 
 ```python
 from string.templatelib import Interpolation
-from tdom.utils import format_interpolation, convert
+from tdom.utils import convert
 
 # Test convert function
 assert convert("hello", "s") == "hello"
 assert convert("hello", "r") == "'hello'"
 assert convert(42, None) == 42
-
-# format_interpolation is used internally for custom format specifiers
-# The html() function uses this to implement :safe and :unsafe specifiers
 ```
 
 **`convert()`**: Applies conversion specifiers (`!a`, `!r`, `!s`) to values

tdom/processor.py

@@ -27,8 +27,8 @@
     TText,
 )
 from .placeholders import TemplateRef
-from .templating import format_interpolation, render_template_as_f
-from .utils import CachableTemplate, LastUpdatedOrderedDict, template_from_parts
+from .templating import format_interpolation, render_template_as_f, template_from_parts
+from .utils import CachableTemplate, LastUpdatedOrderedDict
 
 
 @t.runtime_checkable

tdom/templating.py

@@ -4,7 +4,7 @@
 
 from markupsafe import Markup
 
-from .utils import format_interpolation as base_format_interpolation
+from .utils import base_format_interpolation
 
 
 def _format_safe(value: object, format_spec: str) -> str:
@@ -29,6 +29,17 @@ def format_interpolation(interpolation: Interpolation) -> object:
     )
 
 
+def template_from_parts(
+    strings: t.Sequence[str], interpolations: t.Sequence[Interpolation]
+) -> Template:
+    """Construct a template string from the given strings and parts."""
+    assert len(strings) == len(interpolations) + 1, (
+        "TemplateRef must have one more string than interpolation references."
+    )
+    flat = [x for pair in zip(strings, interpolations) for x in pair] + [strings[-1]]
+    return Template(*flat)
+
+
 def render_template_as_f(template: Template) -> str:
     """Fully render a template by formatting its interpolations."""
     parts: list[str] = []

tdom/utils.py

@@ -65,7 +65,7 @@ def _format_interpolation(
     return converted
 
 
-def format_interpolation(
+def base_format_interpolation(
     interpolation: Interpolation,
     *,
     formatters: t.Sequence[MatcherAndFormatter] = tuple(),
@@ -89,15 +89,12 @@ def format_interpolation(
     )
 
 
-def template_from_parts(
-    strings: t.Sequence[str], interpolations: t.Sequence[Interpolation]
-) -> Template:
-    """Construct a template string from the given strings and parts."""
-    assert len(strings) == len(interpolations) + 1, (
-        "TemplateRef must have one more string than interpolation references."
-    )
-    flat = [x for pair in zip(strings, interpolations) for x in pair] + [strings[-1]]
-    return Template(*flat)
+class LastUpdatedOrderedDict(OrderedDict):
+    "Store items in the order the keys were last updated."
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        self.move_to_end(key)
 
 
 class CachableTemplate:
@@ -115,11 +112,3 @@ def __eq__(self, other: object) -> bool:
 
     def __hash__(self) -> int:
         return hash(self.template.strings)
-
-
-class LastUpdatedOrderedDict(OrderedDict):
-    "Store items in the order the keys were last updated."
-
-    def __setitem__(self, key, value):
-        super().__setitem__(key, value)
-        self.move_to_end(key)

tdom/utils_test.py

@@ -1,6 +1,6 @@
 from string.templatelib import Interpolation
 
-from .utils import convert, format_interpolation
+from .utils import base_format_interpolation, convert
 
 
 class Convertible:
@@ -32,50 +32,50 @@ def test_convert_s():
     assert convert(value, "s") == "Convertible str"
 
 
-def test_format_interpolation_no_formatting():
+def test_base_format_interpolation_no_formatting():
     value = Convertible()
     interp = Interpolation(value, expression="", conversion=None, format_spec="")
-    assert format_interpolation(interp) is value
+    assert base_format_interpolation(interp) is value
 
 
-def test_format_interpolation_a():
+def test_base_format_interpolation_a():
     value = Convertible()
     interp = Interpolation(value, expression="", conversion="a", format_spec="")
-    assert format_interpolation(interp) == "Convertible repr"
+    assert base_format_interpolation(interp) == "Convertible repr"
 
 
-def test_format_interpolation_r():
+def test_base_format_interpolation_r():
     value = Convertible()
     interp = Interpolation(value, expression="", conversion="r", format_spec="")
-    assert format_interpolation(interp) == "Convertible repr"
+    assert base_format_interpolation(interp) == "Convertible repr"
 
 
-def test_format_interpolation_s():
+def test_base_format_interpolation_s():
     value = Convertible()
     interp = Interpolation(value, expression="", conversion="s", format_spec="")
-    assert format_interpolation(interp) == "Convertible str"
+    assert base_format_interpolation(interp) == "Convertible str"
 
 
-def test_format_interpolation_default_formatting():
+def test_base_format_interpolation_default_formatting():
     value = 42
     interp = Interpolation(value, expression="", conversion=None, format_spec="5d")
-    assert format_interpolation(interp) == "   42"
+    assert base_format_interpolation(interp) == "   42"
 
 
-def test_format_interpolation_custom_formatter_match_exact():
+def test_base_format_interpolation_custom_formatter_match_exact():
     value = 42
     interp = Interpolation(value, expression="", conversion=None, format_spec="custom")
 
     def formatter(val: object, spec: str) -> str:
         return f"formatted-{val}-{spec}"
 
     assert (
-        format_interpolation(interp, formatters=[("custom", formatter)])
+        base_format_interpolation(interp, formatters=[("custom", formatter)])
         == "formatted-42-custom"
     )
 
 
-def test_format_interpolation_custom_formatter_match_predicate():
+def test_base_format_interpolation_custom_formatter_match_predicate():
     value = 42
     interp = Interpolation(
         value, expression="", conversion=None, format_spec="custom123"
@@ -88,6 +88,6 @@ def formatter(val: object, spec: str) -> str:
         return f"formatted-{val}-{spec}"
 
     assert (
-        format_interpolation(interp, formatters=[(matcher, formatter)])
+        base_format_interpolation(interp, formatters=[(matcher, formatter)])
         == "formatted-42-custom123"
     )