writer 0.8.3rc4__py3-none-any.whl → 1.25.1rc1__py3-none-any.whl

writer/core_ui.py

@@ -447,7 +447,7 @@ def export_component_tree(component_tree: ComponentTree, mode: ServeMode, only_u
 
     >>> filtered_component_tree = core_ui.export_component_tree(session.session_component_tree, mode=writer.Config.mode)
 
-    This function filters artifacts that should be hidden from the user, for example workflows in run mode.
+    This function filters artifacts that should be hidden from the user, for example blueprints in run mode.
 
     :param component_tree: the full component tree
     :param mode: the mode of the application (edit, run)
@@ -459,7 +459,7 @@ def export_component_tree(component_tree: ComponentTree, mode: ServeMode, only_u
 
     roots = ['root']
     if mode == "edit":
-        roots.append('workflows_root')
+        roots.append('blueprints_root')
 
     _components: List[Component] = []
     for root in roots:
@@ -467,6 +467,10 @@ def export_component_tree(component_tree: ComponentTree, mode: ServeMode, only_u
         _components.append(_root_component)
         _components += component_tree.get_descendents(root)
 
+    # filters notes in run mode
+    if mode == "run":
+        _components = [c for c in _components if c.type != "note"]
+
     return {c.id: c.to_dict() for c in _components}
 
 class UIError(Exception):

writer/evaluator.py

@@ -16,33 +16,38 @@ if TYPE_CHECKING:
 
 
 class Evaluator:
-
     """
     Evaluates templates and expressions in the backend.
     It allows for the sanitisation of frontend inputs.
     """
 
     TEMPLATE_REGEX = re.compile(r"[\\]?@{([^{]*?)}")
+    CONTROL_CHARS = re.compile(r"[\x00-\x1f\x7f]")
 
     def __init__(self, state: "WriterState", component_tree: "ComponentTree"):
         self.state = state
         self.component_tree = component_tree
         self.serializer = writer.core.StateSerialiser()
 
-    def evaluate_field(self, instance_path: InstancePath, field_key: str, as_json=False, default_field_value="", base_context={}) -> Any:
+    def evaluate_field(
+        self,
+        instance_path: InstancePath,
+        field_key: str,
+        as_json=False,
+        default_field_value="",
+        base_context={},
+    ) -> Any:
         def decode_json(text):
+            if not isinstance(text, str):
+                return text
             try:
-                return json.loads(text, strict=False)
+                # Remove control chars
+                clean_text = Evaluator.CONTROL_CHARS.sub("", text)
+                return json.loads(clean_text, strict=False)
             except json.JSONDecodeError as exception:
-                raise WriterConfigurationError("Error decoding JSON. " + str(exception)) from exception
-
-        def replacer(matched):
-            if matched.string[0] == "\\":  # Escaped @, don't evaluate
-                return matched.string
-            expr = matched.group(1).strip()
-            expr_value = self.evaluate_expression(expr, instance_path, base_context)
-
-            return expr_value
+                raise WriterConfigurationError(
+                    "Error decoding JSON. " + str(exception)
+                ) from exception
 
         component_id = instance_path[-1]["componentId"]
         component = self.component_tree.get_component(component_id)
@@ -50,21 +55,35 @@ class Evaluator:
             raise ValueError(f'Component with id "{component_id}" not found.')
 
         field_value = component.content.get(field_key) or default_field_value
-        replaced = None
         full_match = self.TEMPLATE_REGEX.fullmatch(field_value)
 
-        if full_match is None:
-            replaced = self.TEMPLATE_REGEX.sub(lambda m: str(replacer(m)), field_value)
+        def replacer(matched: re.Match):
+            if matched.group(0)[0] == "\\":  # Escaped @, don't evaluate
+                return matched.group(0)
+            expr = matched.group(1).strip()
+            expr_value = self.evaluate_expression(expr, instance_path, base_context)
+            if full_match is not None:
+                return expr_value
             if as_json:
-                replaced = decode_json(replaced)
+                dumped = expr_value
+                if not isinstance(dumped, str):
+                    dumped = json.dumps(dumped)
+                else:
+                    dumped = json.dumps(dumped)[1:-1]
+                return re.sub(r'(?<!\\)"', r'\"', dumped)
+            if not isinstance(expr_value, str):
+                return json.dumps(expr_value)
+            return expr_value
+
+        if full_match is None:
+            replaced = self.TEMPLATE_REGEX.sub(replacer, field_value)
         else:
             replaced = replacer(full_match)
-            if as_json and isinstance(replaced, str):
-                replaced = decode_json(replaced)
+        if as_json:
+            replaced = decode_json(replaced)
 
         return replaced
 
-
     def get_context_data(self, instance_path: InstancePath, base_context={}) -> Dict[str, Any]:
         context: Dict[str, Any] = base_context
         for i in range(len(instance_path)):
@@ -77,15 +96,21 @@ class Evaluator:
                 continue
             if i + 1 >= len(instance_path):
                 continue
-            repeater_instance_path = instance_path[0:i+1]
-            next_instance_path = instance_path[0:i+2]
+            repeater_instance_path = instance_path[0 : i + 1]
+            next_instance_path = instance_path[0 : i + 2]
             instance_number = next_instance_path[-1]["instanceNumber"]
             repeater_object = self.evaluate_field(
-                repeater_instance_path, "repeaterObject", True, """{ "a": { "desc": "Option A" }, "b": { "desc": "Option B" } }""")
+                repeater_instance_path,
+                "repeaterObject",
+                True,
+                """{ "a": { "desc": "Option A" }, "b": { "desc": "Option B" } }""",
+            )
             key_variable = self.evaluate_field(
-                repeater_instance_path, "keyVariable", False, "itemId")
+                repeater_instance_path, "keyVariable", False, "itemId"
+            )
             value_variable = self.evaluate_field(
-                repeater_instance_path, "valueVariable", False, "item")
+                repeater_instance_path, "valueVariable", False, "item"
+            )
 
             repeater_items: List[Tuple[Any, Any]] = []
             if isinstance(repeater_object, dict):
