tensorify-runtime 0.1.0__tar.gz

tensorify_runtime-0.1.0/MANIFEST.in

@@ -0,0 +1,36 @@
+# MANIFEST.in for tensorify-runtime Python package
+# Controls what files are included in the published PyPI package
+
+# Include Python source
+include src/tensorify/runtime/*.py
+include src/tensorify/runtime/**/*.py
+
+# Include metadata
+include pyproject.toml
+include README.md
+
+# Exclude development artifacts
+exclude *.pyc
+exclude *.pyo
+exclude __pycache__
+exclude **/__pycache__
+exclude **/*.pyc
+exclude **/*.pyo
+
+# Exclude build artifacts
+exclude build/
+exclude dist/
+exclude *.egg-info/
+exclude *.egg
+
+# Exclude development files
+exclude .git/
+exclude .gitignore
+exclude .pytest_cache/
+exclude .mypy_cache/
+
+# Exclude tests
+exclude test/
+exclude tests/
+exclude **/test_*.py
+exclude **/*_test.py

tensorify_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: tensorify-runtime
+Version: 0.1.0
+Summary: Runtime engine for Tensorify workflows (Universal Code Editor)
+Author-email: Tensorify Team <dev@tensorify.io>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Requires-Dist: RestrictedPython>=6.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: redis>=5.0
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"

tensorify_runtime-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tensorify-runtime"
+version = "0.1.0"
+description = "Runtime engine for Tensorify workflows (Universal Code Editor)"
+authors = [
+  { name = "Tensorify Team", email = "dev@tensorify.io" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "RestrictedPython>=6.0",
+    "pydantic>=2.0",
+    "redis>=5.0",
+    "aiohttp>=3.9",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+    "mypy"
+]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+namespaces = true

tensorify_runtime-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tensorify_runtime-0.1.0/src/tensorify/plugins/discord_send.py

@@ -0,0 +1,36 @@
+
+import aiohttp
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class DiscordSendPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        token = ctx.get_secret("DISCORD_TOKEN")
+        if not token:
+            return PluginOutput(status="error", error="Missing DISCORD_TOKEN secret")
+
+        channel_id = inputs.get("channel_id")
+        content = inputs.get("message_content")
+        
+        if not channel_id or not content:
+             return PluginOutput(status="error", error="Missing channel_id or message_content")
+        
+        if token == "MOCK_TOKEN":
+            print(f"[Discord Mock] Sending to {channel_id}: {content}")
+            return PluginOutput(status="success", data={"id": "mock-message-id", "content": content})
+
+        url = f"https://discord.com/api/v10/channels/{channel_id}/messages"
+        headers = {
+            "Authorization": f"Bot {token}",
+            "Content-Type": "application/json"
+        }
+        payload = {"content": str(content)}
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, headers=headers, json=payload) as resp:
+                if resp.status in (200, 201):
+                    data = await resp.json()
+                    return PluginOutput(status="success", data=data)
+                else:
+                    text = await resp.text()
+                    return PluginOutput(status="error", error=f"Discord API Error {resp.status}: {text}")

tensorify_runtime-0.1.0/src/tensorify/plugins/discord_trigger.py

@@ -0,0 +1,14 @@
+
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class DiscordTriggerPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        # In a real scenario, the Runtime passes the trigger event in ctx.inputs
+        trigger_data = ctx.inputs.get("discord_event")
+        
+        if not trigger_data:
+            # Fallback for testing or if invoked manually
+            return PluginOutput(status="error", error="No discord_event found in inputs")
+            
+        return PluginOutput(status="success", data=trigger_data)

tensorify_runtime-0.1.0/src/tensorify/plugins/file_writer.py

@@ -0,0 +1,22 @@
+
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class FileWriterPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        file_path = inputs.get("file_path", "output.txt")
+        mode = inputs.get("mode", "w")
+        content = inputs.get("content", "")
+        
+        # Convert content to string if not
+        if not isinstance(content, str):
+            content = str(content)
+            
+        try:
+            with open(file_path, mode) as f:
+                f.write(content)
+            
+            print(f"[File Writer] Wrote to {file_path}")
+            return PluginOutput(status="success", data=file_path)
+        except Exception as e:
+             return PluginOutput(status="error", error=str(e))

tensorify_runtime-0.1.0/src/tensorify/plugins/http_request.py

@@ -0,0 +1,49 @@
+
+import aiohttp
+import json
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class HttpRequestPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        url = inputs.get("url")
+        method = inputs.get("method", "GET").upper()
+        headers_str = inputs.get("headers", "{}")
+        body = inputs.get("body")
+        
+        if not url:
+            return PluginOutput(status="error", error="Missing URL")
+            
+        try:
+            headers = json.loads(headers_str) if isinstance(headers_str, str) else headers_str
+        except Exception:
+            return PluginOutput(status="error", error="Invalid Headers JSON")
+
+        # Mock Mode for Testing
+        if url == "MOCK_URL":
+            print(f"[HTTP Mock] {method} {url}")
+            return PluginOutput(status="success", data={"status": 200, "data": {"mock": "result"}, "headers": {}})
+            
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.request(method, url, headers=headers, json=body) as resp:
+                    try:
+                        data = await resp.json()
+                    except:
+                        data = await resp.text()
+                        
+                    result_obj = {
+                        "status": resp.status,
+                        "data": data,
+                        "headers": dict(resp.headers)
+                    }
+                    
+                    if 200 <= resp.status < 300:
+                        return PluginOutput(status="success", data=result_obj)
+                    else:
+                        # Even if error status, we return as success so workflow can handle logic? 
+                        # Or return error? V3 Philosophy: Let user decide via If condition on status.
+                        return PluginOutput(status="success", data=result_obj)
+                        
+            except Exception as e:
+                return PluginOutput(status="error", error=str(e))

tensorify_runtime-0.1.0/src/tensorify/plugins/http_response.py

@@ -0,0 +1,14 @@
+
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class HttpResponsePlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        body = inputs.get("body")
+        status = inputs.get("status", 200)
+        headers = inputs.get("headers", {})
+        
+        ctx.set_return_value(body, int(status), headers)
+        
+        print(f"[HTTP Response] Set workflow output: Status {status}")
+        return PluginOutput(status="success", data={"returned": True})

tensorify_runtime-0.1.0/src/tensorify/plugins/json_transform.py

@@ -0,0 +1,46 @@
+
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class JsonTransformPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        data = inputs.get("data")
+        expr = inputs.get("expression", "data")
+        
+        # Inject 'data' into the evaluation context
+        # We rely on ctx.eval taking care of restricted execution
+        # But ctx.eval uses ctx._variables. 
+        # We should probably pass a temporary context to eval?
+        # core.py `eval` method: `return safe_eval(expression, eval_context)`
+        # `eval_context` includes `inputs`, `vars`.
+        # So if we want `data` to be available as a variable `data`, we need to inject it.
+        # But `core.py` eval constructs context from member variables.
+        # It doesn't accept "extra locals".
+        # 
+        # Helper workaround: We set a temporary variable in ctx? No, dangerous concurrency.
+        # The `ctx.eval` method in core.py needs to support overrides?
+        #
+        # Let's check core.py. 
+        # def eval(self, expression: str) -> Any:
+        #    ...
+        #    return safe_eval(expression, eval_context)
+        #
+        # This means I CANNOT pass extra vars to eval unless I modify core.py.
+        # OR I use `safe_eval` directly here in the plugin.
+        # Plugin classes sit next to core, but can import safe_eval?
+        # Yes, from tensorify.runtime.expression import safe_eval.
+        
+        from tensorify.runtime.expression import safe_eval
+        
+        eval_ctx = ctx._variables.copy()
+        eval_ctx["data"] = data
+        # Also include standard utils if needed, safe_eval handles it.
+        
+        try:
+            print(f"[JsonTransform] Data: {data}, Expr: {expr}")
+            result = safe_eval(expr, eval_ctx)
+            print(f"[JsonTransform] Result: {result}")
+            return PluginOutput(status="success", data=result)
+        except Exception as e:
+             print(f"[JsonTransform] Error: {e}")
+             return PluginOutput(status="error", error=f"Transform error: {str(e)}")

tensorify_runtime-0.1.0/src/tensorify/plugins/python_script.py

@@ -0,0 +1,54 @@
+
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+from RestrictedPython import compile_restricted, safe_globals
+
+class PythonScriptPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        code_str = inputs.get("code", "")
+        script_params = inputs.get("script_params", {})
+        
+        # Prepare globs
+        # For "Universal" script, we use standard builtins to allow imports
+        # In a real production environment, this should be sandboxed via Docker/WASM,
+        # but for V3 MVP "Local Execution", we trust the user code (or warn them).
+        script_globals = {
+            "__builtins__": __builtins__,
+            "__name__": "universal_script",
+            "ctx": ctx,
+            "print": print
+        }
+        
+        # Locals will contain inputs and collect outputs
+        loc = {
+            "params": script_params, 
+            "result": None,
+            "ctx": ctx # Expose Context for V3 Variable Access (Temporary/Advanced)
+        }
+        
+        # Helper to indent user code
+        indented_code = "\n".join(["    " + line for line in code_str.split("\n")])
+        
+        # Wrapper function
+        wrapped_code = f"""
+async def _user_script(ctx, params):
+    # Standard globals
+{indented_code}
+"""
+        
+        try:
+             # Compile standard (unsafe for now, but universal)
+             exec(wrapped_code, script_globals, loc)
+             
+             # Execute the async function
+             if "_user_script" in loc:
+                 await loc["_user_script"](ctx, script_params)
+             
+             # Proxy captured output (if any)
+             # Note: standard print goes to stdout, so we don't need to capture 'printed' variable unless we redirect stdout.
+             # Since we use standard exec, 'print' just prints.
+             
+             return PluginOutput(status="success", data=loc.get("result"))
+        except Exception as e:
+            print(f"[Script Error] {str(e)}")
+            return PluginOutput(status="error", error=f"Script Error: {str(e)}")

tensorify_runtime-0.1.0/src/tensorify/plugins/telegram_send.py

@@ -0,0 +1,32 @@
+
+import aiohttp
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class TelegramSendPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        token = ctx.get_secret("TELEGRAM_BOT_TOKEN")
+        if not token:
+             return PluginOutput(status="error", error="Missing TELEGRAM_BOT_TOKEN")
+             
+        chat_id = inputs.get("chat_id")
+        text = inputs.get("text")
+        
+        if not chat_id or not text:
+            return PluginOutput(status="error", error="Missing chat_id or text")
+            
+        # Mock Support
+        if token == "MOCK_TOKEN":
+            print(f"[Telegram Mock] Sending to {chat_id}: {text}")
+            return PluginOutput(status="success", data={"ok": True, "result": {"message_id": 123, "text": text}})
+        
+        url = f"https://api.telegram.org/bot{token}/sendMessage"
+        payload = {"chat_id": chat_id, "text": str(text)}
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, json=payload) as resp:
+                data = await resp.json()
+                if resp.status == 200 and data.get("ok"):
+                    return PluginOutput(status="success", data=data)
+                else:
+                    return PluginOutput(status="error", error=f"Telegram API Error: {data}")

tensorify_runtime-0.1.0/src/tensorify/plugins/telegram_trigger.py

@@ -0,0 +1,13 @@
+
+from typing import Any, Dict
+from tensorify.runtime.core import ExecutionContext, PluginOutput
+
+class TelegramTriggerPlugin:
+    async def run(self, ctx: ExecutionContext, inputs: Dict[str, Any]) -> PluginOutput:
+        # Runtime extracts payload from webhook/polling source and puts it in inputs
+        tg_event = ctx.inputs.get("telegram_event")
+        
+        if not tg_event:
+            return PluginOutput(status="error", error="No telegram_event found in inputs")
+            
+        return PluginOutput(status="success", data=tg_event)

tensorify_runtime-0.1.0/src/tensorify/runtime/__init__.py

@@ -0,0 +1,31 @@
+from .core import (
+    ExecutionContext,
+    PluginOutput,
+    ActionPluginV3,
+    EventSource,
+    run_plugin,
+    SnapshotCapturer,
+    WorkflowReturnSignal
+)
+from .subworkflow import SubworkflowLoader
+from .state import (
+    StateManager,
+    SQLiteStateManager
+)
+from .expression import safe_eval
+
+__all__ = [
+    "ExecutionContext",
+    "PluginOutput",
+    "ActionPluginV3",
+    "StateManager",
+    "SQLiteStateManager",
+     "safe_eval",
+    "run_plugin",
+    "SubworkflowLoader",
+    "SnapshotCapturer",
+    "WorkflowReturnSignal"
+]
+
+# Version info could go here
+__version__ = "0.1.0"

tensorify_runtime-0.1.0/src/tensorify/runtime/core.py

@@ -0,0 +1,556 @@
+import os
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Protocol, runtime_checkable
+import uuid
+import datetime
+
+from .state import StateManager, SQLiteStateManager
+from .expression import safe_eval
+import json
+import importlib.util
+import sys
+import aiohttp
+
+class WorkflowReturnSignal(Exception):
+    """Sentinel exception used to propagate a subworkflow result."""
+    def __init__(self, value: Any):
+        self.value = value
+
+@dataclass
+class PluginOutput:
+    """
+    Standard output from any plugin execution.
+    """
+    status: str = "success"  # "success" | "error"
+    data: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+@runtime_checkable
+class ActionPluginV3(Protocol):
+    """
+    Protocol for V3 Action Plugins.
+    All plugins must implement a 'run' function matching this signature.
+    """
+    async def run(self, ctx: "ExecutionContext", inputs: Dict[str, Any]) -> PluginOutput:
+        pass
+
+class EventSource(ABC):
+    """
+    Base class for Trigger Plugins.
+    """
+    def __init__(self):
+        self._handlers = []
+
+    def on_event(self, handler):
+        """Register an async handler function."""
+        self._handlers.append(handler)
+
+    async def emit(self, event_data: Any) -> list:
+        """Call all registered handlers with event data and return their results."""
+        results = []
+        for h in self._handlers:
+            result = await h(event_data)
+            results.append(result)
+        return results
+
+    @abstractmethod
+    async def start(self):
+        """Start the event loop / listener."""
+        pass
+
+    @abstractmethod
+    async def stop(self):
+        """Stop the listener."""
+        pass
+
+class ExecutionContext:
+    """
+    The Runtime Context passed to every node execution.
+    Provides safe access to:
+    - Inputs (from Trigger)
+    - Secrets (Env/Vault)
+    - State (Persistence)
+    - Variables (Runtime Data Flow)
+    """
+
+    def __init__(
+        self,
+        workflow_id: str,
+        execution_id: str,
+        inputs: Dict[str, Any] = None,
+        secrets: Optional[Dict[str, str]] = None,
+        state_manager: Optional[StateManager] = None,
+    ):
+        self.workflow_id = workflow_id
+        # The compiler still emits placeholder execution IDs like "local" or "event"
+        # for generated entrypoints. Prefer the runner-provided run ID when available
+        # so snapshots and job audit trails attach to the actual execution record.
+        self.execution_id = os.environ.get("TENSORIFY_RUN_ID") or execution_id
+        self.inputs = inputs or {}
+        
+        # Security: Use provided secrets dict or fall back to os.environ
+        # In production, this should be restricted.
+        self._secrets = secrets if secrets is not None else os.environ
+        
+        self._state = state_manager or SQLiteStateManager()
+        
+        # Runtime Variables (The "Universal Editor" Data Bus)
+        # Key = Node ID or Variable Name, Value = Any
+        self._variables: Dict[str, Any] = {}
+        
+        # Workflow Return Value (for Webhooks/Sync executions)
+        self._return_value = None
+        self._is_subworkflow = False
+
+    # === Secrets ===
+    def get_secret(self, key: str) -> Optional[str]:
+        """Securely retrieve a secret."""
+        # TODO: Add audit logging here (Who accessed what?)
+        return self._secrets.get(key)
+    
+    # === State (Persistent) ===
+    def set_state(self, key: str, value: Any):
+        """Store data that survives workflow restarts."""
+        self._state.set(self.workflow_id, key, value)
+        
+    def get_state(self, key: str, default: Any = None) -> Any:
+        """Retrieve persistent data."""
+        return self._state.get(self.workflow_id, key, default)
+
+    # === Variables (Transient / Data Flow) ===
+    def set_var(self, key: str, value: Any):
+        """
+        Store a runtime variable.
+        Used by the Compiler to store Node Outputs.
+        """
+        # DEBUG: Print variable update
+        val_str = str(value)
+        truncated_val = val_str[:150] + "..." if len(val_str) > 150 else val_str
+        print(f"[Runtime] [VAR] Setting {key} = {truncated_val}", flush=True)
+
+        self._variables[key] = value
+        print(f"[Runtime] [CTX] Available Variables: {list(self._variables.keys())}", flush=True)
+        # Auto-persist interaction outputs for "Time Travel" / "IntelliSense"
+        # We only persist if it's JSON-serializable (which most plugin outputs are)
+        try:
+             self._state.set(self.workflow_id, f"var_{key}", value)
+             
+             # HYBRID TEST MODE SNAPSHOT
+             execution_mode = os.environ.get("TENSORIFY_EXECUTION_MODE", "serve")
+             if os.environ.get("TENSORIFY_TEST_MODE") == "true" or execution_mode == "invoke":
+                 current_node_id = getattr(self, "_current_node_id", None)
+                 current_inputs = getattr(self, "_current_node_inputs", None)
+                 # Inherit inputs if it's the node's primary output OR a friendly alias set during its execution
+                 snapshot_inputs = current_inputs if (current_node_id == key or current_node_id is not None) else None
+                 SnapshotCapturer.capture_async(self, key, value, snapshot_inputs)
+                 
+        except Exception as e:
+             print(f"[Runtime] State Error/Snapshot Failed: {e}", flush=True)
+             # Ignore serialization errors for non-persistable objects
+             pass
+
+
+        
+    def get_var(self, key: str, default: Any = None) -> Any:
+        """
+        Retrieve a runtime variable.
+        Used by Nodes to access upstream data.
+        """
+        return self._variables.get(key, default)
+    
+    # === Expressions ===
+    def eval(self, expression: str) -> Any:
+        """
+        Safely evaluate a TSL expression.
+        Context includes: inputs, vars, state.
+        """
+        eval_context = {
+            "input": self.inputs,
+            "inputs": self.inputs,
+            "vars": self._variables,
+            "state": self._state.get_all(self.workflow_id)
+        }
+        # Flatten variables for direct access (e.g. loop iterators)
+        eval_context.update(self._variables)
+
+        # Helper for accessing variables with invalid python identifiers (e.g. UUIDs)
+        eval_context["get"] = self.get_var
+
+        # Check if this is a template string (contains {{ }})
+        if isinstance(expression, str) and "{{" in expression and "}}" in expression:
+            # Count how many template sections we have
+            template_count = len(re.findall(r"\{\{.+?\}\}", expression))
+
+            def replace_template(match):
+                inner = match.group(1).strip()
+                resolved = safe_eval(inner, eval_context)
+                return str(resolved)  # Return string representation, not repr()
+
+            # Perform template substitution
+            result = re.sub(r"\{\{(.+?)\}\}", replace_template, expression)
+
+            # If it's a single template with nothing else, eval to preserve type
+            # Otherwise return the substituted string directly
+            if template_count == 1 and expression.strip().startswith("{{") and expression.strip().endswith("}}"):
+                try:
+                    return safe_eval(result.strip("'\"", eval_context))
+                except:
+                    return result
+            else:
+                # Multiple templates or mixed content - return string as-is
+                return result
+
+        try:
+            return safe_eval(expression, eval_context)
+        except Exception as e:
+            # Provide helpful debugging
+            available_keys = list(self._variables.keys())
+            print(f"[Runtime] Eval Error: {e}")
+            print(f"[Runtime] Available variables: {available_keys}")
+            raise e
+
+    def resolve(self, value: Any) -> Any:
+        """
+        Resolve a value that might contain template strings {{ var }}.
+        If value is a string with {{ }}, it evaluates the expression.
+        If value is not a string, returns as is.
+        """
+        if not isinstance(value, str):
+            return value
+
+        # Check if this is a template string
+        if "{{" in value and "}}" in value:
+            # Count how many template sections we have
+            template_count = len(re.findall(r"\{\{.+?\}\}", value))
+
+            # Perform template substitution
+            def replace(m):
+                res = self.eval(m.group(1).strip())
+                return str(res)
+
+            result = re.sub(r"\{\{(.+?)\}\}", replace, value)
+
+            # If it's a single template with nothing else, eval to preserve type
+            # Check that it starts with {{ and ends with }}
+            stripped = value.strip()
+            if template_count == 1 and stripped.startswith("{{") and stripped.endswith("}}"):
+                try:
+                    return self.eval(stripped[2:-2].strip())
+                except:
+                    return result
+            else:
+                # Multiple templates or mixed content - return substituted string
+                print(f"[Runtime] [Template] Resolved: {value[:100]}... → {result[:100]}", flush=True)
+                return result
+
+        return value
+
+    def set_return_value(self, value: Any, status: int = 200, headers: Dict = None):
+        """Set the final output of the workflow."""
+        self._return_value = {"body": value, "status": status, "headers": headers or {}}
+
+    def get_return_value(self):
+        return self._return_value
+
+
+import asyncio
+import aiohttp
+import urllib.request
+import urllib.error
+
+class SnapshotCapturer:
+    _pending_tasks = set()
+
+    @staticmethod
+    def capture_async(ctx: "ExecutionContext", node_id: str, data: Any, inputs: Any = None, status: str = "success"):
+        """Fire-and-forget snapshot upload."""
+        mode = os.environ.get("TENSORIFY_TEST_MODE")
+        print(f"[Runtime] Snapshot Capture Triggered for {node_id}. Mode: {mode}", flush=True)
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                task = loop.create_task(SnapshotCapturer._upload(ctx, node_id, data, inputs, status))
+                SnapshotCapturer._pending_tasks.add(task)
+                task.add_done_callback(SnapshotCapturer._pending_tasks.discard)
+            else:
+                 SnapshotCapturer._upload_sync(ctx, node_id, data, inputs, status)
+        except RuntimeError:
+             # Fallback if no event loop exists (e.g. strict exec environments)
+             print(f"[Runtime] Falling back to synchronous snapshot upload for {node_id}")
+             SnapshotCapturer._upload_sync(ctx, node_id, data, inputs, status)
+        except Exception as e:
+            print(f"[Runtime] Snapshot Error: {e}")
+
+    @staticmethod
+    async def wait_all():
+        if SnapshotCapturer._pending_tasks:
+            await asyncio.gather(*SnapshotCapturer._pending_tasks, return_exceptions=True)
+            SnapshotCapturer._pending_tasks.clear()
+
+    @staticmethod
+    async def _upload(ctx: "ExecutionContext", node_id: str, data: Any, inputs: Any = None, status: str = "success"):
+        import redis
+        import json
+        import datetime
+
+        try:
+            # 1. Mask Secrets
+            masked_inputs = SnapshotCapturer._mask_recursive(inputs, ctx._secrets.values())
+            masked_data = SnapshotCapturer._mask_recursive(data, ctx._secrets.values())
+
+            # 2. Prepare Payload
+            payload = {
+                "id": str(uuid.uuid4()),
+                "workflowId": ctx.workflow_id,
+                "nodeId": node_id,
+                "runId": ctx.execution_id,
+                "status": status,
+                "inputs": masked_inputs,
+                "output": masked_data,
+                "capturedAt": datetime.datetime.now(datetime.timezone.utc).isoformat()
+            }
+
+            # 3. Publish to Redis for real-time WebSocket streaming
+            try:
+                # Support REDIS_URL connection string (like DATABASE_URL)
+                # Format: redis://localhost:6379/0 or rediss:// for TLS
+                redis_url = os.environ.get("REDIS_URL")
+                if redis_url:
+                    redis_client = redis.from_url(redis_url, decode_responses=True)
+                else:
+                    # Fallback to individual env vars for backward compatibility
+                    redis_client = redis.Redis(
+                        host=os.environ.get("REDIS_HOST", "localhost"),
+                        port=int(os.environ.get("REDIS_PORT", 6379)),
+                        db=int(os.environ.get("REDIS_DB", 0)),
+                        decode_responses=True
+                    )
+
+                channel = f"workflow:{ctx.workflow_id}:snapshots"
+                redis_client.publish(channel, json.dumps(payload))
+                print(f"[Runtime] 📤 Published snapshot to Redis: {channel}", flush=True)
+
+            except Exception as redis_err:
+                print(f"[Runtime] ⚠️  Redis publish failed: {redis_err}", flush=True)
+            
+            # 4. Also upload via HTTP for database persistence (fallback)
+            api_url = os.environ.get("TENSORIFY_API_URL", "http://localhost:3000")
+            token = os.environ.get("TENSORIFY_API_KEY") 
+            auth_token = os.environ.get("TENSORIFY_AUTH_TOKEN", token)
+            
+            url = f"{api_url}/api/v1/snapshots"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {auth_token}"
+            }
+            
+            timeout = aiohttp.ClientTimeout(total=2)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(url, json=payload, headers=headers) as resp:
+                     if resp.status != 200:
+                         print(f"[Runtime] Snapshot HTTP Upload Failed: {await resp.text()}", flush=True)
+
+        except Exception as e:
+            print(f"[Runtime] Snapshot Upload Exception: {e}")
+
+    @staticmethod
+    def _upload_sync(ctx: "ExecutionContext", node_id: str, data: Any, inputs: Any = None, status: str = "success"):
+        """Synchronous fallback for snapshot uploads when async event loops are missing."""
+        try:
+            masked_inputs = SnapshotCapturer._mask_recursive(inputs, ctx._secrets.values())
+            masked_data = SnapshotCapturer._mask_recursive(data, ctx._secrets.values())
+            
+            payload = {
+                "workflowId": ctx.workflow_id,
+                "nodeId": node_id,
+                "runId": ctx.execution_id,
+                "status": status,
+                "inputs": masked_inputs,
+                "output": masked_data
+            }
+            
+            api_url = os.environ.get("TENSORIFY_API_URL", "http://localhost:3000")
+            token = os.environ.get("TENSORIFY_API_KEY") 
+            auth_token = os.environ.get("TENSORIFY_AUTH_TOKEN", token)
+            
+            url = f"{api_url}/api/v1/snapshots"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {auth_token}"
+            }
+            
+            req = urllib.request.Request(
+                url, 
+                data=json.dumps(payload).encode('utf-8'), 
+                headers=headers, 
+                method='POST'
+            )
+            try:
+                with urllib.request.urlopen(req, timeout=2) as response:
+                     if response.status != 200:
+                         print(f"[Runtime] Sync Snapshot Upload Failed: HTTP {response.status}", flush=True)
+            except urllib.error.HTTPError as e:
+                 print(f"[Runtime] Sync Snapshot Upload HTTP Error: {e.code} - {e.reason}", flush=True)
+            except Exception as e:
+                 print(f"[Runtime] Sync Snapshot Upload Failed: {e}", flush=True)
+
+        except Exception as e:
+            print(f"[Runtime] Sync Snapshot Exception: {e}")
+
+    @staticmethod
+    def _mask_recursive(data: Any, secrets: Any) -> Any:
+        if isinstance(data, dict):
+            return {k: SnapshotCapturer._mask_recursive(v, secrets) for k, v in data.items()}
+        elif isinstance(data, list):
+            return [SnapshotCapturer._mask_recursive(i, secrets) for i in data]
+        elif isinstance(data, str):
+            for secret in secrets:
+                if secret and len(secret) > 4 and secret in data:
+                     data = data.replace(secret, "******")
+            return data
+        else:
+            return data
+
+
+async def run_plugin(ctx: ExecutionContext, plugin_key: str, inputs: Dict[str, Any]) -> Any:
+    """
+    Executes a plugin action.
+    """
+    # Local import to avoid circular dependency
+    # from ..plugins.discord_send import DiscordSendPlugin
+    # from ..plugins.discord_trigger import DiscordTriggerPlugin
+    # from ..plugins.telegram_send import TelegramSendPlugin
+    # from ..plugins.telegram_trigger import TelegramTriggerPlugin
+    # from ..plugins.python_script import PythonScriptPlugin
+    from ..plugins.http_request import HttpRequestPlugin
+    # from ..plugins.http_response import HttpResponsePlugin
+    # from ..plugins.file_writer import FileWriterPlugin
+    # from ..plugins.json_transform import JsonTransformPlugin
+    
+    # Simple registry (Phase 5)
+    registry = {}
+    
+    plugin = registry.get(plugin_key)
+    
+    # --- Dynamic Discovery from Bundled Plugins ---
+    if not plugin:
+        try:
+            # Try to load as a flat module from 'plugins' package first
+            try:
+                # heuristic: @tensorify/webhook-trigger:3.0.0 -> webhook_trigger
+                # clean_name = plugin_key.split(":")[0].replace("@tensorify/", "").replace("-", "_")
+                # But 'plugins' dir is in sys.path? No, we need to import from 'plugins' package.
+                # Assuming 'main.py' is in root and 'plugins' is a package next to it.
+                
+                clean_name = plugin_key.split(":")[0].replace("@tensorify/", "").replace("-", "_")
+                module_name = f"plugins.{clean_name}"
+                
+                print(f"[Runtime] Attempting import: {module_name}")
+                module = importlib.import_module(module_name)
+                
+                # We need to find the class.
+                # Heuristic: CamelCase of clean_name? webhook_trigger -> WebhookTriggerPlugin
+                # Or just search the module for a subclass of something?
+                # Or check __all__?
+                
+                # Let's inspect the module
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name)
+                    # Simple check: class name ends with 'Plugin'
+                    if isinstance(attr, type) and attr_name.endswith("Plugin") and attr_name != "Plugin":
+                         print(f"[Runtime] Found plugin class {attr_name} in {module_name}")
+                         plugin_instance = attr()
+                         registry[plugin_key] = plugin_instance
+                         plugin = plugin_instance
+                         break
+                
+            except ImportError:
+                 # Fallback to nested folder discovery (if manual bundle)
+                 pass
+            except Exception as e:
+                print(f"[Runtime] Flat import failed for {plugin_key}: {e}")
+
+            if not plugin:
+                # Look for plugins directory (sibling to this runtime or in executing root)
+                # We assume the execution root has 'plugins' folder (from our bundle logic)
+                cwd = pathlib.Path.cwd()
+                plugin_dir = cwd / "plugins" / plugin_key
+    
+                if plugin_dir.exists() and plugin_dir.is_dir():
+                    manifest_path = plugin_dir / "manifest.json"
+                    
+                    # Check python directory
+                    python_dir = plugin_dir / "python"
+                    
+                    print(f"[Runtime] Checking {plugin_dir}")
+                    
+                    if manifest_path.exists() and python_dir.exists():
+                        with open(manifest_path, "r") as f:
+                            manifest = json.load(f)
+                        
+                        class_name = manifest.get("entrypointClassName")
+                        
+                        if class_name:
+                            # Scan python files for the class
+                            found_class = False
+                            for py_file in python_dir.glob("*.py"):
+                                # Dynamically load module
+                                module_name = f"dynamic_plugins.{plugin_key.replace('/', '_').replace(':', '_').replace('@', '').replace('-', '_')}"
+                                try:
+                                    spec = importlib.util.spec_from_file_location(module_name, py_file)
+                                    if spec and spec.loader:
+                                        module = importlib.util.module_from_spec(spec)
+                                        sys.modules[module_name] = module
+                                        spec.loader.exec_module(module)
+                                        
+                                        if hasattr(module, class_name):
+                                            PluginClass = getattr(module, class_name)
+                                            # Instantiate
+                                            plugin_instance = PluginClass()
+                                            
+                                            # Cache and use
+                                            registry[plugin_key] = plugin_instance
+                                            plugin = plugin_instance
+                                            print(f"[Runtime] Dynamically loaded {plugin_key} from {py_file}")
+                                            found_class = True
+                                            break
+                                except Exception as e:
+                                    print(f"[Runtime] Error loading module {py_file}: {e}")
+                            
+                            if not found_class:
+                               print(f"[Runtime] Class {class_name} not found in {python_dir}")
+                        else:
+                            print(f"[Runtime] entrypointClassName not found in metadata for {plugin_key}")
+                    else:
+                        print(f"[Runtime] Manifest or python dir missing in {plugin_dir}")
+                else:
+                     print(f"[Runtime] Plugin dir not found: {plugin_dir} (CWD: {cwd})")
+        except Exception as e:
+            print(f"[Runtime] Dynamic discovery failed for {plugin_key}: {e}")
+
+    if not plugin:
+        print(f"[Runtime] Warning: Plugin {plugin_key} not found in registry. Using Mock.")
+        return PluginOutput(status="success", data={"message": f"Mock Output from {plugin_key}"})
+    
+    print(f"[Runtime] Executing {plugin_key}")
+    try:
+        ctx._current_node_inputs = inputs
+
+        # Return the full PluginOutput object so the caller (generated code)
+        # can treat it consistently with direct class calls (accessing .data).
+        result = await plugin.run(ctx, inputs)
+        
+        # LOGGING FOR USER INSPECTION
+        if result.status == "success":
+             try:
+                 print(f"[Runtime] Output from {plugin_key}: {json.dumps(result.data, default=str)}", flush=True)
+             except:
+                 print(f"[Runtime] Output from {plugin_key}: {result.data} (Not JSON serializable)", flush=True)
+        else:
+             print(f"[Runtime] Error from {plugin_key}: {result.error}", flush=True)
+
+        return result
+    except Exception as e:
+        return PluginOutput(status="error", error=str(e))

tensorify_runtime-0.1.0/src/tensorify/runtime/expression.py

@@ -0,0 +1,55 @@
+from RestrictedPython import compile_restricted, safe_globals, utility_builtins
+from typing import Any, Dict
+
+def safe_eval(expression: str, context: Dict[str, Any]) -> Any:
+    """
+    Safely evaluate a Python expression within a context.
+    
+    Security:
+    - No imports
+    - No disk access
+    - No dunder (__) access
+    
+    Args:
+        expression: Python expression string (e.g. "a > 10")
+        context: Dictionary of variables available to the expression
+    
+    Returns:
+        The result of the expression
+    """
+    if not expression or not expression.strip():
+        return None
+        
+    try:
+        # Prepare restricted execution environment
+        loc = {}
+        
+        # Helper for RestrictedPython subscript access
+        def _getitem_(obj, index):
+            return obj[index]
+            
+        def _getattr_(obj, name):
+            if isinstance(obj, dict) and name in obj:
+                return obj[name]
+            return getattr(obj, name)
+            
+        def _getiter_(obj):
+            return iter(obj)
+
+        # Combine safe builtins with user context
+        glob = safe_globals.copy()
+        glob.update(utility_builtins)
+        glob["_getitem_"] = _getitem_
+        glob["_getattr_"] = _getattr_
+        glob["_getiter_"] = _getiter_
+        glob.update(context)
+        
+        # Compile expression (eval mode)
+        code = compile_restricted(expression, '<string>', 'eval')
+        
+        # Execute
+        result = eval(code, glob, loc)
+        return result
+        
+    except Exception as e:
+        raise ValueError(f"Expression evaluation failed: {expression}. Error: {str(e)}")

tensorify_runtime-0.1.0/src/tensorify/runtime/state.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+import json
+import os
+import sqlite3
+from typing import Any, Dict, Optional
+
+class StateManager(ABC):
+    """
+    Interface for persistent state storage.
+    Used by workflows to store data that survives restarts/crashes.
+    """
+    
+    @abstractmethod
+    def set(self, workflow_id: str, key: str, value: Any):
+        pass
+    
+    @abstractmethod
+    def get(self, workflow_id: str, key: str, default: Any = None) -> Any:
+        pass
+    
+    @abstractmethod
+    def delete(self, workflow_id: str, key: str):
+        pass
+    
+    @abstractmethod
+    def get_all(self, workflow_id: str) -> Dict[str, Any]:
+        pass
+
+class SQLiteStateManager(StateManager):
+    """
+    Production-ready local state storage using SQLite.
+    Stores values as JSON strings.
+    """
+    
+    def __init__(self, db_path: str = ".tensorify/state.db"):
+        self.db_path = db_path
+        self._init_db()
+    
+    def _init_db(self):
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        conn = sqlite3.connect(self.db_path)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS state (
+                workflow_id TEXT,
+                key TEXT,
+                value TEXT,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                PRIMARY KEY (workflow_id, key)
+            )
+        """)
+        conn.commit()
+        conn.close()
+    
+    def set(self, workflow_id: str, key: str, value: Any):
+        conn = sqlite3.connect(self.db_path)
+        try:
+            serialized_value = json.dumps(value)
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO state (workflow_id, key, value) 
+                VALUES (?, ?, ?)
+                """,
+                (workflow_id, key, serialized_value)
+            )
+            conn.commit()
+        finally:
+            conn.close()
+    
+    def get(self, workflow_id: str, key: str, default: Any = None) -> Any:
+        conn = sqlite3.connect(self.db_path)
+        try:
+            cursor = conn.execute(
+                "SELECT value FROM state WHERE workflow_id = ? AND key = ?",
+                (workflow_id, key)
+            )
+            row = cursor.fetchone()
+            if row:
+                return json.loads(row[0])
+            return default
+        finally:
+            conn.close()
+            
+    def delete(self, workflow_id: str, key: str):
+        conn = sqlite3.connect(self.db_path)
+        try:
+            conn.execute(
+                "DELETE FROM state WHERE workflow_id = ? AND key = ?",
+                (workflow_id, key)
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+    def get_all(self, workflow_id: str) -> Dict[str, Any]:
+        conn = sqlite3.connect(self.db_path)
+        try:
+            cursor = conn.execute(
+                "SELECT key, value FROM state WHERE workflow_id = ?",
+                (workflow_id,)
+            )
+            result = {}
+            for key, value_json in cursor.fetchall():
+                result[key] = json.loads(value_json)
+            return result
+        finally:
+            conn.close()

tensorify_runtime-0.1.0/src/tensorify/runtime/subworkflow.py

@@ -0,0 +1,115 @@
+import importlib.util
+import os
+import pathlib
+import sys
+from typing import Any
+from .core import ExecutionContext, WorkflowReturnSignal
+
+class SubworkflowLoader:
+    """
+    Loads and executes other workflows as sub-routines.
+    This is the core engine for V3's modular architecture.
+    """
+    def __init__(self, execution_root: pathlib.Path | str = "workflows"):
+        root = pathlib.Path(execution_root)
+        if root.name == "workflows":
+            self.execution_root = root.parent if root.parent != pathlib.Path("") else pathlib.Path.cwd()
+            self.workflows_dir = root
+        else:
+            self.execution_root = root
+            self.workflows_dir = root / "workflows"
+        self._cache = {}
+        self._call_stack: list[str] = []
+
+    async def execute(self, workflow_id: str, parent_ctx: ExecutionContext, input_value: Any) -> Any:
+        """
+        Executes a subworkflow by ID.
+        
+        Args:
+            workflow_id: The ID/filename of the subworkflow (w/o extension).
+            parent_ctx: The context of the caller (used to inherit config/secrets).
+            input_value: Value to pass to the child workflow trigger payload.
+            
+        Returns:
+            Value returned by the child workflow's Return node, or None.
+        """
+        if workflow_id in self._call_stack:
+            raise ValueError(
+                f"Circular subworkflow reference detected: {workflow_id} in stack {self._call_stack}"
+            )
+
+        self._call_stack.append(workflow_id)
+        try:
+            module = self._load_module(workflow_id)
+
+            child_payload = self._normalize_input_payload(input_value)
+
+            child_ctx = ExecutionContext(
+                workflow_id=workflow_id,
+                execution_id=parent_ctx.execution_id,
+                inputs=child_payload,
+                secrets=parent_ctx._secrets,
+                state_manager=parent_ctx._state,
+            )
+            child_ctx._is_subworkflow = True
+
+            if not hasattr(module, "run"):
+                raise ValueError(
+                    f"Subworkflow {workflow_id} does not export 'run(ctx, injected_payload=None)'"
+                )
+
+            try:
+                return await module.run(child_ctx, injected_payload=child_payload)
+            except WorkflowReturnSignal as signal:
+                return signal.value
+        finally:
+            self._call_stack.pop()
+
+    def _normalize_input_payload(self, input_value: Any) -> dict[str, Any]:
+        if isinstance(input_value, dict):
+            envelope_keys = {"body", "headers", "query", "path", "method"}
+            if "body" in input_value and envelope_keys.issubset(input_value.keys()):
+                return {
+                    "body": input_value.get("body"),
+                    "headers": input_value.get("headers") or {},
+                    "query": input_value.get("query") or {},
+                    "path": input_value.get("path") or "",
+                    "method": input_value.get("method") or "INTERNAL",
+                }
+
+        return {
+            "body": input_value,
+            "headers": {},
+            "query": {},
+            "path": "",
+            "method": "INTERNAL",
+        }
+
+    def _load_module(self, workflow_id: str):
+        """Dynamic import of the generated python file."""
+        if workflow_id in self._cache:
+            return self._cache[workflow_id]
+            
+        # Security Check: Prevent directory traversal
+        if ".." in workflow_id or "/" in workflow_id or "\\" in workflow_id:
+             raise ValueError(f"Invalid workflow ID: {workflow_id}")
+
+        file_path = os.path.join(str(self.workflows_dir), f"{workflow_id}.py")
+        
+        if not os.path.exists(file_path):
+             # Try resolving absolute path if provided dir was relative
+             abs_path = os.path.abspath(file_path)
+             if not os.path.exists(abs_path):
+                 raise FileNotFoundError(f"Subworkflow file not found: {file_path}")
+             file_path = abs_path
+
+        spec = importlib.util.spec_from_file_location(f"subflow_{workflow_id}", file_path)
+        if spec is None or spec.loader is None:
+             raise ImportError(f"Could not load spec for {workflow_id}")
+             
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[f"subflow_{workflow_id}"] = module
+        spec.loader.exec_module(module)
+        
+        self._cache[workflow_id] = module
+        return module

tensorify_runtime-0.1.0/src/tensorify_runtime.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: tensorify-runtime
+Version: 0.1.0
+Summary: Runtime engine for Tensorify workflows (Universal Code Editor)
+Author-email: Tensorify Team <dev@tensorify.io>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Requires-Dist: RestrictedPython>=6.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: redis>=5.0
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"

tensorify_runtime-0.1.0/src/tensorify_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+MANIFEST.in
+pyproject.toml
+src/tensorify/plugins/discord_send.py
+src/tensorify/plugins/discord_trigger.py
+src/tensorify/plugins/file_writer.py
+src/tensorify/plugins/http_request.py
+src/tensorify/plugins/http_response.py
+src/tensorify/plugins/json_transform.py
+src/tensorify/plugins/python_script.py
+src/tensorify/plugins/telegram_send.py
+src/tensorify/plugins/telegram_trigger.py
+src/tensorify/runtime/__init__.py
+src/tensorify/runtime/core.py
+src/tensorify/runtime/expression.py
+src/tensorify/runtime/state.py
+src/tensorify/runtime/subworkflow.py
+src/tensorify_runtime.egg-info/PKG-INFO
+src/tensorify_runtime.egg-info/SOURCES.txt
+src/tensorify_runtime.egg-info/dependency_links.txt
+src/tensorify_runtime.egg-info/requires.txt
+src/tensorify_runtime.egg-info/top_level.txt

tensorify_runtime-0.1.0/src/tensorify_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tensorify_runtime-0.1.0/src/tensorify_runtime.egg-info/requires.txt

@@ -0,0 +1,9 @@
+RestrictedPython>=6.0
+pydantic>=2.0
+redis>=5.0
+aiohttp>=3.9
+
+[dev]
+pytest
+black
+mypy

tensorify_runtime-0.1.0/src/tensorify_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+tensorify