agentmark-templatedx 0.1.0__tar.gz

agentmark_templatedx-0.1.0/.gitignore

@@ -0,0 +1,70 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Ruff
+.ruff_cache/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo

agentmark_templatedx-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,80 @@
+# 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/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@agentmark-ai/templatedx-python",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "postinstall": "node ../../scripts/setup-python-venv.js -e \".[dev]\"",
+    "test": "node ../../scripts/run-venv.js pytest tests/",
+    "lint": "node ../../scripts/run-venv.js ruff check src/ tests/ && node ../../scripts/run-venv.js mypy src --strict",
+    "lint:fix": "node ../../scripts/run-venv.js ruff check --fix src/ tests/"
+  }
+}

agentmark_templatedx-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agentmark-templatedx"
+version = "0.1.0"
+description = "Python implementation of the AgentMark templatedx transformer"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [
+    { name = "AgentMark Team" }
+]
+keywords = ["agentmark", "templatedx", "mdx", "transformer", "template"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "ruff>=0.1.0",
+    "mypy>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/agentmark/agentmark"
+Repository = "https://github.com/agentmark/agentmark"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/templatedx"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+warn_return_any = true
+warn_unused_ignores = true

agentmark_templatedx-0.1.0/src/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",
+]

agentmark_templatedx-0.1.0/src/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",
+}

agentmark_templatedx-0.1.0/src/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)