@@ -94,17 +119,20 @@ class Evaluator:
                 repeater_items = list(enumerate(repeater_object))
             else:
                 raise ValueError(
-                    "Cannot produce context. Repeater object must evaluate to a dictionary.")
+                    "Cannot produce context. Repeater object must evaluate to a dictionary."
+                )
 
             context[key_variable] = repeater_items[instance_number][0]
             context[value_variable] = repeater_items[instance_number][1]
 
         if len(instance_path) > 0:
-            context['target'] = instance_path[-1]['componentId']
+            context["target"] = instance_path[-1]["componentId"]
 
         return context
 
-    def set_state(self, expr: str, instance_path: InstancePath, value: Any, base_context = {}) -> None:
+    def set_state(
+        self, expr: str, instance_path: InstancePath, value: Any, base_context={}
+    ) -> None:
         accessors = self.parse_expression(expr, instance_path, base_context)
         state_ref = self.state
 
@@ -114,18 +142,24 @@ class Evaluator:
             else:
                 state_ref = state_ref[accessor]
 
-        if not isinstance(state_ref, (writer.core.State, writer.core.WriterState, writer.core.StateProxy, dict)):
+        if not isinstance(
+            state_ref, (writer.core.State, writer.core.WriterState, writer.core.StateProxy, dict)
+        ):
             raise ValueError(
-                f'Reference "{expr}" cannot be translated to state. Found value of type "{type(state_ref)}".')
+                f'Reference "{expr}" cannot be translated to state. Found value of type "{type(state_ref)}".'
+            )
 
-        state_ref[accessors[-1]] = value        
+        state_ref[accessors[-1]] = value
 
-    def parse_expression(self, expr: str, instance_path: Optional[InstancePath] = None, base_context = {}) -> List[str]:
-
-        """ Returns a list of accessors from an expression. """
+    def parse_expression(
+        self, expr: str, instance_path: Optional[InstancePath] = None, base_context={}
+    ) -> List[str]:
+        """Returns a list of accessors from an expression."""
 
         if not isinstance(expr, str):
-            raise ValueError(f'Expression must be of type string. Value of type "{ type(expr) }" found.')
+            raise ValueError(
+                f'Expression must be of type string. Value of type "{ type(expr) }" found.'
+            )
 
         accessors: List[str] = []
         s = ""
@@ -170,7 +204,9 @@ class Evaluator:
     def get_env_variable_value(self, expr: str):
         return os.getenv(expr[1:])
 
-    def evaluate_expression(self, expr: str, instance_path: Optional[InstancePath] = None, base_context = {}) -> Any:
+    def evaluate_expression(
+        self, expr: str, instance_path: Optional[InstancePath] = None, base_context={}
+    ) -> Any:
         context_data = base_context
         result = None
         if instance_path:
