setta 0.0.14.dev4__tar.gz → 0.0.14.dev6__tar.gz

{setta-0.0.14.dev4/backend/setta.egg-info → setta-0.0.14.dev6}/PKG-INFO

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

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

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

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

@@ -0,0 +1,41 @@
+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

{setta-0.0.14.dev4 → setta-0.0.14.dev6}/backend/setta/tasks/tasks.py

@@ -3,6 +3,7 @@ import copy
 import json
 import logging
 import time
+import traceback
 from typing import Dict
 
 from setta.database.utils import create_new_id
@@ -87,15 +88,25 @@ class Tasks:
                     or None in fnInfo["dependencies"]
                     or any(k in fnInfo["dependencies"] for k in message.content.keys())
                 ):
-                    # Send message to subprocess
-                    sp_info["subprocess"].parent_conn.send(
-                        {
-                            "type": call_type,
-                            "fn_name": fn_name,
-                            "message": message,
-                            "other_data": other_data,
-                        }
+                    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(
@@ -127,23 +138,43 @@ class Tasks:
         self, subprocess_key, fn_name, msg_id, recv_fn, 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()
-        result = await self.task_runner.run(recv_fn, [], 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
+        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')}"
             )
-            if websocket_manager is not None:
-                if result["content"]:
-                    await websocket_manager.send_message_to_requester(
-                        msg_id, result["content"], result["messageType"]
-                    )
-                await self.maybe_send_latest_run_time_info(
-                    subprocess_key, fn_name, msg_id, websocket_manager
+
+            elapsed_time = time.perf_counter() - start_time
+            if result["status"] == "success":
+                self.update_average_subprocess_fn_time(
+                    subprocess_key, fn_name, elapsed_time
                 )
-            else:
-                results.append(result)
+                if websocket_manager is not None:
+                    if result["content"]:
+                        await websocket_manager.send_message_to_requester(
+                            msg_id, result["content"], result["messageType"]
+                        )
+                    await self.maybe_send_latest_run_time_info(
+                        subprocess_key, fn_name, msg_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:

{setta-0.0.14.dev4 → setta-0.0.14.dev6}/backend/setta/tasks/utils.py

@@ -61,8 +61,17 @@ class SettaInMemoryFnSubprocess:
         sys.stderr = output_capture
 
         while True:
-            msg = self.child_conn.recv()  # Wait for requests
-            msg_type = msg["type"]
+            try:
+                msg = self.child_conn.recv()
+                msg_type = msg["type"]
+                logger.debug(f"Subprocess received message type: {msg_type}")
+            except EOFError:
+                logger.error("EOF error when receiving message in subprocess")
+                break
+            except Exception as e:
+                logger.error(f"Error receiving message in subprocess: {str(e)}")
+                traceback.print_exc()
+                break
 
             if msg_type == "shutdown":
                 # Signal all worker threads to stop
@@ -114,21 +123,43 @@ class SettaInMemoryFnSubprocess:
 
                 elif msg_type == "call" or msg_type == "call_with_new_exporter_obj":
                     fn_name = msg["fn_name"]
+                    try:
+                        logger.debug(
+                            f"Subprocess about to process message for {fn_name}"
+                        )
+                        # Start a worker for this function if needed
+                        self._start_worker_for_fn(
+                            fn_name,
+                            fn_workers,
+                            fn_message_queues,
+                            fns_dict,
+                            cache,
+                            lock,
+                            send_lock,
+                            self.child_conn,
+                        )
 
-                    # Start a worker for this function if needed
-                    self._start_worker_for_fn(
-                        fn_name,
-                        fn_workers,
-                        fn_message_queues,
-                        fns_dict,
-                        cache,
-                        lock,
-                        send_lock,
-                        self.child_conn,
-                    )
-
-                    # Add the message to the function's queue
-                    fn_message_queues[fn_name].put(msg)
+                        # Add the message to the function's queue
+                        fn_message_queues[fn_name].put(msg)
+                    except Exception as e:
+                        logger.error(
+                            f"Error processing message for {fn_name}: {str(e)}"
+                        )
+                        traceback.print_exc()
+                        # Make sure to send an error response, so the parent doesn't hang
+                        with send_lock:
+                            try:
+                                self.child_conn.send(
+                                    {
+                                        "status": "error",
+                                        "error": str(e),
+                                        "messageType": None,
+                                    }
+                                )
+                            except:
+                                logger.error(
+                                    "Failed to send error response back to parent"
+                                )
 
             except Exception as e:
                 traceback.print_exc()
@@ -145,11 +176,14 @@ class SettaInMemoryFnSubprocess:
         self, fn_name, fn_message_queues, fns_dict, cache, lock, send_lock, child_conn
     ):
         """Worker thread that processes messages for a specific function"""
+        logger.debug(f"Started worker thread for {fn_name}")
         while True:
             try:
                 # Get a message from the queue
                 msg = fn_message_queues[fn_name].get()
-
+                logger.debug(
+                    f"Worker thread for {fn_name} got message of type: {msg.get('type') if msg else 'None'}"
+                )
                 if msg is None:  # Sentinel value to stop the thread
                     break
 
@@ -241,10 +275,11 @@ class SettaInMemoryFnSubprocess:
 
             # Send shutdown message to the subprocess
             try:
+                logger.debug("Sending shutdown message to subprocess")
                 self.parent_conn.send({"type": "shutdown"})
-            except (BrokenPipeError, EOFError):
-                # Pipe might already be closed, that's okay
-                pass
+                logger.debug("Shutdown message sent")
+            except (BrokenPipeError, EOFError) as e:
+                logger.error(f"Error sending shutdown message: {str(e)}")
 
             # Join the process with timeout
             self.process.join(timeout=2)

{setta-0.0.14.dev4 → setta-0.0.14.dev6/backend/setta.egg-info}/PKG-INFO

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

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

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

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

@@ -1,29 +0,0 @@
-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)