agentmark-templatedx 0.1.0__py3-none-any.whl

agentmark_templatedx-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: agentmark-templatedx
+Version: 0.1.0
+Summary: Python implementation of the AgentMark templatedx transformer
+Project-URL: Homepage, https://github.com/agentmark/agentmark
+Project-URL: Repository, https://github.com/agentmark/agentmark
+Author: AgentMark Team
+License-Expression: MIT
+Keywords: agentmark,mdx,template,templatedx,transformer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# AgentMark TemplateDX (Python)
+
+Python implementation of the AgentMark templatedx transformer.
+
+## Installation
+
+```bash
+pip install agentmark-templatedx
+```
+
+## Usage
+
+This package transforms pre-parsed MDX AST trees. The AST is typically obtained by:
+- Parsing MDX with the TypeScript `@agentmark-ai/templatedx` package
+- Loading a pre-parsed AST from a JSON file
+- Receiving an AST from the AgentMark runtime
+
+```python
+import asyncio
+import json
+from templatedx import TemplateDX
+
+async def main():
+    engine = TemplateDX()
+
+    # Load a pre-parsed MDX AST (from TypeScript parser or JSON file)
+    with open("template.ast.json") as f:
+        ast = json.load(f)
+
+    # Transform the AST with props
+    result = await engine.transform(
+        ast,
+        props={"name": "Alice", "items": [1, 2, 3]}
+    )
+
+    print(result)
+
+asyncio.run(main())
+```
+
+## Custom Plugins
+
+```python
+from templatedx import TagPlugin, PluginContext
+
+class MyPlugin(TagPlugin):
+    async def transform(self, props, children, context):
+        # Transform children and return result
+        transformer = context.create_node_transformer(context.scope)
+        return await transformer.transform_children(children)
+
+engine = TemplateDX()
+engine.register_tag_plugin(MyPlugin(), ["MyTag"])
+```
+
+## Custom Filters
+
+```python
+engine = TemplateDX()
+engine.register_filter("double", lambda x: x * 2)
+```
+
+## Built-in Filters
+
+- `capitalize(str)` - Capitalize first character
+- `upper(str)` - Uppercase string
+- `lower(str)` - Lowercase string
+- `truncate(str, length)` - Truncate with ellipsis
+- `abs(num)` - Absolute value
+- `join(arr, separator)` - Join array elements
+- `round(num, decimals)` - Round number
+- `replace(str, search, replacement)` - Replace occurrences
+- `urlencode(str)` - URL encode string
+- `dump(any)` - JSON stringify
+
+## Built-in Tags
+
+- `<If condition={...}>` / `<ElseIf condition={...}>` / `<Else>` - Conditional rendering
+- `<ForEach arr={...}>{(item, index) => ...}</ForEach>` - Array iteration
+- `<Raw>...</Raw>` - Raw content passthrough

agentmark_templatedx-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+templatedx/__init__.py,sha256=gvN3W7OwlxJ7s1n4e8AKcbE2n07jA3wssSxl1kqHBdM,1410
+templatedx/constants.py,sha256=hBOTmHqhXaZ4BKmnH5LydMiurL4hBbtXKhPMu3AGSU8,650
+templatedx/engine.py,sha256=GmEpybXMn2RVpYpqP775LnhSCmPKZpopTKEn8slXXy4,4849
+templatedx/expression.py,sha256=ja5CFHke9rxjkPulwnm5o2lI6uQIAVZmJzXJSTEsgdw,23455
+templatedx/filter_registry.py,sha256=gC1uk6-4eqfMC9jKYesKs1eqNN3SLvV2ibP2sfVT9nA,2409
+templatedx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+templatedx/scope.py,sha256=R9mk84tbQig2RiyXo5_dIGnBkGGgLtqS83UEJ5CgF7Y,2743
+templatedx/tag_plugin.py,sha256=6zcTeHBldvxhUASnsKQmtLkvE8TpZ7vf8OAkbhoPp0M,7246
+templatedx/tag_registry.py,sha256=pv_Cr6zleW3CuojJ2kqSRo-EOifdTZK5_F4Gk4-dxiY,2504
+templatedx/transformer.py,sha256=_WB_La9QrJZoGVZjI1KdArzCyL9GJJF152u_stzaMFc,7903
+templatedx/utils.py,sha256=EViu19Sp3OGoets-BfAOvl0PK3AEEA-Wb5s6r9NxSk4,614
+templatedx/filter_plugins/__init__.py,sha256=GVxR-HnEk0eI6qR1iUKECvbx-hVy0Kyg5sxX1YeJUVo,154
+templatedx/filter_plugins/builtin.py,sha256=5b9Fa_pS_IQBbxeoG0NxTd_dYs7olRiACxZfT6SAVlg,4122
+templatedx/tag_plugins/__init__.py,sha256=dXsiOGqI_lEvBlqUiILvadK67QRRO8e6BnqivDdqwqk,259
+templatedx/tag_plugins/conditional.py,sha256=uV0ZCW3l_9_o7McNky07FrQZXNfR-ZZ4hQTftCoYXko,3369
+templatedx/tag_plugins/for_each.py,sha256=LkvW4Tu-yN0Yj39sSPY8WQMO9NqjmsmOLct2VVoz_og,10699
+templatedx/tag_plugins/raw.py,sha256=yq3J_XOxmzTWULE4CBaJ828SZa8OAOkaW65NTPh-l4Y,905
+agentmark_templatedx-0.1.0.dist-info/METADATA,sha256=yPbj1RdmgT5F6TP67A-T4QMRUWPl8bkOxtY1npENXu8,2990
+agentmark_templatedx-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentmark_templatedx-0.1.0.dist-info/RECORD,,