@@ -179,16 +215,7 @@ class Evaluator:
         state_ref: Any = self.state.user_state
         accessors: List[str] = self.parse_expression(expr, instance_path, base_context)
 
-        for accessor in accessors:
-            if isinstance(state_ref, (writer.core.StateProxy, dict)) and accessor in state_ref:
-                state_ref = state_ref.get(accessor)
-                result = state_ref
-            elif isinstance(state_ref, (list)) and state_ref[int(accessor)] is not None:
-                state_ref = state_ref[int(accessor)]
-                result = state_ref
-            elif isinstance(context_ref, dict) and accessor in context_ref:
-                context_ref = context_ref.get(accessor)
-                result = context_ref
+        result = self._apply_accessors(accessors, state_ref, context_ref)
 
         if isinstance(result, writer.core.StateProxy):
             return result.to_dict()
@@ -196,4 +223,29 @@ class Evaluator:
         if result is None and expr.startswith("$"):
             return self.get_env_variable_value(expr)
 
-        return result
+        return result
+
+    def _apply_accessors(self, accessors: List[str], state_ref: Any, context_ref: Any = None) -> Any:
+        if not accessors:
+            return state_ref
+        
+        result = self._apply_accessor(accessors[0], context_ref)
+        if result is None:
+            result = self._apply_accessor(accessors[0], state_ref)
+
+        for accessor in accessors[1:]:
+            result = self._apply_accessor(accessor, result)
+
+        return result
+
+    def _apply_accessor(self, accessor: str, target: Any) -> Any:
+        if isinstance(target, (writer.core.StateProxy, dict)):
+            return target.get(accessor)
+        
+        if isinstance(target, list):
+            try:
+                return target[int(accessor)]
+            except IndexError:
+                pass
+        
+        return None

writer/journal.py

