Some perf improvements

Author: eliotwrobson

.vscode/settings.json

@@ -23,7 +23,7 @@
   "cSpell.words": [
     "datadir"
   ],
-  "python-envs.defaultEnvManager": "ms-python.python:conda",
-  "python-envs.defaultPackageManager": "ms-python.python:conda",
+  "python-envs.defaultEnvManager": "ms-python.python:venv",
+  "python-envs.defaultPackageManager": "ms-python.python:pip",
   "python-envs.pythonProjects": []
 }

pyproject.toml

@@ -47,7 +47,7 @@ dev = [
   "pytest-datadir>=1.8.0",
   "ruff>=0.14.9",
   "types-chevron>=0.14.2.20250103",
-  "ustache>=0.1.6",
+  "mstache>=0.3.0",
 ]
 
 [tool.pytest.ini_options]
@@ -70,5 +70,5 @@ precision = 2
 python_version = "3.10"
 
 [[tool.mypy.overrides]]
-module = ["yaml", "combustache.*", "pystache.*", "ustache.*"]
+module = ["yaml", "combustache.*", "pystache.*", "mstache.*"]
 ignore_missing_imports = true

src/mystace/mustache_tree.py

@@ -28,6 +28,16 @@
     TokenType.DELIMITER,
 )
 
+# Pre-compute common space strings for indentation (avoids repeated multiplication)
+_SPACE_CACHE = [""] + [" " * i for i in range(1, 33)]  # Cache up to 32 spaces
+
+
+def _get_spaces(n: int) -> str:
+    """Get n spaces, using cache when possible."""
+    if n < len(_SPACE_CACHE):
+        return _SPACE_CACHE[n]
+    return " " * n
+
 
 class ContextNode:
     __slots__ = ("context", "parent_context_node")
@@ -47,11 +57,12 @@ def get(self, key: str) -> t.Any:
         if key == ".":
             return self.context
 
-        chain_iter = iter(key.split("."))
+        # Split only once and cache
+        keys = key.split(".")
         curr_ctx = self.context
         parent_node = self.parent_context_node
 
-        first_key = next(chain_iter)
+        first_key = keys[0]
 
         # TODO I think this is where changes need to be made if we want to
         # support indexing and lambdas.
@@ -72,7 +83,7 @@ def get(self, key: str) -> t.Any:
             return None
 
         # Loop through the rest
-        for key in chain_iter:
+        for key in keys[1:]:
             if isinstance(outer_context, list):
                 try:
                     int_key = int(key)
@@ -97,17 +108,11 @@ def open_section(self, key: str) -> t.List[ContextNode]:
 
         # In the case of the list, need a new context for each item
         if isinstance(new_context, list):
-            res_list = []
-
-            for item in new_context:
-                new_stack = ContextNode(item, self)
-                # new_stack.parent_context_node = self
-                res_list.append(new_stack)
-
+            # Pre-allocate list for better performance
+            res_list = [ContextNode(item, self) for item in new_context]
             return res_list
 
-        new_stack = ContextNode(new_context, self)
-        return [new_stack]
+        return [ContextNode(new_context, self)]
 
 
 class TagType(enum.Enum):
@@ -186,6 +191,7 @@ def __repr__(self) -> str:
 class MustacheRenderer:
     mustache_tree: MustacheTreeNode
     partials_dict: t.Dict[str, MustacheTreeNode]