agentmark_templatedx-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

templatedx/__init__.py

@@ -0,0 +1,58 @@
+"""TemplateDX - Python implementation of the AgentMark templatedx transformer.
+
+This package provides a Python implementation of the templatedx transformer
+for processing AgentMark MDX AST trees.
+
+Example:
+    ```python
+    import asyncio
+    from templatedx import TemplateDX
+
+    async def main():
+        engine = TemplateDX()
+        result = await engine.transform(
+            ast,
+            props={"name": "Alice"}
+        )
+        print(result)
+
+    asyncio.run(main())
+    ```
+"""
+
+from .constants import MDX_JSX_ATTRIBUTE_TYPES, NODE_TYPES
+from .engine import TemplateDX
+from .expression import EvaluationError, ExpressionEvaluator, LexerError, ParseError
+from .filter_registry import FilterRegistry
+from .scope import Scope
+from .tag_plugin import Node, NodeHelpers, PluginContext, TagPlugin
+from .tag_registry import TagPluginRegistry
+from .transformer import NodeTransformer, transform_tree
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Main engine
+    "TemplateDX",
+    # Core classes
+    "NodeTransformer",
+    "Scope",
+    "TagPlugin",
+    "PluginContext",
+    "NodeHelpers",
+    # Registries
+    "TagPluginRegistry",
+    "FilterRegistry",
+    # Expression evaluation
+    "ExpressionEvaluator",
+    "LexerError",
+    "ParseError",
+    "EvaluationError",
+    # Constants
+    "NODE_TYPES",
+    "MDX_JSX_ATTRIBUTE_TYPES",
+    # Types
+    "Node",
+    # Convenience functions
+    "transform_tree",
+]

templatedx/constants.py

@@ -0,0 +1,21 @@
+"""Constants for node types and attribute types."""
+
+NODE_TYPES = {
+    "MDX_JSX_FLOW_ELEMENT": "mdxJsxFlowElement",
+    "MDX_JSX_TEXT_ELEMENT": "mdxJsxTextElement",
+    "MDX_JSX_ESM": "mdxjsEsm",
+    "YAML": "yaml",
+    "MDX_TEXT_EXPRESSION": "mdxTextExpression",
+    "MDX_FLOW_EXPRESSION": "mdxFlowExpression",
+    "LIST": "list",
+    "LIST_ITEM": "listItem",
+    "TEXT": "text",
+    "PARAGRAPH": "paragraph",
+    "HTML": "html",
+}
+
+MDX_JSX_ATTRIBUTE_TYPES = {
+    "MDX_JSX_ATTRIBUTE": "mdxJsxAttribute",
+    "MDX_JSX_ATTRIBUTE_VALUE_EXPRESSION": "mdxJsxAttributeValueExpression",
+    "MDX_JSX_EXPRESSION_ATTRIBUTE": "mdxJsxExpressionAttribute",
+}

templatedx/engine.py