@@ -0,0 +1,227 @@
+import contextlib
+import json
+import logging
+from contextvars import ContextVar
+from copy import deepcopy
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional
+
+import writer.abstract
+from writer.core import Config
+from writer.keyvalue_storage import writer_kv_storage
+
+if TYPE_CHECKING:
+    from writer.blueprints import Graph, GraphNode
+    from writer.core import Component
+
+
+logger = logging.getLogger("journal")
+
+JOURNAL_KEY_PREFIX = "wf-journal-"
+INIT_LOGS_KEY_PREFIX = "wf-init-logs-"
+
+class JournalRecord:
+    def __init__(
+        self,
+        execution_environment: Dict,
+        title: str,
+        graph: "Graph"
+    ):
+        from writer import core_ui
+
+        self.started_at = datetime.now(timezone.utc)
+        self.instance_type = "editor" if Config.mode == "edit" else "agent"
+
+        # Get blueprint_id from the parent of any node in the graph
+        # All nodes in a blueprint share the same parent blueprint component
+        self.blueprint_id = graph.nodes[0].component.parentId if graph.nodes else None
+
+        self.execution_environment = execution_environment
+        self.trigger = {
+            "event": execution_environment.get("context", {}).get("event"),
+            "payload": execution_environment.get("payload"),
+            "component": {}
+        }
+
+        if self.trigger["event"] == "wf-run-blueprint":
+            self.trigger["component"]["type"] = "blueprint"
+            self.trigger["component"]["id"] = self.blueprint_id
+            blueprint_component = core_ui.current_component_tree().get_component(self.trigger["component"]["id"])
+            if blueprint_component is not None:
+                self.trigger["component"]["title"] = blueprint_component.content.get("key")
+        else:
+            self.trigger["component"]["type"] = "block"
+            component = graph.get_start_nodes()[0].component
+            self.trigger["component"]["id"] = component.id
+            self.trigger["component"]["title"] = self._get_block_info(component)["title"]
+
+        if "API" in title:
+            self.trigger["type"] = "API"
+        elif "Cron" in title:
+            self.trigger["type"] = "Cron"
+        elif "UI" in title:
+            self.trigger["type"] = "UI"
+        else:
+            self.trigger["type"] = "On demand"
+
+        self.graph = graph
+        self.block_outputs: Dict[str, Any] = {}
+        for graph_node in self.graph.nodes:
+            block_info = self._get_block_info(graph_node.component)
+            self.block_outputs[graph_node.id] = {
+                "component": {
+                    "type": graph_node.component.type,
+                    "id": graph_node.component.id,
+                    "title": block_info["title"],
+                    "category": block_info["category"]
+                },
+                "executions": []
+            }
+
+        self.is_runable = True
+        self.result: Optional[Literal["success", "error", "stopped"]] = None
+
+    def _get_block_info(self, component: "Component") -> Dict[str, str]:
+        block_title = component.content.get("alias")
+        component_definition = writer.abstract.templates.get(component.type)
+
+        # If component has an alias, use it as title
+        if block_title is not None:
+            category = "Unknown category"
+            if component_definition is not None:
+                category = component_definition.writer.get("category", "Unknown category")
+            return {
+                "title": block_title,
+                "category": category
+            }
+
+        # If no component definition found, return defaults
+        if component_definition is None:
+            return {
+                "title": "Unknown block",
+                "category": "Unknown category"
+            }
+
+        # Use component definition for both title and category
+        return {
+            "title": component_definition.writer.get("name", "Unknown block"),
+            "category": component_definition.writer.get("category", "Unknown category")
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        block_outputs = deepcopy(self.block_outputs)
+        for graph_node in self.graph.nodes:
+            block_outputs[graph_node.id]["executions"].append(self.get_execution_data(graph_node))
+
+        data = {
+            "timestamp": self.started_at.isoformat(),
+            "instanceType": self.instance_type,
+            "blueprintId": self.blueprint_id,
+            "trigger": self.trigger,
+            "blockOutputs": block_outputs,
+            "result": self.result,
+        }
+        sanitized_data = self._sanitize_data(data)
+        return {
+            **sanitized_data,
+            "isRunable": self.is_runable,
+        }
+
+    def get_execution_data(self, graph_node: "GraphNode") -> Dict[str, Any]:
+        execution_data: Dict[str, Any] = {
+            "result": graph_node.result,
+            "outcome": graph_node.outcome,
+        }
+
+        # Add timing information if available
+        if graph_node.tool:
+            if hasattr(graph_node.tool, 'started_at') and graph_node.tool.started_at >= 0:
+                execution_data["startedAt"] = graph_node.tool.started_at
+            if hasattr(graph_node.tool, 'execution_time_in_seconds') and graph_node.tool.execution_time_in_seconds >= 0:
+                execution_data["executionTimeInSeconds"] = graph_node.tool.execution_time_in_seconds
+
+            # Add captured logs if available
+            if hasattr(graph_node.tool, 'captured_stdout') and graph_node.tool.captured_stdout:
+                execution_data["stdout"] = graph_node.tool.captured_stdout
+            if hasattr(graph_node.tool, 'captured_logs') and graph_node.tool.captured_logs:
+                execution_data["logs"] = graph_node.tool.captured_logs
+
+            # Add error message if available (contains the traceback for errors)
+            if hasattr(graph_node.tool, 'message') and graph_node.tool.message:
+                execution_data["message"] = graph_node.tool.message
+
+        return execution_data
+
+    def _sanitize_data(self, data):
+        if data is None:
+            return None
+
+        if isinstance(data, list):
+            return [self._sanitize_data(item) for item in data]
+        if isinstance(data, dict):
+            return {
+                k: self._sanitize_data(v)
+                for k, v in data.items()
+            }
+        if isinstance(data, (str, int, float, bool, type(None))):
+            return data
+
+        try:
+            return json.loads(json.dumps(data))
+        except (TypeError, OverflowError):
+            self.is_runable = False
+            return f"Can't be displayed in the Journal. Value of type: {str(type(data))}."
+
+    def construct_key(self) -> str:
+        return f"{JOURNAL_KEY_PREFIX}{self.instance_type[0]}-{int(self.started_at.timestamp() * 1000)}"
+    
+    def set_result(self, result: Literal["success", "error", "stopped"]) -> None:
+        self.result = result
+
+    def add_nested_execution(self, nested_record: "JournalRecord") -> None:
+        for graph_node in nested_record.graph.nodes:
+            if graph_node.id not in self.block_outputs:
+                self.block_outputs[graph_node.id] = nested_record.block_outputs[graph_node.id]
+            self.block_outputs[graph_node.id]["executions"].append(nested_record.get_execution_data(graph_node))
+    
+    def save(self) -> None:
+        if "journal" not in Config.feature_flags or not writer_kv_storage.is_accessible():
+            return
+        data = self.to_dict()
+        writer_kv_storage.save(self.construct_key(), data)
+
+
+_parent_journal_record: ContextVar[Optional[JournalRecord]] = ContextVar("parent_journal_record", default=None)
+_current_journal_record: ContextVar[Optional[JournalRecord]] = ContextVar("current_journal_record", default=None)
+
+@contextlib.contextmanager
+def use_journal_record_context(
+    execution_environment: Dict,
+    title: str,
+    graph: "Graph"
+):
+    parent_record = _parent_journal_record.get()
+    current_record = JournalRecord(execution_environment, title, graph)
+    _current_journal_record.set(current_record)
+    if parent_record is None:
+        _parent_journal_record.set(current_record)
+
+    try:
+        yield current_record
+    except BaseException as e:
+        current_record.set_result("error")
+        raise e
+    finally:
+        _current_journal_record.set(None)
+        if parent_record is not None:
+            parent_record.add_nested_execution(current_record)
+        else:
+            try:
+                current_record.save()
+            except Exception:
+                logger.exception("Failed to save a Journal entry")
+            _parent_journal_record.set(None)
+
+
+def get_current_journal_record() -> Optional[JournalRecord]:
+    return _current_journal_record.get()

writer/keyvalue_storage.py

@@ -0,0 +1,93 @@
+import logging
+import os
+from functools import partial
+from typing import Any, Dict, List, Literal, Optional, Protocol
+
+import httpx
+
+logger = logging.getLogger("kv_storage")
+
+
+class _WrappedRequestFunc(Protocol):
+    def __call__(
+        self,
+        headers: Dict[str, str],
+        timeout: int,
+    ) -> httpx.Response: ...
+
+
+class KeyValueStorage:
+    def __init__(self, client: Optional[httpx.Client] = None) -> None:
+        base_url = os.getenv("WRITER_BASE_URL")
+        self.api_key = os.getenv("WRITER_API_KEY")
+        if None in (base_url, self.api_key):
+            logger.warning("Missing required environment variables for KV storage access")
+        self.api_url = f"{base_url}/v1" if base_url else None
+
+        self._client = client if client is not None else httpx
+
+    def _get_agent_ids(self):
+        from writer.core import get_session
+        current_session = get_session()
+
+        if current_session:
+            headers = current_session.headers or {}
+            agent_id = headers.get("x-agent-id") or os.getenv("WRITER_APP_ID")
+            org_id = headers.get("x-organization-id") or os.getenv("WRITER_ORG_ID")
+            return (agent_id, org_id)
+
+        agent_id = os.getenv("WRITER_APP_ID")
+        org_id = os.getenv("WRITER_ORG_ID")
+        return (agent_id, org_id)
+
+    def get(self, key: str, type_: Literal["data", "secret"]) -> Dict[str, Any]:
+        return self._request(partial(self._client.get, url=f"{self.api_url}/agent_{type_}/{key}")).json()
+
+    def get_data_keys(self) -> List[str]:
+        return self._request(partial(self._client.get, url=f"{self.api_url}/agent_data")).json()["keys"]
+    
+    def save(self, key: str, data: Any) -> Dict[str, Any]:
+        try:
+            return self._create(key, data).json()
+        except httpx.HTTPStatusError as e:
+            if "already exists" in e.response.text:
+                return self._update(key, data).json()
+            raise e
+
+    def _create(self, key: str, data: Any) -> httpx.Response:
+        return self._request(partial(self._client.post, url=f"{self.api_url}/agent_data", json={"key": key, "data": data}))
+
+    def _update(self, key: str, data: Any) -> httpx.Response:
+        return self._request(partial(self._client.put, url=f"{self.api_url}/agent_data/{key}", json={"data": data}))
+
+    def delete(self, key: str) -> Dict[str, str]:
+        self._request(partial(self._client.delete, url=f"{self.api_url}/agent_data/{key}"))
+        return {"key": key}
+
+    def _request(self, request_func: _WrappedRequestFunc) -> httpx.Response:
+
+        agent_id, org_id = self._get_agent_ids()
+        if None in (agent_id, org_id):
+            raise ValueError("Can't access KV storage. Missing agent id or org id")
+
+        if None in (self.api_key, self.api_url):
+            raise ValueError("Can't access KV storage. Missing required env vars")
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "X-Organization-Id": org_id,
+            "X-Agent-Id": agent_id,
+        }
+
+        response = request_func(headers=headers, timeout=3)
+        response.raise_for_status()
+        return response
+
+    def is_accessible(self) -> bool:
+        if None in self._get_agent_ids():
+            return False
+        if None in (self.api_key, self.api_url):
+            return False
+        return True
+
+writer_kv_storage = KeyValueStorage()