+    __slots__ = ("mustache_tree", "partials_dict")
 
     def __init__(
         self,
@@ -210,6 +216,7 @@ def render(
         html_escape_fn: t.Callable[[str], str] = html_escape,
     ) -> str:
         res_list = []
+        res_list_append = res_list.append  # Cache method lookup
         starting_context = ContextNode(data)
         last_was_newline = True  # Track if we're at the start of a line
 
@@ -220,18 +227,20 @@ def render(
             (node, starting_context, self.mustache_tree.offset)
             for node in self.mustache_tree.children
         )
+        work_deque_popleft = work_deque.popleft  # Cache method lookup
+        work_deque_appendleft = work_deque.appendleft  # Cache method lookup
         while work_deque:
-            curr_node, curr_context, curr_offset = work_deque.popleft()
+            curr_node, curr_context, curr_offset = work_deque_popleft()
             if curr_node.tag_type is TagType.LITERAL:
-                res_list.append(curr_node.data)
+                res_list_append(curr_node.data)
                 last_was_newline = curr_node.data.endswith("\n")
 
                 # Add offset for partials after newline, but only if there's
                 # more content coming at the same offset level
                 if last_was_newline and curr_offset > 0:
                     # Check if the next node also has the same offset
                     if work_deque and work_deque[0][2] == curr_offset:
-                        res_list.append(curr_offset * " ")
+                        res_list_append(_get_spaces(curr_offset))
 
             elif (
                 curr_node.tag_type is TagType.VARIABLE
@@ -246,7 +255,7 @@ def render(
                     if curr_node.tag_type is TagType.VARIABLE:
                         str_content = html_escape_fn(str_content)
 
-                    res_list.append(str_content)
+                    res_list_append(str_content)
             elif curr_node.tag_type is TagType.SECTION:
                 new_context_stacks = curr_context.open_section(curr_node.data)
 
@@ -255,7 +264,7 @@ def render(
                 for new_context_stack in reversed(new_context_stacks):
                     for child_node in reversed(curr_node.children):
                         # No need to make a copy of the context per-child, it's immutable
-                        work_deque.appendleft((child_node, new_context_stack, 0))
+                        work_deque_appendleft((child_node, new_context_stack, 0))
 
             elif curr_node.tag_type is TagType.INVERTED_SECTION:
                 # No need to add to the context stack, inverted sections
@@ -266,7 +275,7 @@ def render(
 
                 if not bool(lookup_data):
                     for child_node in reversed(curr_node.children):
-                        work_deque.appendleft((child_node, curr_context, 0))
+                        work_deque_appendleft((child_node, curr_context, 0))
 
             elif curr_node.tag_type is TagType.PARTIAL:
                 partial_tree = self.partials_dict.get(curr_node.data)
@@ -279,12 +288,12 @@ def render(
                 # For standalone partials, add indentation at the beginning
                 # Only add if we're at the start of a line (last output was newline)
                 if curr_node.offset > 0 and last_was_newline:
-                    res_list.append(curr_node.offset * " ")
+                    res_list_append(_get_spaces(curr_node.offset))
                     last_was_newline = False
 
                 # Propagate the combined offset through the partial content
                 for child_node in reversed(partial_tree.children):
-                    work_deque.appendleft(
+                    work_deque_appendleft(
                         (child_node, curr_context, curr_offset + curr_node.offset)
                     )
 

src/mystace/util.py

@@ -2,13 +2,19 @@
 
 LAMBDA = "<lambda>"
 
+# Pre-build translation table for HTML escaping (much faster than multiple replace calls)
+_HTML_ESCAPE_TABLE = str.maketrans(
+    {
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+    }
+)
+
 
 def html_escape(s: str) -> str:
-    s = s.replace("&", "&amp;")  # Must be done first!
-    s = s.replace("<", "&lt;")
-    s = s.replace(">", "&gt;")
-    s = s.replace('"', "&quot;")
-    return s
+    return s.translate(_HTML_ESCAPE_TABLE)
 
 
 def is_whitespace(string: str) -> bool:

tests/test_speed.py

@@ -24,8 +24,7 @@
     "combustache",
     "moosetash",
     "pystache",
-    "ustache",
-    "ustache-full",
+    "mstache",
     "mystace-full",
 ]
 TestCaseT = t.Tuple[str, t.Dict[str, int]]
@@ -331,15 +330,10 @@ def render_function(_, obj):
         import pystache
 
         render_function = pystache.render
-    elif render_function_name == "ustache-full":
-        import ustache
+    elif render_function_name == "mstache":
+        import mstache
 
-        def render_function(x, y):
-            return ustache.render(x, y, cache={})
-    elif render_function_name == "ustache":
-        import ustache
-
-        render_function = ustache.render
+        render_function = mstache.render
     else:
         assert_never(render_function_name)