ya-tagscript 1.6.2__tar.gz → 1.6.4__tar.gz

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/.github/workflows/black.yml

@@ -15,7 +15,7 @@ jobs:
           python-version-file: ".python-version"
 
       - name: Lint with black
-        uses: psf/black@c6755bb741b6481d6b3d3bb563c83fa060db96c9  # 26.3.1
+        uses: psf/black@87928e6d6761a4a6d22250e1fee5601b3998086e  # 26.5.1
         with:
           options: '--check --diff --verbose'
           src: '.'

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/.pre-commit-config.yaml

@@ -25,7 +25,7 @@ repos:
       - id: add-trailing-comma
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 26.3.1
+    rev: 26.5.0
     hooks:
       - id: black
 

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 *Currently none*
 
+# v1.6.4
+
+- Parser state optimizations
+- Parsing and interpretation performance improvements
+
+# v1.6.3
+
+- Performance improvements in the parser
+- Performance improvements in the interpreter
+
 # v1.6.2
 
 - Fix import structure

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ya_tagscript
-Version: 1.6.2
+Version: 1.6.4
 Summary: Yet Another TagScript fork. An easy drop in user-provided Templating system.
 Project-URL: Changelog, https://ya-tagscript.readthedocs.io/en/latest/changelog.html
 Project-URL: Documentation, https://ya-tagscript.readthedocs.io
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 
 # ya_tagscript - Yet Another TagScript fork
 
-Current stable version: v1.6.2
+Current stable version: v1.6.4
 
 ## Information
 
@@ -87,7 +87,7 @@ or
 <!--VERSIONED TAG SECTION START-->
 
 ```
-pip install git+https://github.com/MajorTanya/ya_tagscript.git@v1.6.2
+pip install git+https://github.com/MajorTanya/ya_tagscript.git@v1.6.4
 ```
 
 <!--VERSIONED TAG SECTION END-->

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/README.md

@@ -1,6 +1,6 @@
 # ya_tagscript - Yet Another TagScript fork
 
-Current stable version: v1.6.2
+Current stable version: v1.6.4
 
 ## Information
 
@@ -62,7 +62,7 @@ or
 <!--VERSIONED TAG SECTION START-->
 
 ```
-pip install git+https://github.com/MajorTanya/ya_tagscript.git@v1.6.2
+pip install git+https://github.com/MajorTanya/ya_tagscript.git@v1.6.4
 ```
 
 <!--VERSIONED TAG SECTION END-->

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/docs/conf.py

@@ -17,7 +17,7 @@ project_copyright = "2025, MajorTanya"
 author = "MajorTanya"
 
 ### VERSION SECTION START
-version = "1.6.2"
+version = "1.6.4"
 ### VERSION SECTION END
 release = version
 

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ya_tagscript"
-version = "1.6.2"
+version = "1.6.4"
 description = "Yet Another TagScript fork. An easy drop in user-provided Templating system."
 readme = "README.md"
 license = "CC-BY-4.0"

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/src/ya_tagscript/interpreter/interpreter.py

@@ -26,7 +26,14 @@ _logger = logging.getLogger(__name__)
 
 class TagScriptInterpreter(InterpreterABC):
 
