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

writer/command_line.py

@@ -7,6 +7,7 @@ import click
 import writer.serve
 from writer import VERSION, wf_project
 from writer.deploy import cloud, deploy
+from writer.sync import FileBuffering
 
 CONTEXT_SETTINGS = {'help_option_names': ['-h', '--help']}
 @click.group(
@@ -20,9 +21,8 @@ def main():
 @main.command()
 @click.option('--host', default="127.0.0.1", help="Host to run the app on")
 @click.option('--port', default=None, help="Port to run the app on")
-@click.option("--enable-jobs-api", help="Set this flag to enable the Jobs API, allowing you to execute jobs without user interaction.", is_flag=True)
 @click.argument('path')
-def run(path: str, host: str, port: Optional[int], enable_jobs_api: bool):
+def run(path: str, host: str, port: Optional[int]):
     """Run the app from PATH folder in run mode."""
 
     abs_path = os.path.abspath(path)
@@ -35,15 +35,23 @@ def run(path: str, host: str, port: Optional[int], enable_jobs_api: bool):
         raise click.ClickException(f"There's no Writer Framework project at this location : {abs_path}")
 
     writer.serve.serve(
-        abs_path, mode="run", port=port, host=host, enable_server_setup=True, enable_jobs_api=enable_jobs_api)
+        abs_path,
+        mode="run",
+        port=port,
+        host=host,
+        enable_server_setup=True
+    )
 
 @main.command()
 @click.option('--host', default="127.0.0.1", help="Host to run the app on")
 @click.option('--port', default=None, help="Port to run the app on")
 @click.option('--enable-remote-edit', help="Set this flag to allow non-local requests in edit mode.", is_flag=True)
 @click.option('--enable-server-setup', help="Set this flag to enable server setup hook in edit mode.", is_flag=True)
+@click.option('--enable-file-buffering', help="Set this flag to enable file buffering in edit mode.", is_flag=True)
+@click.option('--buffer-sync-interval', default=10, type=int, help="Interval in seconds for synchronizing the file buffer.")
+@click.option('--buffer-path', default=None, type=str, help="Path to the file buffer directory. If not provided, a temporary directory will be used.")
 @click.option("--no-interactive", help="Set this flag to run the app without asking anything to the user.", is_flag=True)
