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

writer/blocks/crontrigger.py

@@ -0,0 +1,49 @@
+from writer.abstract import register_abstract_template
+from writer.blocks.base_trigger import BlueprintTrigger
+from writer.ss_types import AbstractTemplate
+
+
+class CronTrigger(BlueprintTrigger):
+    @classmethod
+    def register(cls, type: str):
+        super(CronTrigger, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Cron Trigger",
+                    "description": "Triggers an event on a schedule based on a cron expression.",
+                    "category": "Triggers",
+                    "featureFlags": ["cron_trigger"],
+                    "fields": {
+                        "cronExpression": {
+                            "name": "Cron Expression",
+                            "type": "Text",
+                            "desc": "The cron expression that defines the schedule (e.g., '0 * * * *' for every hour).",
+                        },
+                        "timezone": {
+                            "name": "Timezone",
+                            "type": "Text",
+                            "desc": "The timezone for the cron schedule (e.g., 'UTC', 'America/New_York'). Defaults to UTC.",
+                            "default": "UTC",
+                        },
+                        "defaultResult": {
+                            "name": "Default result",
+                            "type": "Code",
+                            "desc": 'The result that is used when the blueprint is triggered from the "Run blueprint" button',
+                        },
+                    },
+                    "outs": {
+                        "trigger": {
+                            "name": "Trigger",
+                            "style": "success",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        super().run()
+        self.outcome = "trigger"

writer/blocks/foreach.py

@@ -1,75 +1,92 @@
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import BlueprintBlock
 from writer.ss_types import AbstractTemplate
 
 
-class ForEach(WorkflowBlock):
-
+class ForEach(BlueprintBlock):
     @classmethod
     def register(cls, type: str):
         super(ForEach, cls).register(type)
-        register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
-            writer={
-                "name": "For-each loop",
-                "description": "Executes a workflow repeatedly, based on the items provided.",
-                "category": "Logic",
-                "fields": {
-                    "workflowKey": {
-                        "name": "Workflow key",
-                        "desc": "The workflow which will be executed for each item.",
-                        "type": "Text",
-                    },
-                    "items": {
-                        "name": "Items",
-                        "desc": "The item value will be passed in the execution environment and will be available at @{payload.item}, its id at @{payload.itemId}.",
-                        "default": "{}",
-                        "init": '{ "fr": "France", "pl": "Poland" }',
-                        "type": "Object",
-                        "control": "Textarea"
-                    }
-                },
-                "outs": {
-                    "success": {
-                        "name": "Success",
-                        "description": "The workflow executed successfully.",
-                        "style": "success",
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "For-each loop",
+                    "description": "Loops through each item in a list to run the same logic.",
+                    "category": "Logic",
+                    "fields": {
+                        "items": {
+                            "name": "Items",
+                            "desc": "The item value will be passed in the execution environment. It will be available at @{item}, and its ID at @{itemId}. You can use either a list or a dictionary.",
+                            "default": "[]",
+                            "init": '["France", "Poland"]',
+                            "type": "Object",
+                            "control": "Textarea",
+                        },
+                        "prefix": {
+                            "name": "Prefix",
+                            "type": "Text",
+                            "desc": "If set, the item will be available at @{prefix_item} and the item id at @{prefix_itemId}.",
+                        },
                     },
-                    "error": {
-                        "name": "Error",
-                        "description": "The workflow wasn't executed successfully.",
-                        "style": "error",
+                    "outs": {
+                        "loop": {
+                            "name": "Loop",
+                            "description": "Connect the branch that you'd like to loop on. The branch plugged in here will be executed once per item.",
+                            "style": "dynamic",
+                        },
+                        "success": {
+                            "name": "Success",
+                            "description": "The branch referenced executed successfully for each item.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "The branch referenced has failed for at least one of the items.",
+                            "style": "error",
+                        },
                     },
                 },
-            }
-        ))
-
-    def _run_workflow_for_item(self, workflow_key, base_execution_environment, item_id, item):
-        expanded_execution_environment = base_execution_environment | { 
-            "payload": {
-                "itemId": item_id,
-                "item": item
-            }
-        }
-        return self.runner.run_workflow_by_key(workflow_key, expanded_execution_environment)
+            ),
+        )
 
     def run(self):
         try:
-            workflow_key = self._get_field("workflowKey")
             items = self._get_field("items", as_json=True)
+            prefix = str(self._get_field("prefix", as_json=False, default_field_value="")).strip()
+            if prefix:
+                prefix += "_"
             base_execution_environment = self.execution_environment
 
-            std_items = items
-            result = None
+            if not isinstance(items, (list, dict)):
+                raise ValueError("Items must be a list or dictionary.")
+
             if isinstance(items, list):
-                std_items = enumerate(std_items, 0)
-                result = [self._run_workflow_for_item(workflow_key, base_execution_environment, item_id, item) for item_id, item in std_items]
+                blueprint_environments = [
+                    base_execution_environment | {f"{prefix}itemId": i, f"{prefix}item": item}
+                    for i, item in enumerate(items)
+                ]
+
+                results = self.runner.run_branch_batch(
+                    self.component.id, "loop", blueprint_environments
+                )
+                self.result = results  # Return as a list
+
             elif isinstance(items, dict):
-                std_items = items.items()
-                result = {item_id:self._run_workflow_for_item(workflow_key, base_execution_environment, item_id, item) for item_id, item in std_items}
+                blueprint_environments = {
+                    str(item_id): base_execution_environment
+                    | {f"{prefix}itemId": str(item_id), f"{prefix}item": item}
+                    for item_id, item in items.items()
+                }
+                results = self.runner.run_branch_batch(
+                    self.component.id, "loop", list(blueprint_environments.values())
+                )
+                self.result = {
+                    item_id: results[i] for i, item_id in enumerate(blueprint_environments.keys())
+                }
 
-            self.result = result
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
-            raise e
+            raise e

writer/blocks/httprequest.py

@@ -1,123 +1,136 @@
-import re
-
-import requests
+import json
 
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import BlueprintBlock
 from writer.ss_types import AbstractTemplate
 
 
-class HTTPRequest(WorkflowBlock):
-
-    CONTROL_CHARS = re.compile(r"[\x00-\x1f\x7f]")
-
+class HTTPRequest(BlueprintBlock):
     @classmethod
     def register(cls, type: str):
         super(HTTPRequest, cls).register(type)
-        register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
-            writer={
-                "name": "HTTP Request",
-                "description": "Executes an HTTP request.",
-                "category": "Other",
-                "fields": {
-                    "method": {
-                        "name": "Method",
-                        "type": "Text",
-                        "options": {
-                            "GET": "GET",
-                            "POST": "POST",
-                            "PUT": "PUT",
-                            "PATCH": "PATCH",
-                            "DELETE": "DELETE"
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "HTTP request",
+                    "description": "Sends an HTTP request to an API endpoint. Used to fetch or send data.",
+                    "category": "Other",
+                    "fields": {
+                        "method": {
+                            "name": "Method",
+                            "type": "Text",
+                            "options": {
+                                "GET": "GET",
+                                "POST": "POST",
+                                "PUT": "PUT",
+                                "PATCH": "PATCH",
+                                "DELETE": "DELETE",
+                            },
+                            "validator": {
+                                "type": "string",
+                                "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", ""],
+                            },
                         },
-                        "default": "GET",
-                        "validator": {
-                            "type": "string",
-                            "enum": ["GET", "POST", "PUT", "PATCH", "DELETE"],
-                        }
-                    },
-                    "url": {
-                        "name": "URL",
-                        "type": "Text",
-                        "validator": {
-                            "type": "string",
-                            "format": "uri",
-                        }
-                    },
-                    "headers": {
-                        "name": "Headers",
-                        "type": "Key-Value",
-                        "default": "{}",
-                        "validator": {
-                            "type": "object",
-                            "patternProperties": {
-                                "^.*$": {
-                                    "type": ["string", "number", "boolean"],
+                        "url": {
+                            "name": "URL",
+                            "type": "Text",
+                            "control": "Textarea",
+                        },
+                        "headers": {
+                            "name": "Headers",
+                            "type": "Key-Value",
+                            "default": "{}",
+                            "validator": {
+                                "type": "object",
+                                "patternProperties": {
+                                    "^.*$": {
+                                        "type": ["string", "number", "boolean"],
+                                    },
                                 },
+                                "additionalProperties": True,
                             },
-                            "additionalProperties": True,
-                        }
-                    },
-                    "body": {
-                        "name": "Body",
-                        "type": "Text",
-                        "control": "Textarea"
-                    },
-                },
-                "outs": {
-                    "success": {
-                        "name": "Success",
-                        "description": "The request was successful.",
-                        "style": "success",
-                    },
-                    "responseError": {
-                        "name": "Response error",
-                        "description": "The connection was established successfully but an error response code was received or the response was invalid.",
-                        "style": "error",
+                        },
+                        "bodyType": {
+                            "name": "Body type",
+                            "type": "Text",
+                            "description": "Specify whether to interpret the body as plain text or JSON.",
+                            "options": {
+                                "text": "Plain text",
+                                "JSON": "JSON",
+                            },
+                            "default": "text",
+                        },
+                        "body": {"name": "Body", "type": "Text", "control": "Textarea"},
                     },
-                    "connectionError": {
-                        "name": "Connection error",
-                        "description": "The connection couldn't be established.",
-                        "style": "error",
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The request was successful.",
+                            "style": "success",
+                        },
+                        "responseError": {
+                            "name": "Response error",
+                            "description": "The connection was established successfully but an error response code was received or the response was invalid.",
+                            "style": "error",
+                        },
+                        "connectionError": {
+                            "name": "Connection error",
+                            "description": "The connection couldn't be established.",
+                            "style": "error",
+                        },
                     },
                 },
-            }
-        ))
-
-    def _clean_json_string(self, s: str) -> str:
-
-        """ Remove control characters, which aren't tolerated by JSON loads() strict mode, from string."""
-
-        return HTTPRequest.CONTROL_CHARS.sub("", s)
+            ),
+        )
 
     def run(self):