-    __slots__ = ("blocks", "_parser", "work_limit", "total_work")
+    __slots__ = (
+        "blocks",
+        "_parser",
+        "work_limit",
+        "total_work",
+        "_named_blocks",
+        "_unnamed_blocks",
+    )
 
     def __init__(
         self,
@@ -36,6 +43,20 @@ class TagScriptInterpreter(InterpreterABC):
         self.blocks: Sequence[BlockABC] = blocks
         self.work_limit: int | None = None
         self.total_work: int = 0
+        # fast lookup dict for blocks with non-None _accepted_names
+        self._named_blocks: dict[str, BlockABC] = {}
+        # fallback list for blocks where _accepted_names is None
+        self._unnamed_blocks: list[BlockABC] = []
+
+        # register blocks in the appropriate group
+        for block in blocks:
+            # noinspection PyProtectedMember
+            names = block._accepted_names  # pyright: ignore [reportPrivateUsage]
+            if names is not None:
+                for name in names:
+                    self._named_blocks[name.lower()] = block
+            else:
+                self._unnamed_blocks.append(block)
 
     def process(
         self,
@@ -84,15 +105,15 @@ class TagScriptInterpreter(InterpreterABC):
             # in other words, this is plaintext to us
             return subject
         ast = self._parser.parse(subject)
-        output: list[str] = []
+        output: str = ""
         node_processing_fn = self._process_node
         for node in ast:
             try:
                 node_output = node_processing_fn(node, response, original)
-                output.append(node_output)
+                output += node_output
             except StopError as e:
                 _logger.debug("StopError raised on %r", node, exc_info=e)
-                output = [e.message]
+                output = e.message
                 break
 
             if node.type != NodeType.TEXT:
@@ -103,10 +124,20 @@ class TagScriptInterpreter(InterpreterABC):
                     node_output,
                 )
 
-        return "".join(output)
+        return output
 
     def _process_context(self, ctx: Context) -> str | None:
-        for b in self.blocks:
+        declaration = ctx.node.declaration
+        if declaration is not None:
+            named_block = self._named_blocks.get(declaration.lower())
+            if named_block is not None and named_block.will_accept(ctx):
+                processed = named_block.process(ctx)
+                if processed is not None:
+                    result = str(processed)
+                    ctx.node.output = result
+                    return result
+
+        for b in self._unnamed_blocks:
             if b.will_accept(ctx):
                 processed = b.process(ctx)
                 if processed is not None:

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/src/ya_tagscript/interpreter/parse_state.py

@@ -20,19 +20,6 @@ class ParseState(Enum):
     IN_PAYLOAD = auto()  # After the colon
 
 
-VALID_TRANSITIONS: dict[int, frozenset[ParseState]] = {
-    ParseState.EXPECTING_DECLARATION.value: frozenset({ParseState.IN_DECLARATION}),
-    ParseState.IN_DECLARATION.value: frozenset(
-        {ParseState.IN_PARAMETER, ParseState.IN_PAYLOAD},
-    ),
-    ParseState.IN_PARAMETER.value: frozenset({ParseState.POST_PARAMETER}),
-    ParseState.POST_PARAMETER.value: frozenset(
-        {ParseState.IN_PAYLOAD},
-    ),  # Or pop (not a state)
-    ParseState.IN_PAYLOAD.value: frozenset(),  # Only pop gets out of payload
-}
-
-
 @dataclass(slots=True)
 class BlockParseState:
     """
@@ -43,10 +30,10 @@ class BlockParseState:
     state: ParseState
     block_depth: int = 0
     paren_depth: int = 0
-    declaration: list[str] | None = None
-    parameter: list[str] | None = None
+    declaration: str | None = None
+    parameter: str | None = None
     has_parameter_section: bool = False  # True if 1-depth () exist, even if empty
-    payload: list[str] | None = None
+    payload: str | None = None
     has_payload_section: bool = False  # True if 1-depth : exists, even if empty
 
     def finalize(self) -> NodeABC:
@@ -54,16 +41,16 @@ class BlockParseState:
         if self.declaration is None:
             raise ValueError("Cannot finalize BLOCK Node without a declaration.")
 
-        parameter = "".join(self.parameter) if self.parameter is not None else None
+        parameter = self.parameter if self.parameter is not None else None
         if self.has_parameter_section and parameter is None:
             parameter = ""
 
-        payload = "".join(self.payload) if self.payload is not None else None
+        payload = self.payload if self.payload is not None else None
         if self.has_payload_section and payload is None:
             payload = ""
 
         node = Node.block(
-            declaration="".join(self.declaration),
+            declaration=self.declaration,
             parameter=parameter,
             payload=payload,
         )
@@ -92,6 +79,28 @@ class BlockParseState:
             - EXPECTING_DECLARATION can transition to the base None state if the tokens
                 are "{}"
         """
-        if not next_state in VALID_TRANSITIONS.get(self.state.value, frozenset()):
+        if (
+            self.state == ParseState.EXPECTING_DECLARATION
+            and next_state == ParseState.IN_DECLARATION
+        ):
+            self.state = next_state
+
+        elif self.state == ParseState.IN_DECLARATION and (
+            next_state == ParseState.IN_PARAMETER or next_state == ParseState.IN_PAYLOAD
+        ):
+            self.state = next_state
+
+        elif (
+            self.state == ParseState.IN_PARAMETER
+            and next_state == ParseState.POST_PARAMETER
+        ):
+            self.state = next_state
+
+        elif (
+            self.state == ParseState.POST_PARAMETER
+            and next_state == ParseState.IN_PAYLOAD
+        ):
+            self.state = next_state
+
+        else:
             raise ValueError(f"Invalid state transition: {self.state} -> {next_state}")
-        self.state = next_state

{ya_tagscript-1.6.2 → ya_tagscript-1.6.4}/src/ya_tagscript/interpreter/ts_parser.py

@@ -38,13 +38,13 @@ class TagScriptParser:
     def __init__(self) -> None:
         self._nodes: list[NodeABC] = []
         self._state: BlockParseState | None = None
-        self._text_buffer: list[str] = []
+        self._text_buffer: str = ""
 
     def parse(self, input_str: str) -> list[NodeABC]:
         """Converts a string into a list of Nodes and handling nested blocks as text"""
         self._nodes = []
         self._state = None
-        self._text_buffer = []
+        self._text_buffer = ""
         i = 0
         input_len = len(input_str)
         special_chars = _SPECIAL_TOKENS
@@ -53,8 +53,9 @@ class TagScriptParser:
         # this is an extremely hot loop so there are additional local references to
         # instance attributes in order to squeeze a bit more performance from the
         # parser
+        char = ""
         while i < input_len:
-            previous_char = input_str[max(i - 1, 0)]
+            previous_char = char
             char = input_str[i]
             block: BlockParseState | None = self._state
             current_state = block.state if block is not None else None
@@ -65,7 +66,7 @@ class TagScriptParser:
                 while i < input_len and input_str[i] not in special_chars:
                     i += 1
                 text = input_str[start:i]
-                self._text_buffer.append(text)
+                self._text_buffer += text
                 continue
 
             try:
@@ -74,7 +75,7 @@ class TagScriptParser:
                     if block is None or current_state is None:
                         if previous_char == BACKSLASH:
                             # escaped, don't start block
-                            self._text_buffer.append(char)
+                            self._text_buffer += char
                             i += 1
                             continue
                         self._flush_text_buffer()
@@ -90,52 +91,52 @@ class TagScriptParser:
 
                     if current_state == ParseState.EXPECTING_DECLARATION:
                         block.transition_state(ParseState.IN_DECLARATION)
-                        block.declaration = [char]
+                        block.declaration = char
                     elif current_state == ParseState.IN_DECLARATION:
                         if block.declaration is None:
-                            block.declaration = [char]
+                            block.declaration = char
                         else:
-                            block.declaration.append(char)
+                            block.declaration += char
                     elif current_state == ParseState.IN_PARAMETER:
                         if block.parameter is None:
-                            block.parameter = [char]
+                            block.parameter = char
                         else:
-                            block.parameter.append(char)
+                            block.parameter += char
                     elif current_state == ParseState.IN_PAYLOAD:
                         if block.payload is None:
-                            block.payload = [char]
+                            block.payload = char
                         else:
-                            block.payload.append(char)
+                            block.payload += char
                     elif current_state == ParseState.POST_PARAMETER:
                         # only colon or pop is allowed here, abort the block entirely
-                        self._text_buffer.append(_reconstruct_partial_block(block))
-                        self._text_buffer.append(char)
+                        self._text_buffer += _reconstruct_partial_block(block)
+                        self._text_buffer += char
                         self._state = None
                     # endregion Opening brace handling
 
                 elif char == BRACE_CLOSE:
                     # region Closing brace handling
                     if block is None or current_state is None:
-                        self._text_buffer.append(char)
+                        self._text_buffer += char
                         i += 1
                         continue
                     elif block.block_depth == 1:
                         if previous_char == BACKSLASH:
                             if current_state == ParseState.IN_DECLARATION:
                                 if block.declaration is None:
-                                    block.declaration = [char]
+                                    block.declaration = char
                                 else:
-                                    block.declaration.append(char)
+                                    block.declaration += char
                             elif current_state == ParseState.IN_PARAMETER:
                                 if block.parameter is None:
-                                    block.parameter = [char]
+                                    block.parameter = char
                                 else:
-                                    block.parameter.append(char)
+                                    block.parameter += char
                             elif current_state == ParseState.IN_PAYLOAD:
                                 if block.payload is None:
-                                    block.payload = [char]
+                                    block.payload = char
                                 else:
-                                    block.payload.append(char)
+                                    block.payload += char
                             i += 1
                             continue
 
@@ -143,7 +144,7 @@ class TagScriptParser:
                             if current_state == ParseState.EXPECTING_DECLARATION:
                                 # {} found, illegal BLOCK node, treat as TEXT
                                 text = BRACE_OPEN + char
-                                self._text_buffer.append(text)
+                                self._text_buffer += text
                             else:
                                 self._nodes.append(block.finalize())
                             self._state = None
@@ -155,96 +156,96 @@ class TagScriptParser:
 
                     if current_state == ParseState.EXPECTING_DECLARATION:
                         block.transition_state(ParseState.IN_DECLARATION)
-                        block.declaration = [char]
+                        block.declaration = char
                     elif current_state == ParseState.IN_DECLARATION:
                         if block.declaration is None:
-                            block.declaration = [char]
+                            block.declaration = char
                         else:
-                            block.declaration.append(char)
+                            block.declaration += char
                     elif current_state == ParseState.IN_PARAMETER:
                         if block.parameter is None:
-                            block.parameter = [char]
+                            block.parameter = char
                         else:
-                            block.parameter.append(char)
+                            block.parameter += char
                     elif current_state == ParseState.IN_PAYLOAD:
                         if block.payload is None:
-                            block.payload = [char]
+                            block.payload = char
                         else:
-                            block.payload.append(char)
+                            block.payload += char
                     elif current_state == ParseState.POST_PARAMETER:
                         # only colon or pop is allowed here, abort the block entirely
-                        self._text_buffer.append(_reconstruct_partial_block(block))
-                        self._text_buffer.append(char)
+                        self._text_buffer += _reconstruct_partial_block(block)
+                        self._text_buffer += char
                         self._state = None
                     # endregion Closing brace handling
 
                 elif char == PAREN_OPEN:
                     # region Opening paren handling
                     if block is None or current_state is None:
-                        self._text_buffer.append(char)
+                        self._text_buffer += char
                         i += 1
                         continue
 
                     block.paren_depth += 1
                     if current_state == ParseState.EXPECTING_DECLARATION:
                         block.transition_state(ParseState.IN_DECLARATION)
-                        block.declaration = [char]
+                        block.declaration = char
                     elif current_state == ParseState.IN_DECLARATION:
                         if block.block_depth == 1:
                             block.has_parameter_section = True
                             block.transition_state(ParseState.IN_PARAMETER)
                         elif block.declaration is None:
-                            block.declaration = [char]
+                            block.declaration = char
                         else:
-                            block.declaration.append(char)
+                            block.declaration += char
                     elif current_state == ParseState.IN_PARAMETER:
                         if block.parameter is None:
-                            block.parameter = [char]
+                            block.parameter = char
                         else:
-                            block.parameter.append(char)
+                            block.parameter += char
                     elif current_state == ParseState.IN_PAYLOAD:
                         if block.payload is None:
-                            block.payload = [char]
+                            block.payload = char
                         else:
-                            block.payload.append(char)
+                            block.payload += char
                     elif current_state == ParseState.POST_PARAMETER:
                         # only colon or pop is allowed here, abort the block entirely
-                        self._text_buffer.append(_reconstruct_partial_block(block))
-                        self._text_buffer.append(char)
+                        self._text_buffer += _reconstruct_partial_block(block)
+                        self._text_buffer += char
                         self._state = None
                     # endregion Opening paren handling
 
                 elif char == PAREN_CLOSE:
                     # region Closing paren handling
                     if block is None or current_state is None:
-                        self._text_buffer.append(char)
+                        self._text_buffer += char
                         i += 1
                         continue
 
                     if current_state == ParseState.EXPECTING_DECLARATION:
                         block.transition_state(ParseState.IN_DECLARATION)
-                        block.declaration = [char]
+                        block.declaration = char
                     elif current_state == ParseState.IN_DECLARATION:
                         if block.declaration is None:
-                            block.declaration = [char]
+                            block.declaration = char
                         else:
-                            block.declaration.append(char)
+                            block.declaration += char
                     elif current_state == ParseState.IN_PARAMETER:
                         if block.paren_depth == 1:
                             block.transition_state(ParseState.POST_PARAMETER)
                         elif block.parameter is None:
-                            block.parameter = [char]
+                            block.parameter = char
                         else:
-                            block.parameter.append(char)
+                            block.parameter += char
                     elif current_state == ParseState.IN_PAYLOAD:
                         if block.payload is None:
-                            block.payload = [char]
+                            block.payload = char
                         else:
-                            block.payload.append(char)
+                            block.payload += char
                     elif current_state == ParseState.POST_PARAMETER:
                         # only colon or pop is allowed here, abort the block entirely
-                        self._text_buffer.append(_reconstruct_partial_block(block))
-                        self._text_buffer.append(char)
+                        self._text_buffer += _reconstruct_partial_block(block)
+                        self._text_buffer += char
                         self._state = None
 
                     if block.paren_depth != 0:
@@ -254,13 +255,13 @@ class TagScriptParser:
                 elif char == COLON:
                     # region Colon handling
                     if block is None or current_state is None:
-                        self._text_buffer.append(char)
+                        self._text_buffer += char
                         i += 1
                         continue
 
                     if current_state == ParseState.EXPECTING_DECLARATION:
                         block.transition_state(ParseState.IN_DECLARATION)
-                        block.declaration = [char]
+                        block.declaration = char
                     elif (
                         current_state
                         in (ParseState.IN_DECLARATION, ParseState.POST_PARAMETER)
@@ -271,21 +272,21 @@ class TagScriptParser:
                         block.transition_state(ParseState.IN_PAYLOAD)
                     elif current_state == ParseState.IN_DECLARATION:
                         if block.declaration is None:
-                            block.declaration = [char]
+                            block.declaration = char
                         else:
-                            block.declaration.append(char)
+                            block.declaration += char
                     elif current_state == ParseState.IN_PARAMETER:
                         if block.parameter is None:
-                            block.parameter = [char]
+                            block.parameter = char
                         else:
-                            block.parameter.append(char)
+                            block.parameter += char
                     elif current_state == ParseState.IN_PAYLOAD:
                         if block.payload is None:
-                            block.payload = [char]
+                            block.payload = char
                         else:
-                            block.payload.append(char)
+                            block.payload += char
                     else:
-                        self._text_buffer.append(char)
+                        self._text_buffer += char
                     # endregion Colon handling
 
                 else:
@@ -293,38 +294,38 @@ class TagScriptParser:
                     if block is None or current_state is None:
                         # unlikely if not impossible to hit but better safe than sorry
                         # (non-special chars are fast-tracked for None block above)
-                        self._text_buffer.append(char)
+                        self._text_buffer += char
                         i += 1
                         continue
 
                     if current_state == ParseState.EXPECTING_DECLARATION:
                         block.transition_state(ParseState.IN_DECLARATION)
-                        block.declaration = [char]
+                        block.declaration = char
                     elif current_state == ParseState.IN_DECLARATION:
                         if block.declaration is None:
-                            block.declaration = [char]
+                            block.declaration = char
                         else:
-                            block.declaration.append(char)
+                            block.declaration += char
                     elif current_state == ParseState.IN_PARAMETER:
                         if block.parameter is None:
-                            block.parameter = [char]
+                            block.parameter = char
                         else:
-                            block.parameter.append(char)
+                            block.parameter += char
                     elif current_state == ParseState.IN_PAYLOAD:
                         if block.payload is None:
-                            block.payload = [char]
+                            block.payload = char
                         else:
-                            block.payload.append(char)
+                            block.payload += char
                     elif current_state == ParseState.POST_PARAMETER:
                         # only colon or pop is allowed here, abort the block entirely
-                        self._text_buffer.append(_reconstruct_partial_block(block))
-                        self._text_buffer.append(char)
+                        self._text_buffer += _reconstruct_partial_block(block)
+                        self._text_buffer += char
                         self._state = None
                     # endregion Any other char handling (including BACKSLASH)
 
             except ValueError as e:
                 _log.warning("Invalid state transition encountered: %r", e)
-                self._text_buffer.append(char)
+                self._text_buffer += char
 
             i += 1
         # endregion end of processing loop
@@ -333,7 +334,7 @@ class TagScriptParser:
         self._flush_text_buffer()
         if (block := self._state) is not None:
             raw_partial_block = _reconstruct_partial_block(block)
-            self._text_buffer.append(raw_partial_block)
+            self._text_buffer += raw_partial_block
             self._flush_text_buffer()
             self._state = None
 
@@ -347,19 +348,21 @@ class TagScriptParser:
             else:
                 text = "".join(self._text_buffer)
             self._nodes.append(Node.text(text_value=text))
-            self._text_buffer = []
+            self._text_buffer = ""
 
 
 def _reconstruct_partial_block(block: BlockParseState) -> str:
     """Reconstructs a partial block as text for error recovery."""
-    parts: list[str] = [BRACE_OPEN, "".join(block.declaration or [])]
+    out = BRACE_OPEN
+    if block.declaration is not None:
+        out += block.declaration
     if block.has_parameter_section:
-        parts.append(PAREN_OPEN)
+        out += PAREN_OPEN
         if block.parameter is not None:
-            parts.append("".join(block.parameter))
-        parts.append(PAREN_CLOSE)
+            out += block.parameter
+        out += PAREN_CLOSE
     if block.has_payload_section:
-        parts.append(COLON)
+        out += COLON
         if block.payload is not None:
-            parts.append("".join(block.payload))
-    return "".join(parts)
+            out += block.payload
+    return out