setta 0.0.14.dev5__tar.gz → 0.0.14.dev7__tar.gz

{setta-0.0.14.dev5/backend/setta.egg-info → setta-0.0.14.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: setta
-Version: 0.0.14.dev5
+Version: 0.0.14.dev7
 Summary: Python without the donkeywork.
 Home-page: https://setta.dev
 Author: Kevin Musgrave, Jeff Musgrave

setta-0.0.14.dev7/backend/setta/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.14.dev7"

setta-0.0.14.dev7/backend/setta/tasks/task_runner.py

@@ -0,0 +1,29 @@
+import asyncio
+import inspect
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
+from enum import Enum
+
+
+class RunType(Enum):
+    SUBPROCESS = "SUBPROCESS"
+    THREAD = "THREAD"
+    NONE = "NONE"
+
+
+class TaskRunner:
+    def __init__(self):
+        self.thread_executor = ThreadPoolExecutor(max_workers=2)
+        self.process_executor = ProcessPoolExecutor(max_workers=2)
+
+    async def run(self, fn, fn_args, run_as):
+        if inspect.iscoroutinefunction(fn):
+            return await fn(*fn_args)
+
+        if run_as == RunType.NONE:
+            return fn(*fn_args)
+        elif run_as == RunType.THREAD:
+            executor = self.thread_executor
+        elif run_as == RunType.SUBPROCESS:
+            executor = self.process_executor
+
+        return await asyncio.get_running_loop().run_in_executor(executor, fn, *fn_args)

{setta-0.0.14.dev5 → setta-0.0.14.dev7}/backend/setta/tasks/tasks.py

@@ -3,7 +3,6 @@ import copy
 import json
 import logging
 import time
-import traceback
 from typing import Dict
 
 from setta.database.utils import create_new_id
@@ -72,56 +71,53 @@ class Tasks:
         call_type="call",
         other_data=None,
     ):
-        # Create a list of tasks to run concurrently
-        tasks = []
-        results = []
         message.content = {tuple(json.loads(k)): v for k, v in message.content.items()}
 
+        # Group tasks by subprocess to ensure sequential processing per subprocess
+        subprocess_tasks = {}
+        results = []
+
+        # First, identify all relevant subprocesses and their functions to call
         for sp_key, sp_info in self.in_memory_subprocesses.items():
             if (subprocess_key and sp_key != subprocess_key) or (
                 not match_subprocess_key(sp_key, project_config_id, section_id, idx)
             ):
                 continue
+
+            # For each matching subprocess, collect all functions that need to be called
+            fns_to_call = []
             for fn_name, fnInfo in sp_info["fnInfo"].items():
                 if (
                     call_all
                     or None in fnInfo["dependencies"]
                     or any(k in fnInfo["dependencies"] for k in message.content.keys())
                 ):
-                    logger.debug(
-                        f"Sending message to subprocess {sp_key}, function {fn_name}, message type: {call_type}"
-                    )
-                    try:
-                        # Send message to subprocess
-                        sp_info["subprocess"].parent_conn.send(
-                            {
-                                "type": call_type,
-                                "fn_name": fn_name,
-                                "message": message,
-                                "other_data": other_data,
-                            }
-                        )
-                    except Exception as e:
-                        logger.error(
-                            f"Error sending message to subprocess {sp_key}: {str(e)}"
-                        )
-                        traceback.print_exc()
-                        continue  # Skip to next function if we can't send
-
-                    # Create task for receiving response
-                    task = asyncio.create_task(
-                        self._handle_subprocess_response(
-                            sp_key,
-                            fn_name,
-                            message.id,
-                            sp_info["subprocess"].parent_conn.recv,
-                            websocket_manager,
-                            results,
-                        )
-                    )
-                    tasks.append(task)
+                    fns_to_call.append(fn_name)
 
-        # Wait for all tasks to complete concurrently
+            if fns_to_call:
+                subprocess_tasks[sp_key] = {
+                    "subprocess": sp_info["subprocess"],
+                    "functions": fns_to_call,
+                }
+
+        # Create tasks to process each subprocess sequentially
+        tasks = []
+        for sp_key, sp_data in subprocess_tasks.items():
+            task = asyncio.create_task(
+                self._process_subprocess_sequentially(
+                    sp_key,
+                    sp_data["subprocess"],
+                    sp_data["functions"],
+                    message,
+                    call_type,
+                    other_data,
+                    websocket_manager,
+                    results,
+                )
+            )
+            tasks.append(task)
+
+        # Wait for all subprocess tasks to complete (each subprocess processed sequentially)
         if tasks:
             await asyncio.gather(*tasks)
 
@@ -134,47 +130,51 @@ class Tasks:
                 content.extend(r["content"])
         return {"content": content, "messageType": C.WS_IN_MEMORY_FN_RETURN}
 