-        import json
-
         try:
             method = self._get_field("method", False, "GET")
             url = self._get_field("url")
-            headers = self._get_field("headers", True)
-            body = self._clean_json_string(self._get_field("body"))
-            req = requests.request(method, url, headers=headers, data=body)
-            
-            content_type = req.headers.get("Content-Type")
-            is_json = content_type and "application/json" in content_type
-            
-            self.result = {
-                "headers": dict(req.headers),
-                "status_code": req.status_code,
-                "body": req.json() if is_json else req.text
-            }
-            if req.ok:
-                self.outcome = "success"
+            headers = self._get_field("headers", True, default_field_value="{}")
+            body_type = self._get_field("bodyType")
+            body = None
+            raw_body = None
+
+            if body_type == "JSON":
+                body = self._get_field("body", as_json=True)
+                raw_body = json.dumps(body)
+                headers.setdefault("Content-Type", "application/json")
             else:
-                self.outcome = "responseError"
-                raise RuntimeError("HTTP response with code " + str(req.status_code))
+                body = self._get_field("body", as_json=False)
+                raw_body = body
+
+            with self.acquire_httpx_client() as client:
+                res = client.request(method, url, headers=headers, content=raw_body, timeout=180)
+
+                content_type = res.headers.get("Content-Type", "")
+                is_response_json = "application/json" in content_type
+
+                self.result = {
+                    "request": {
+                        "url": str(res.request.url),
+                        "headers": dict(res.request.headers),
+                        "body": res.request.content.decode("utf-8", errors="replace"),
+                    },
+                    "headers": dict(res.headers),
+                    "status_code": res.status_code,
+                    "body": res.json() if is_response_json else res.text,
+                }
+
+                if res.is_success:
+                    self.outcome = "success"
+                else:
+                    self.outcome = "responseError"
+                    raise RuntimeError(
+                        f"HTTP response with code {res.status_code} and message {res.text}"
+                    )
+
         except json.JSONDecodeError as e:
             self.outcome = "responseError"
             raise e