-@click.option("--enable-jobs-api", help="Set this flag to enable the Jobs API, allowing you to execute jobs without user interaction.", is_flag=True)
+@click.option('--verbose', '-v', is_flag=True, help="Enable verbose output.")
 @click.argument('path')
 def edit(
     path: str,
@@ -51,28 +59,56 @@ def edit(
     host: str,
     enable_remote_edit: bool,
     enable_server_setup: bool,
+    enable_file_buffering: bool,
+    buffer_sync_interval: int,
+    buffer_path: Optional[str],
     no_interactive: bool,
-    enable_jobs_api: bool,
+    verbose: bool = False
 ):
     """Run the app from PATH folder in edit mode."""
-    abs_path = os.path.abspath(path)
-    if wf_project.is_project(path) is False and \
-        wf_project.can_create_project(path) is True and \
+    buffer = None
+    
+    if enable_file_buffering:
+        buffer = FileBuffering(
+            dest_dir=path,
+            src_dir=os.path.abspath(buffer_path) if buffer_path else None,
+            verbose=verbose,
+            interval=buffer_sync_interval,
+        )
+        print(f"Using temporary buffer path: {buffer.path}")
+        buffer.init()
+        buffer.watch_changes()
+        print("File buffering started in background")
+        
+        project_path = buffer.path
+    else:
+        project_path = path
+
+
+    abs_path = os.path.abspath(project_path)
+    if wf_project.is_project(project_path) is False and \
+        wf_project.can_create_project(project_path) is True and \
         no_interactive is False:
         click.confirm("There’s no Writer Framework project at this location, would you like to create a new one ?", default=False, abort=True)
-        create_app(path, template_name="default", overwrite=False)
+        create_app(project_path, template_name="default", overwrite=False)
 
-    if wf_project.is_project(path) is False and \
-        wf_project.can_create_project(path) is True:
+    if wf_project.is_project(project_path) is False and \
+        wf_project.can_create_project(project_path) is True:
         raise click.ClickException(f"There’s no Writer Framework project at this location, create a new one with `writer create {path}`")
 
-    if wf_project.is_project(path) is False and \
-        wf_project.can_create_project(path) is False:
+    if wf_project.is_project(project_path) is False and \
+        wf_project.can_create_project(project_path) is False:
         raise click.ClickException(f"There’s no Writer Framework project at this location : {abs_path}")
 
-    writer.serve.serve(
-        abs_path, mode="edit", port=port, host=host,
-        enable_remote_edit=enable_remote_edit, enable_server_setup=enable_server_setup, enable_jobs_api=enable_jobs_api)
+    try:
+        writer.serve.serve(
+            abs_path, mode="edit", port=port, host=host,
+            enable_remote_edit=enable_remote_edit, enable_server_setup=enable_server_setup,
+            )
+    finally:
+        if buffer:
+            print("Stopping file buffering...")
+            buffer.stop()
 
 @main.command()
 @click.argument('path')

writer/core.py

@@ -46,7 +46,9 @@ import writer.blocks
 import writer.evaluator
 from writer import core_ui
 from writer.core_ui import Component
+from writer.logs import use_stdout_redirect
 from writer.ss_types import (
+    BlueprintExecutionError,
     BlueprintExecutionLog,
     InstancePath,
     Readable,
@@ -55,11 +57,13 @@ from writer.ss_types import (
     WriterEventResult,
     WriterFileItem,
 )
+from writer.vault import writer_vault
 
 if TYPE_CHECKING:
     import pandas
 
     from writer.app_runner import AppProcess
+    from writer.blueprints import BlueprintRunner
     from writer.ss_types import AppProcessServerRequest
 
 
@@ -157,6 +161,7 @@ class WriterSession:
         self.session_component_tree = core_ui.build_session_component_tree(base_component_tree)
         self.event_handler = EventHandler(self)
         self.userinfo: Optional[dict] = None
+        self.queued_messages: List[Any] = []
 
     def update_last_active_timestamp(self) -> None:
         self.last_active_timestamp = int(time.time())
@@ -798,7 +803,7 @@ class State(metaclass=StateMeta):
         If there is a StateProxy, it is a fault in the code.
         """
         annotations = get_annotations(self)
-        expected_type = annotations.get(key, None)
+        expected_type = cast(Type, annotations.get(key, None))
         expect_dict = _type_match_dict(expected_type)
         if isinstance(value, dict) and not expect_dict:
             """
@@ -1077,6 +1082,10 @@ class WriterState(State):
             shortened_message = message[0 : WriterState.LOG_ENTRY_MAX_LEN] + "..."
         else:
             shortened_message = message
+
+        if id is not None:
+            self._remove_duplicates_in_mail(id)
+
         self.add_mail(
             "logEntry",
             {
@@ -1104,6 +1113,18 @@ class WriterState(State):
     def clear_mail(self) -> None:
         self.mail = []
 
+    def _remove_duplicates_in_mail(self, id: str) -> None:
+        new_mail = []
+        for entry in self.mail:
+            if entry["type"] != "logEntry":
+                new_mail.append(entry)
+                continue
+            log_id = entry["payload"].get("id")
+            if log_id != id:
+                new_mail.append(entry)
+                continue
+        self.mail = new_mail
+
     def set_page(self, active_page_key: str) -> None:
         self.add_mail("pageChange", active_page_key)
 
@@ -1201,8 +1222,136 @@ class EventHandlerRegistry:
         callable: Callable
         meta: "EventHandlerRegistry.HandlerMeta"
 
+    # === BLUEPRINT HANLDERS ===
+    @staticmethod
+    def stop_blueprint_run(payload: dict, blueprint_runner: "BlueprintRunner"):
+        run_id = payload.pop("run_id", None)
+        if not run_id:
+            raise ValueError("Missing run_id in payload")
+        return blueprint_runner.cancel_blueprint_execution(run_id=run_id)
+
+    @staticmethod
+    def run_blueprint_by_id(
+        payload: dict,
+        context: dict,
+        session: dict,
+        blueprint_runner: "BlueprintRunner",
+        vault: Dict,
+    ):
+        blueprint_id = payload.pop("blueprint_id", None)
+        if not blueprint_id:
+            raise ValueError("Missing blueprint_id in payload")
+        execution_environment = EventHandler._get_blueprint_execution_environment(
+            payload, context, session, vault
+        )
+        return blueprint_runner.run_blueprint(
+            component_id=blueprint_id,
+            execution_environment=execution_environment,
+            title="Blueprint execution triggered on demand",
+        )
+
+    @staticmethod
+    def run_blueprint_by_key(
+        payload: dict,
+        context: dict,
+        session: dict,
+        blueprint_runner: "BlueprintRunner",
+        vault: Dict,
+    ):
+        blueprint_key = payload.pop("blueprint_key", None)
+        if not blueprint_key:
+            raise ValueError("Missing blueprint_key in payload")
+        execution_environment = EventHandler._get_blueprint_execution_environment(
+            payload, context, session, vault
+        )
+        return blueprint_runner.run_blueprint_by_key(
+            blueprint_key=blueprint_key, execution_environment=execution_environment
+        )
+
+    @staticmethod
+    def run_blueprint_via_api(
+        payload: dict,
+        context: dict,
+        session: dict,
+        blueprint_runner: "BlueprintRunner",
+        vault: Dict,
+    ):
+        """
+        This handler is used to run a blueprint via the API.
+        It is used by the frontend to run a blueprint when the user clicks on a button.
+        """
+        blueprint_id = payload.pop("blueprint_id", None)
+        if not blueprint_id:
+            raise ValueError("Missing blueprint_id in payload")
+        trigger_type = payload.pop("trigger_type", None)
+        if not trigger_type:
+            raise ValueError("Missing trigger_type in payload")
+        execution_environment = EventHandler._get_blueprint_execution_environment(
+            payload, context, session, vault
+        )
+        return blueprint_runner.run_blueprint_via_api(
+            blueprint_id=blueprint_id,
+            trigger_type=trigger_type,
+            branch_id=payload.pop("branch_id", None),
+            execution_environment=execution_environment,
+        )
+
+    @staticmethod
+    def run_blueprint_branch(
+        payload: dict,
+        context: dict,
+        session: dict,
+        blueprint_runner: "BlueprintRunner",
+        vault: Dict,
+    ):
+        branch_id = payload.pop("branch_id", None)
+        if not branch_id:
+            raise ValueError("Missing branch_id in payload")
+        execution_environment = EventHandler._get_blueprint_execution_environment(
+            payload, context, session, vault
+        )
+        return blueprint_runner.run_branch(
+            start_node_id=branch_id,
+            branch_out_id=None,
+            execution_environment=execution_environment,
+            title="Branch execution triggered by demand",
+        )
+
     def __init__(self):
-        self.handler_map: Dict[str, "EventHandlerRegistry.HandlerEntry"] = {}  # type: ignore
+        self.handler_map: Dict[str, "EventHandlerRegistry.HandlerEntry"] = {
+            "stop_blueprint_run": {
+                "callable": self.stop_blueprint_run,
+                "meta": {"name": "stop_blueprint_run", "args": ["payload", "blueprint_runner"]},
+            },
+            "run_blueprint_by_key": {
+                "callable": self.run_blueprint_by_key,
+                "meta": {
+                    "name": "run_blueprint_by_key",
+                    "args": ["payload", "context", "session", "blueprint_runner", "vault"],
+                },
+            },
+            "run_blueprint_by_id": {
+                "callable": self.run_blueprint_by_id,
+                "meta": {
+                    "name": "run_blueprint_by_id",
+                    "args": ["payload", "context", "session", "blueprint_runner", "vault"],
+                },
+            },
+            "run_blueprint_via_api": {
+                "callable": self.run_blueprint_via_api,
+                "meta": {
+                    "name": "run_blueprint_via_api",
+                    "args": ["payload", "context", "session", "blueprint_runner", "vault"],
+                },
+            },
+            "run_blueprint_branch": {
+                "callable": self.run_blueprint_branch,
+                "meta": {
+                    "name": "run_blueprint_branch",
+                    "args": ["payload", "context", "session", "blueprint_runner", "vault"],
+                },
+            },
+        }
 
     def __iter__(self):
         return iter(self.handler_map.keys())
@@ -1508,6 +1657,12 @@ class EventDeserialiser:
         payload = _deserialize_bigint_format(payload)
         return payload
 
+    def _transform_tab_change(self, ev: WriterEvent) -> Optional[str]:
+        payload = ev.payload
+        if not isinstance(payload, str):
+            return None
+        return payload
+
 
 class SessionManager:
     """
@@ -1639,16 +1794,29 @@ class EventHandler:
             return
         self.evaluator.set_state(binding["stateRef"], instance_path, payload)
 
+    @staticmethod
+    def _get_blueprint_execution_environment(payload, context, session, vault):
+        return {
+            "payload": payload,
+            "context": context,
+            "session": session,
+            "vault": vault,
+        }
+
     def _get_blueprint_callable(
         self,
         blueprint_key: Optional[str] = None,
         blueprint_id: Optional[str] = None,
         branch_id: Optional[str] = None,
     ):
-        def fn(payload, context, session):
-            execution_environment = {"payload": payload, "context": context, "session": session}
+        def fn(payload, context, session, vault):
+            execution_environment = self._get_blueprint_execution_environment(
+                payload, context, session, vault
+            )
             if blueprint_key:
-                return self.blueprint_runner.run_blueprint_by_key(blueprint_key, execution_environment)
+                return self.blueprint_runner.run_blueprint_by_key(
+                    blueprint_key, execution_environment
+                )
             elif blueprint_id:
                 return self.blueprint_runner.run_blueprint(
                     blueprint_id, execution_environment, "Blueprint execution triggered on demand"
@@ -1664,18 +1832,6 @@ class EventHandler:
         return fn
 
     def _get_handler_callable(self, handler: str) -> Optional[Callable]:
-        if handler.startswith("$runBlueprint_"):
-            blueprint_key = handler[14:]
-            return self._get_blueprint_callable(blueprint_key=blueprint_key)
-
-        if handler.startswith("$runBlueprintById_"):
-            blueprint_id = handler[18:]
-            return self._get_blueprint_callable(blueprint_id=blueprint_id)
-
-        if handler.startswith("$runBlueprintTriggerBranchById_"):
-            branch_id = handler[31:]
-            return self._get_blueprint_callable(branch_id=branch_id)
-
         current_app_process = get_app_process()
         handler_registry = current_app_process.handler_registry
         callable_handler = handler_registry.find_handler_callable(handler)
@@ -1690,24 +1846,23 @@ class EventHandler:
             "context": context_data,
             "session": _event_handler_session_info(),
             "ui": _event_handler_ui_manager(),
+            "blueprint_runner": self.blueprint_runner,
+            "vault": writer_vault.get_secrets(),
         }
 
     def _call_handler_callable(self, handler_callable: Callable, calling_arguments: Dict) -> Any:
         current_app_process = get_app_process()
         result = None
-        captured_stdout = None
         with (
             core_ui.use_component_tree(self.session.session_component_tree),
-            contextlib.redirect_stdout(io.StringIO()) as f,
+            use_stdout_redirect(
+                lambda entry: self.session_state.add_log_entry("info", "Stdout message", entry)
+            ),
         ):
             middlewares_executors = current_app_process.middleware_registry.executors()
             result = EventHandlerExecutor.invoke_with_middlewares(
                 middlewares_executors, handler_callable, calling_arguments
             )
-            captured_stdout = f.getvalue()
-
-        if captured_stdout:
-            self.session_state.add_log_entry("info", "Stdout message", captured_stdout)
 
         return result
 
@@ -1740,17 +1895,21 @@ class EventHandler:
             calling_arguments = self._get_calling_arguments(ev, instance_path=None)
             return self._call_handler_callable(handler_callable, calling_arguments)
         except BaseException as e:
-            self.session_state.add_notification(
-                "error",
-                "Runtime Error",
-                f"An error occurred when processing event '{ ev.type }'.",
-            )
-            self.session_state.add_log_entry(
-                "error",
-                "Runtime Exception",
-                f"A runtime exception was raised when processing event '{ ev.type }'.",
-                traceback.format_exc(),
-            )
+            if not isinstance(e, BlueprintExecutionError):
+                # Only create a notification and log entry
+                # for non-blueprint errors, as blueprint errors
+                # have their own logging mechanism
+                self.session_state.add_notification(
+                    "error",
+                    "Runtime Error",
+                    f"An error occurred when processing event '{ ev.type }'.",
+                )
+                self.session_state.add_log_entry(
+                    "error",
+                    "Runtime Exception",
+                    f"A runtime exception was raised when processing event '{ ev.type }'.",
+                    traceback.format_exc(),
+                )
             raise e
 
     def _handle_component_event(self, ev: WriterEvent):
@@ -1762,7 +1921,13 @@ class EventHandler:
             target_component = cast(Component, self.session_component_tree.get_component(target_id))
             self._handle_binding(ev.type, target_component, instance_path, ev.payload)
             calling_arguments = self._get_calling_arguments(ev, instance_path)
-            self.blueprint_runner.execute_ui_trigger(target_id, ev.type, calling_arguments)
+            execution_environment = self._get_blueprint_execution_environment(
+                calling_arguments.get("payload"),
+                calling_arguments.get("context"),
+                calling_arguments.get("session"),
+                calling_arguments.get("vault"),
+            )
+            self.blueprint_runner.execute_ui_trigger(target_id, ev.type, execution_environment)
             if not target_component.handlers:
                 return None
             handler = target_component.handlers.get(ev.type)

writer/core_ui.py

@@ -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

@@ -55,34 +55,32 @@ 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)
 
-        def replacer(matched):
-            if matched.string[0] == "\\":  # Escaped @, don't evaluate
-                return matched.string
+        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:
-                return json.dumps(expr_value)
+                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 = field_value
-            if as_json:
-                # First pass to remove quotes around @{my_var}
-                replaced = re.sub(r'"(@{\s*[^"]+?\s*})"', r"\1", field_value)
-            replaced = self.TEMPLATE_REGEX.sub(replacer, replaced)
-            if as_json:
-                replaced = decode_json(replaced)
+            replaced = self.TEMPLATE_REGEX.sub(replacer, field_value)
         else:
             replaced = replacer(full_match)
-            if as_json:
-                replaced = decode_json(replaced)
+        if as_json:
+            replaced = decode_json(replaced)
 
         return replaced
 
@@ -217,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()
@@ -235,3 +224,28 @@ class Evaluator:
             return self.get_env_variable_value(expr)
 
         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