setta 0.0.14.dev4__py3-none-any.whl → 0.0.14.dev6__py3-none-any.whl

setta/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.14.dev4"
+__version__ = "0.0.14.dev6"

setta/tasks/task_runner.py

@@ -1,8 +1,12 @@
 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"
@@ -16,14 +20,22 @@ class TaskRunner:
         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)
+        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
+            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)
+            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/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/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.dist-info → setta-0.0.14.dev6.dist-info}/METADATA

@@ -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.dist-info → setta-0.0.14.dev6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-setta/__init__.py,sha256=9veran4Ad41E_iJ8FcUXuAdGf6tKlQnmP63HirwZdO8,28
+setta/__init__.py,sha256=Au0i6BplPktnDDP961GPD0r_9xhbmzMtWXB1881eIRw,28
 setta/server.py,sha256=q4w9WG7SuLxwYtgXUCQyLt7t_HLmQV4y5abqvm7-uEA,4861
 setta/start.py,sha256=5sMZ7WH3KV9Q0v186PsaYqsWOz7hebyrpXbBOp9wQww,3589
 setta/cli/__init__.py,sha256=UxZG_VOMuF6lEBT3teUgTS9ulsK3wt3Gu3BbAQiAmt8,47
@@ -229,9 +229,9 @@ setta/static/frontend/assets/logo/logo.svg,sha256=k3XeAlA6hEaNfjnXG05hyb-8u1p_Fr
 setta/static/seed/.DS_Store,sha256=ENxJvDQd7Te_U8gExcXtHE-mAeBUYOHELRfDWgN1NmA,6148
 setta/static/seed/examples/.DS_Store,sha256=1lFlJ5EFymdzGAUAaI30vcaaLHt3F1LwpG7xILf9jsM,6148
 setta/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-setta/tasks/task_runner.py,sha256=gMXpfZWFMQbix2MfrHVCKB7BxQCjO8JH2P8cxUmt1ms,849
-setta/tasks/tasks.py,sha256=uG-S3jN9qZEolHtXkJZ4LMi-8LrNPctQR6TVWPlyeTs,10206
-setta/tasks/utils.py,sha256=cTmHJGPk6HHbl7nNTPV2KaTugkdSRJTow0z4A05b0lg,15901
+setta/tasks/task_runner.py,sha256=2bykjmSDPZ6lFqeaKTFYPN1eqHtrKDIZJpIi4PztL9Q,1232
+setta/tasks/tasks.py,sha256=o8YVQvEW3uzhMTF38HFk_IgHVe4Wyye7ybb7QZm_-TQ,11695
+setta/tasks/utils.py,sha256=GnFnNVhvXxzoIZtsvhDip12BMKVd73S3UCHdm7ZP01s,17786
 setta/tasks/fns/__init__.py,sha256=JhGzzQGaT9BWtF3pOmguh6pzIF9kdG3jdDNLyYZ2w7g,461
 setta/tasks/fns/codeAreaAutocomplete.py,sha256=gJ5JbjkWDyTothr-UF-YlOxrbVzj2iyOVK7XD3lfhSQ,6416
 setta/tasks/fns/codeAreaFindTemplateVars.py,sha256=vD9rY8VNPavv6VKa1bnxRPPRDNvFQy6mPIZRl-_3GnY,3708
@@ -252,9 +252,9 @@ setta/utils/generate_new_filename.py,sha256=KBLX6paDmTvXR-027TpqQkfijIXc7mCfhen-
 setta/utils/section_contents.py,sha256=V2HQPik6DfSXw4j7IalbP5AZ3OEGCbtL5ub3xL-Q_Qo,4141
 setta/utils/utils.py,sha256=KjzcvgM3Ab3IcE8vaWYtgBpwzPLKg0LmblnHLoYZJHM,9164
 setta/utils/websocket_manager.py,sha256=MBIMI8xxOFQF4lT3on4pupi1ttEWXdWPV4fI2YP_UJU,3925
-setta-0.0.14.dev4.dist-info/LICENSE,sha256=us9fuCq9wmiZVzayjKxNZ2iJYF6dROe0Qp57ToCO7XU,11361
-setta-0.0.14.dev4.dist-info/METADATA,sha256=JUVKYWOIw0XU77QDXfJhbcNVN9N5xkrirMToSOucr0Y,7517
-setta-0.0.14.dev4.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-setta-0.0.14.dev4.dist-info/entry_points.txt,sha256=P0qCESy9fWF2q1EQ9JufGldCSnPHplDPn8J6Bgk5hB0,42
-setta-0.0.14.dev4.dist-info/top_level.txt,sha256=8G4lmRzVOnJ11_DescPVHE6MQZH-o06A0nGsDDV2ngY,6
-setta-0.0.14.dev4.dist-info/RECORD,,
+setta-0.0.14.dev6.dist-info/LICENSE,sha256=us9fuCq9wmiZVzayjKxNZ2iJYF6dROe0Qp57ToCO7XU,11361
+setta-0.0.14.dev6.dist-info/METADATA,sha256=UZ7Aa4y8MuovjaCfTVklgMKW9gokelnp1mWFNeLKba8,7517
+setta-0.0.14.dev6.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+setta-0.0.14.dev6.dist-info/entry_points.txt,sha256=P0qCESy9fWF2q1EQ9JufGldCSnPHplDPn8J6Bgk5hB0,42
+setta-0.0.14.dev6.dist-info/top_level.txt,sha256=8G4lmRzVOnJ11_DescPVHE6MQZH-o06A0nGsDDV2ngY,6
+setta-0.0.14.dev6.dist-info/RECORD,,