-        except BaseException as e:
-            if not self.outcome:
+        except Exception as e:
+            if self.outcome is None or self.outcome not in ("responseError",):
                 self.outcome = "connectionError"
-            raise e
+            raise e

writer/blocks/ifelse.py

@@ -0,0 +1,71 @@
+import sys
+import traceback
+
+from writer.abstract import register_abstract_template
+from writer.blocks.base_block import BlueprintBlock
+from writer.ss_types import AbstractTemplate
+
+
+class IfElseBlock(BlueprintBlock):
+    @classmethod
+    def register(cls, type: str):
+        super(IfElseBlock, cls).register(type)
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "If-Else",
+                    "description": "Evaluate custom Python code and redirect to 'true' or 'false' branch. Useful for conditional logic.",
+                    "category": "Logic",
+                    "fields": {
+                        "expression": {
+                            "name": "Expression",
+                            "type": "Eval",
+                            "desc": "The expression to be evaluated. Must be a single expression (no statements).",
+                            "init": 'state["counter"] > 10',
+                        },
+                    },
+                    "outs": {
+                        "true": {
+                            "name": "True",
+                            "description": "The event handler execution for True.",
+                            "style": "success",
+                        },
+                        "false": {
+                            "name": "False",
+                            "description": "The event handler execution for False.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "The expression evaluation failed.",
+                            "style": "error",
+                        },
+                    },
+                },
+            ),
+        )
+
+    def run(self):
+        expression = self._get_field("expression")
+
+        try:
+            writeruserapp = sys.modules.get("writeruserapp")
+            block_globals = {
+                **self.execution_environment,
+                **(writeruserapp.__dict__ if writeruserapp else {}),
+                "state": self.runner.session.session_state,
+            }
+            # Evaluate the expression and set the result
+            compiled_expr = compile(expression, "<expression>", mode="eval")
+            self.result = eval(compiled_expr, block_globals)
+
+            if self.result:
+                self.outcome = "true"
+            else:
+                self.outcome = "false"
+        except BaseException:
+            self.outcome = "error"
+            self.message = f"<pre>{traceback.format_exc()}</pre>"
+            raise