@@ -0,0 +1,155 @@
+"""TemplateDX engine - main entry point for the templatedx transformer."""
+
+from collections.abc import Callable
+from typing import Any
+
+from .filter_plugins import register_builtin_filters
+from .filter_registry import FilterRegistry
+from .scope import Scope
+from .tag_plugin import Node, TagPlugin
+from .tag_plugins import ElseIfPlugin, ElsePlugin, ForEachPlugin, IfPlugin, RawPlugin
+from .tag_registry import TagPluginRegistry
+from .transformer import NodeTransformer
+
+
+def _register_builtin_tag_plugins() -> None:
+    """Register all built-in tag plugins globally."""
+    TagPluginRegistry.register_global(IfPlugin(), ["If"])
+    TagPluginRegistry.register_global(ElseIfPlugin(), ["ElseIf"])
+    TagPluginRegistry.register_global(ElsePlugin(), ["Else"])
+    TagPluginRegistry.register_global(ForEachPlugin(), ["ForEach"])
+    TagPluginRegistry.register_global(RawPlugin(), ["Raw"])
+
+
+# Register built-in plugins on module load
+_register_builtin_tag_plugins()
+register_builtin_filters()
+
+
+class TemplateDX:
+    """Stateful TemplateDX engine with isolated plugin registries.
+
+    This is the main entry point for using templatedx. It provides
+    instance-level plugin registries that inherit from global registries.
+
+    Example:
+        ```python
+        engine = TemplateDX()
+
+        # Transform an AST
+        result = await engine.transform(ast, props={"name": "Alice"})
+
+        # Register custom plugins
+        engine.register_tag_plugin(MyPlugin(), ["MyTag"])
+        engine.register_filter("double", lambda x: x * 2)
+        ```
+    """
+
+    def __init__(self) -> None:
+        """Initialize a new TemplateDX engine.
+
+        Creates instance-level registries that inherit from global registries.
+        """
+        self._tag_registry = TagPluginRegistry()
+        self._filter_registry = FilterRegistry()
+
+        # Copy built-in plugins to instance
+        self._tag_registry.copy_from_global()
+        self._filter_registry.copy_from_global()
+
+    def register_tag_plugin(self, plugin: TagPlugin, names: list[str]) -> None:
+        """Register a tag plugin on this instance.
+
+        Args:
+            plugin: The tag plugin instance
+            names: List of tag names this plugin handles
+        """
+        self._tag_registry.register(plugin, names)
+
+    def remove_tag_plugin(self, name: str) -> None:
+        """Remove a tag plugin from this instance.
+
+        Args:
+            name: Tag name to remove
+        """
+        self._tag_registry.remove(name)
+
+    def get_tag_plugin(self, name: str) -> TagPlugin | None:
+        """Get a tag plugin by name.
+
+        Args:
+            name: Tag name
+
+        Returns:
+            The plugin, or None if not found
+        """
+        return self._tag_registry.get(name)
+
+    def get_tag_registry(self) -> TagPluginRegistry:
+        """Get the tag plugin registry.
+
+        Returns:
+            The tag plugin registry for this instance
+        """
+        return self._tag_registry
+
+    def register_filter(self, name: str, func: Callable[..., Any]) -> None:
+        """Register a filter function on this instance.
+
+        Args:
+            name: Filter name
+            func: Filter function
+        """
+        self._filter_registry.register(name, func)
+
+    def remove_filter(self, name: str) -> None:
+        """Remove a filter from this instance.
+
+        Args:
+            name: Filter name to remove
+        """
+        self._filter_registry.remove(name)
+
+    def get_filter(self, name: str) -> Callable[..., Any] | None:
+        """Get a filter function by name.
+
+        Args:
+            name: Filter name
+
+        Returns:
+            The filter function, or None if not found
+        """
+        return self._filter_registry.get(name)
+
+    def get_filter_registry(self) -> FilterRegistry:
+        """Get the filter registry.
+
+        Returns:
+            The filter registry for this instance
+        """
+        return self._filter_registry
+
+    async def transform(
+        self,
+        tree: Node,
+        props: dict[str, Any] | None = None,
+        shared: dict[str, Any] | None = None,
+    ) -> Node:
+        """Transform an AST tree with the given props.
+
+        Note: Props are wrapped as {"props": props} to match TS behavior.
+        Templates access variables as `props.name`, not just `name`.
+
+        Args:
+            tree: Root AST node (pre-parsed MDX AST as dict)
+            props: Props to pass to the template
+            shared: Shared/global context accessible from all scopes
+
+        Returns:
+            Transformed AST tree
+        """
+        # Wrap props to match TypeScript behavior
+        variables = {"props": props if props is not None else {}}
+        scope = Scope(variables=variables, shared=shared if shared is not None else {})
+        transformer = NodeTransformer(scope, self)
+        return await transformer.transform(tree)