-    async def _handle_subprocess_response(
-        self, subprocess_key, fn_name, msg_id, recv_fn, websocket_manager, results
+    async def _process_subprocess_sequentially(
+        self,
+        subprocess_key,
+        subprocess,
+        fn_names,
+        message,
+        call_type,
+        other_data,
+        websocket_manager,
+        results,
     ):
-        # Run the receive function in a thread
-        logger.debug(
-            f"Waiting for response from subprocess {subprocess_key}, function {fn_name}"
-        )
-        start_time = time.perf_counter()
-        try:
-            result = await self.task_runner.run(recv_fn, [], RunType.THREAD)
-            logger.debug(
-                f"Received response from subprocess {subprocess_key}, function {fn_name}: status={result.get('status', 'unknown')}"
+        # Process each function sequentially for this subprocess
+        for fn_name in fn_names:
+            # Send message to subprocess
+            subprocess.parent_conn.send(
+                {
+                    "type": call_type,
+                    "fn_name": fn_name,
+                    "message": message,
+                    "other_data": other_data,
+                }
             )
 
+            # Wait for and handle the response before sending the next message
+            start_time = time.perf_counter()
+            result = await self.task_runner.run(
+                subprocess.parent_conn.recv, [], RunType.THREAD
+            )
             elapsed_time = time.perf_counter() - start_time
+
             if result["status"] == "success":
                 self.update_average_subprocess_fn_time(
                     subprocess_key, fn_name, elapsed_time
                 )
+
                 if websocket_manager is not None:
                     if result["content"]:
                         await websocket_manager.send_message_to_requester(
-                            msg_id, result["content"], result["messageType"]
+                            message.id, result["content"], result["messageType"]
                         )
                     await self.maybe_send_latest_run_time_info(
-                        subprocess_key, fn_name, msg_id, websocket_manager
+                        subprocess_key, fn_name, message.id, websocket_manager
                     )
                 else:
                     results.append(result)
-        except EOFError:
-            logger.error(
-                f"EOF error when receiving response from subprocess {subprocess_key}, function {fn_name}"
-            )
-            # Add stack trace to see where exactly the error occurs
-            traceback.print_exc()
-            # Consider adding a placeholder result or raising to caller
-        except Exception as e:
-            logger.error(
-                f"Error receiving response from subprocess {subprocess_key}, function {fn_name}: {str(e)}"
-            )
-            traceback.print_exc()
 
     async def add_custom_fns(self, code_graph, exporter_obj):
         for c in code_graph:
@@ -182,8 +182,6 @@ class Tasks:
             sp = self.in_memory_subprocesses.get(subprocess_key, {}).get("subprocess")
             if sp:
                 sp.close()
-                del self.in_memory_subprocesses[subprocess_key]
-
             sp = SettaInMemoryFnSubprocess(
                 self.stop_event, self.websockets, c["subprocessStartMethod"]
             )

setta-0.0.14.dev7/backend/setta/tasks/utils.py

@@ -0,0 +1,292 @@
+import asyncio
+import importlib.util
+import logging
+import multiprocessing
+import queue
+import sys
+import threading
+import traceback
+import uuid
+
+from setta.tasks.fns.utils import TaskDefinition
+from setta.utils.constants import CWD
+from setta.utils.utils import nested_access
+
+logger = logging.getLogger(__name__)
+
+
+def import_code_from_string(code_string, module_name=None, add_to_sys_modules=True):
+    # Generate a unique module name if one isn't provided
+    if module_name is None:
+        module_name = f"setta_dynamic_module_{uuid.uuid4().hex}"
+
+    # Add current directory to sys.path if it's not already there
+    current_dir = str(CWD)
+    if current_dir not in sys.path:
+        sys.path.insert(0, current_dir)
+
+    spec = importlib.util.spec_from_loader(module_name, loader=None)
+
+    # Create a new module based on the spec
+    module = importlib.util.module_from_spec(spec)
+
+    # Optionally add the module to sys.modules
+    if add_to_sys_modules:
+        print(f"adding {module_name} to sys.modules", flush=True)
+        sys.modules[module_name] = module
+
+    # Compile the code string
+    code_object = compile(code_string, module_name, "exec")
+
+    # Execute the compiled code object in the module's namespace
+    exec(code_object, module.__dict__)
+
+    return module
+
+
+class SettaInMemoryFnSubprocess:
+    def __init__(self, stop_event, websockets, start_method):
+        logger.debug(
+            f"Creating SettaInMemoryFnSubprocess using {start_method} start_method"
+        )
+        ctx = multiprocessing.get_context(start_method)
+        self.parent_conn, self.child_conn = ctx.Pipe()
+        self.process = ctx.Process(target=self._subprocess_main)
+        self.stdout_parent_conn, self.stdout_child_conn = ctx.Pipe()
+        self.process.daemon = True  # Ensure process dies with parent
+        self.process.start()
+
+        self.stop_event = asyncio.Event()
+        self.tasks_stop_event = stop_event
+        self.websockets = websockets
+        self.stdout_queue = queue.Queue()
+        self.stdout_processor_task = None
+        self.stdout_thread = threading.Thread(target=self.stdout_listener, daemon=True)
+        self.stdout_thread.start()
+
+        if len(self.websockets) > 0:
+            self.start_stdout_processor_task()
+
+    def _subprocess_main(self):
+        """Main loop in subprocess that handles all requests"""
+        # Initialize store for imported modules
+        fns_dict = {}
+        cache = {}
+
+        class OutputCapture:
+            def __init__(self, stdout_pipe):
+                self.stdout_pipe = stdout_pipe
+
+            def write(self, text):
+                self.stdout_pipe.send(text)
+
+            def flush(self):
+                pass
+
+        # Redirect stdout as soon as subprocess starts
+        output_capture = OutputCapture(self.stdout_child_conn)
+        sys.stdout = output_capture
+        sys.stderr = output_capture
+
+        while True:
+            msg = self.child_conn.recv()  # Wait for requests
+            msg_type = msg["type"]
+            return_message_type = None
+
+            if msg_type == "shutdown":
+                break
+
+            try:
+                if msg_type == "import":
+                    dependencies = {}
+                    for to_import in msg["imports"]:
+                        code = to_import["code"]
+                        module_name = to_import["module_name"]
+                        # Import and store module
+                        module = import_code_from_string(code, module_name)
+                        added_fn_names = add_fns_from_module(
+                            fns_dict, module, module_name
+                        )
+                        for k in added_fn_names:
+                            cache[k] = msg["exporter_obj"]
+                            dependencies[k] = get_task_metadata(fns_dict[k], cache[k])
+
+                    self.child_conn.send(
+                        {
+                            "status": "success",
+                            "content": dependencies,
+                        }
+                    )
+
+                elif msg_type == "call":
+                    result, return_message_type = self.call_imported_fn(
+                        msg, fns_dict, cache
+                    )
+                    self.child_conn.send(
+                        {
+                            "status": "success",
+                            "content": result,
+                            "messageType": return_message_type,
+                        }
+                    )
+
+                elif msg_type == "call_with_new_exporter_obj":
+                    # replace old exporter_obj
+                    cache[msg["fn_name"]] = msg["other_data"]["exporter_obj"]
+                    result, return_message_type = self.call_imported_fn(
+                        msg, fns_dict, cache
+                    )
+                    self.child_conn.send(
+                        {
+                            "status": "success",
+                            "content": result,
+                            "messageType": return_message_type,
+                        }
+                    )
+
+            except Exception as e:
+                traceback.print_exc()
+                self.child_conn.send(
+                    {
+                        "status": "error",
+                        "error": str(e),
+                        "messageType": return_message_type,
+                    }
+                )
+
+    def call_imported_fn(self, msg, fns_dict, cache):
+        fn_name = msg["fn_name"]
+        message = self.process_message(fn_name, msg["message"], cache)
+        fn = fns_dict[fn_name]
+        result = fn.fn(message)
+        return_message_type = fn.return_message_type
+        return result, return_message_type
+
+    def close(self):
+        try:
+            logger.debug("Initiating shutdown sequence")
+            self.parent_conn.send({"type": "shutdown"})
+            self.process.join(timeout=2)  # Add timeout to process join
+
+            if self.process.is_alive():
+                logger.debug("Process still alive after timeout, forcing termination")
+                self.process.terminate()
+                self.process.join(timeout=1)
+        except Exception as e:
+            logger.debug(f"Error during process shutdown: {e}")
+
+        # Set stop event before closing pipes
+        self.stop_event.set()
+
+        # Close all connections
+        for conn in [
+            self.parent_conn,
+            self.child_conn,
+            self.stdout_parent_conn,
+            self.stdout_child_conn,
+        ]:
+            conn.close()
+
+        self.stdout_thread.join(timeout=2)  # Add timeout to thread join
+
+        if self.stdout_thread.is_alive():
+            logger.debug("Stdout thread failed to terminate within timeout")
+
+        if self.stdout_processor_task:
+            self.stdout_processor_task.cancel()
+
+    def process_message(self, fn_name, message, cache):
+        if fn_name in cache:
+            exporter_obj = cache[fn_name]
+            for k, v in message.content.items():
+                nice_str = exporter_obj.var_name_mapping.get(k)
+                if not nice_str:
+                    continue
+                p_dict, key = nested_access(exporter_obj.output, nice_str)
+                p_dict[key] = v
+            message.content = exporter_obj.output
+        return message.content
+
+    def start_stdout_processor_task(self):
+        if self.stdout_processor_task is None or self.stdout_processor_task.done():
+            self.stdout_processor_task = asyncio.create_task(
+                self.process_stdout_queue()
+            )
+
+    async def stop_stdout_processor_task(self):
+        if self.stdout_processor_task and not self.stdout_processor_task.done():
+            self.stdout_processor_task.cancel()
+            try:
+                await self.stdout_processor_task
+            except asyncio.CancelledError:
+                pass
+            self.stdout_processor_task = None
+
+    async def process_stdout_queue(self):
+        while not self.should_stop():
+            try:
+                if self.should_stop():
+                    break
+                if len(self.websockets) > 0:
+                    stdout_data = self.stdout_queue.get_nowait()
+                    stdout_data = stdout_data.replace("\n", "\r\n")
+                    for w in self.websockets:
+                        await w.send_text(stdout_data)
+                    self.stdout_queue.task_done()
+            except queue.Empty:
+                await asyncio.sleep(0.1)  # Check for connection every 100ms
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                if self.should_stop():
+                    break
+                logger.debug(f"Error processing stdout: {e}")
+
+    def stdout_listener(self):
+        while not self.should_stop():
+            if self.stdout_parent_conn.poll(0.1):  # Check for data with timeout
+                try:
+                    stdout_data = self.stdout_parent_conn.recv()
+                    self.stdout_queue.put(stdout_data)
+                except EOFError:  # Pipe was closed
+                    break
+                except Exception as e:
+                    logger.debug(f"Error in stdout listener: {e}")
+                    if self.should_stop():
+                        break
+            else:  # No data available within timeout
+                if self.should_stop():
+                    break
+
+    def should_stop(self):
+        return self.stop_event.is_set() or self.tasks_stop_event.is_set()
+
+
+def add_fns_from_module(fns_dict, module, module_name=None):
+    count = 1
+    added_fn_names = []
+    for attr in vars(module).values():
+        if isinstance(attr, TaskDefinition):
+            if not attr.name:
+                if not module_name:
+                    raise ValueError(
+                        "Either TaskDefinition must be initialized with a name, or task_name must be specified"
+                    )
+                attr.name = f"{module_name}-{count}"
+                count += 1
+            fns_dict[attr.name] = attr
+            added_fn_names.append(attr.name)
+    return added_fn_names
+
+
+def get_task_metadata(in_memory_fn, exporter_obj):
+    # None means run the task on every change
+    if in_memory_fn.dependencies is None:
+        dependencies = set([None])
+    # Empty array means only run when the task imported.
+    # Non-empty array means run when specified dependencies update.
+    else:
+        dependencies = set(
+            exporter_obj.var_name_reverse_mapping[d] for d in in_memory_fn.dependencies
+        )
+    return dependencies

{setta-0.0.14.dev5 → setta-0.0.14.dev7/backend/setta.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: setta
-Version: 0.0.14.dev5
+Version: 0.0.14.dev7
 Summary: Python without the donkeywork.
 Home-page: https://setta.dev
 Author: Kevin Musgrave, Jeff Musgrave

setta-0.0.14.dev5/backend/setta/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.14.dev5"

setta-0.0.14.dev5/backend/setta/tasks/task_runner.py

@@ -1,41 +0,0 @@
-import asyncio
-import inspect
-import logging
-import traceback
-from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
-from enum import Enum
-
-logger = logging.getLogger(__name__)
-
-
-class RunType(Enum):
-    SUBPROCESS = "SUBPROCESS"
-    THREAD = "THREAD"
-    NONE = "NONE"
-
-
-class TaskRunner:
-    def __init__(self):
-        self.thread_executor = ThreadPoolExecutor(max_workers=2)
-        self.process_executor = ProcessPoolExecutor(max_workers=2)
-
-    async def run(self, fn, fn_args, run_as):
-        logger.debug(f"TaskRunner running function {fn.__name__} with run_as={run_as}")
-        try:
-            if inspect.iscoroutinefunction(fn):
-                return await fn(*fn_args)
-
-            if run_as == RunType.NONE:
-                return fn(*fn_args)
-            elif run_as == RunType.THREAD:
-                executor = self.thread_executor
-            elif run_as == RunType.SUBPROCESS:
-                executor = self.process_executor
-
-            return await asyncio.get_running_loop().run_in_executor(
-                executor, fn, *fn_args
-            )
-        except Exception as e:
-            logger.error(f"Error in TaskRunner.run: {str(e)}")
-            traceback.print_exc()
-            raise