writer/blocks/logmessage.py

@@ -1,58 +1,53 @@
 from writer.abstract import register_abstract_template
-from writer.blocks.base_block import WorkflowBlock
+from writer.blocks.base_block import BlueprintBlock
 from writer.ss_types import AbstractTemplate
 
 
-class LogMessage(WorkflowBlock):
-
+class LogMessage(BlueprintBlock):
     @classmethod
     def register(cls, type: str):
         super(LogMessage, cls).register(type)
-        register_abstract_template(type, AbstractTemplate(
-            baseType="workflows_node",
-            writer={
-                "name": "Log message",
-                "description": "Appends a message to the log.",
-                "category": "Other",
-                "fields": {
-                    "type": {
-                        "name": "Type",
-                        "type": "Text",
-                        "options": {
-                            "info": "Info",
-                            "error": "Error"
+        register_abstract_template(
+            type,
+            AbstractTemplate(
+                baseType="blueprints_node",
+                writer={
+                    "name": "Log message",
+                    "description": "Prints a message to the console for debugging or monitoring app flow.",
+                    "category": "Other",
+                    "fields": {
+                        "type": {
+                            "name": "Type",
+                            "type": "Text",
+                            "options": {"info": "Info", "error": "Error"},
+                            "default": "info",
                         },
-                        "default": "info"
-                    },
-                    "message": {
-                        "name": "Message",
-                        "type": "Text",
-                        "control": "Textarea"
-                    },
-                },
-                "outs": {
-                    "success": {
-                        "name": "Success",
-                        "description": "The request was successful.",
-                        "style": "success",
+                        "message": {"name": "Message", "type": "Text", "control": "Textarea"},
                     },
-                    "error": {
-                        "name": "Error",
-                        "description": "The workflow was executed successfully.",
-                        "style": "error",
+                    "outs": {
+                        "success": {
+                            "name": "Success",
+                            "description": "The message was logged successfully.",
+                            "style": "success",
+                        },
+                        "error": {
+                            "name": "Error",
+                            "description": "There was an error logging the message.",
+                            "style": "error",
+                        },
                     },
                 },
-            }
-        ))
+            ),
+        )
 
     def run(self):
         try:
             type = self._get_field("type", False, "info")
-            message = self._get_field("message", required=True)
+            message = str(self._get_field("message", required=True))
 
-            self.runner.session.session_state.add_log_entry(type, "Workflows message", message)
-            self.result = None
+            self.runner.session.session_state.add_log_entry(type, "Blueprints message", message)
+            self.result = message
             self.outcome = "success"
         except BaseException as e:
             self.outcome = "error"
-            raise e
+            raise e