setta 0.0.14.dev5__py3-none-any.whl → 0.0.14.dev7__py3-none-any.whl

setta/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.14.dev5"
+__version__ = "0.0.14.dev7"

setta/tasks/task_runner.py

@@ -1,12 +1,8 @@
 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"
@@ -20,22 +16,14 @@ class TaskRunner:
         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 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
-            )
-        except Exception as e:
-            logger.error(f"Error in TaskRunner.run: {str(e)}")
-            traceback.print_exc()
-            raise
+        return await asyncio.get_running_loop().run_in_executor(executor, fn, *fn_args)

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/tasks/utils.py

@@ -7,7 +7,6 @@ import sys
 import threading
 import traceback
 import uuid
-from collections import defaultdict
 
 from setta.tasks.fns.utils import TaskDefinition
 from setta.utils.constants import CWD
@@ -16,6 +15,35 @@ 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(
@@ -40,20 +68,20 @@ class SettaInMemoryFnSubprocess:
             self.start_stdout_processor_task()
 
     def _subprocess_main(self):
-        """Main loop in subprocess that handles all requests with parallel function execution"""
+        """Main loop in subprocess that handles all requests"""
         # Initialize store for imported modules
         fns_dict = {}
         cache = {}
 
-        # Message queues per function
-        fn_message_queues = defaultdict(queue.Queue)
+        class OutputCapture:
+            def __init__(self, stdout_pipe):
+                self.stdout_pipe = stdout_pipe
 
-        # Create a lock for thread-safe operations
-        lock = threading.RLock()
-        send_lock = threading.Lock()
+            def write(self, text):
+                self.stdout_pipe.send(text)
 
-        # Function worker threads
-        fn_workers = {}
+            def flush(self):
+                pass
 
         # Redirect stdout as soon as subprocess starts
         output_capture = OutputCapture(self.stdout_child_conn)
@@ -61,27 +89,11 @@ class SettaInMemoryFnSubprocess:
         sys.stderr = output_capture
 
         while True:
-            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
+            msg = self.child_conn.recv()  # Wait for requests
+            msg_type = msg["type"]
+            return_message_type = None
 
             if msg_type == "shutdown":
-                # Signal all worker threads to stop
-                for fn_name in fn_workers:
-                    fn_message_queues[fn_name].put(None)
-
-                # Wait for all worker threads to finish (with timeout)
-                for fn_name, worker in fn_workers.items():
-                    worker.join(timeout=1.0)
-
                 break
 
             try:
@@ -92,221 +104,108 @@ class SettaInMemoryFnSubprocess:
                         module_name = to_import["module_name"]
                         # Import and store module
                         module = import_code_from_string(code, module_name)
-                        with lock:
-                            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]
-                                )
-                                # Start a worker thread for each function
-                                self._start_worker_for_fn(
-                                    k,
-                                    fn_workers,
-                                    fn_message_queues,
-                                    fns_dict,
-                                    cache,
-                                    lock,
-                                    send_lock,
-                                    self.child_conn,
-                                )
-
-                    with send_lock:
-                        self.child_conn.send(
-                            {
-                                "status": "success",
-                                "content": dependencies,
-                            }
+                        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])
 
-                elif msg_type == "call" or msg_type == "call_with_new_exporter_obj":
-                    fn_name = msg["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,
+                    self.child_conn.send(
+                        {
+                            "status": "success",
+                            "content": dependencies,
+                        }
                     )
 
-                    # Add the message to the function's queue
-                    fn_message_queues[fn_name].put(msg)
-
-            except Exception as e:
-                traceback.print_exc()
-                with send_lock:
+                elif msg_type == "call":
+                    result, return_message_type = self.call_imported_fn(
+                        msg, fns_dict, cache
+                    )
                     self.child_conn.send(
                         {
-                            "status": "error",
-                            "error": str(e),
-                            "messageType": None,
+                            "status": "success",
+                            "content": result,
+                            "messageType": return_message_type,
                         }
                     )
 
-    def _worker_thread(
-        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
-
-                msg_type = msg["type"]
-                return_message_type = None
-
-                if msg_type == "call" or msg_type == "call_with_new_exporter_obj":
-                    try:
-                        # Handle updating exporter_obj for call_with_new_exporter_obj
-                        if msg_type == "call_with_new_exporter_obj":
-                            with lock:
-                                cache[fn_name] = msg["other_data"]["exporter_obj"]
-
-                        # Get a thread-safe copy of what we need
-                        with lock:
-                            in_memory_fn_obj = fns_dict[fn_name]
-                            exporter_obj = cache.get(fn_name)
-
-                        # Process message
-                        message_content = process_message(msg["message"], exporter_obj)
-
-                        # Call function
-                        result = in_memory_fn_obj.fn(message_content)
-                        return_message_type = in_memory_fn_obj.return_message_type
-
-                        # Send result back
-                        with send_lock:
-                            child_conn.send(
-                                {
-                                    "status": "success",
-                                    "content": result,
-                                    "messageType": return_message_type,
-                                }
-                            )
-                    except Exception as e:
-                        traceback.print_exc()
-                        with send_lock:
-                            child_conn.send(
-                                {
-                                    "status": "error",
-                                    "error": str(e),
-                                    "messageType": return_message_type,
-                                }
-                            )
-
-                # Mark task as done
-                fn_message_queues[fn_name].task_done()
+                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()
-                print(f"Error in worker thread for {fn_name}: {e}", flush=True)
-
-    def _start_worker_for_fn(
-        self,
-        fn_name,
-        fn_workers,
-        fn_message_queues,
-        fns_dict,
-        cache,
-        lock,
-        send_lock,
-        child_conn,
-    ):
-        """Start a worker thread for a function if not already running"""
-        if fn_name not in fn_workers or not fn_workers[fn_name].is_alive():
-            worker = threading.Thread(
-                target=self._worker_thread,
-                args=(
-                    fn_name,
-                    fn_message_queues,
-                    fns_dict,
-                    cache,
-                    lock,
-                    send_lock,
-                    child_conn,
-                ),
-                daemon=True,
-                name=f"worker-{fn_name}",
-            )
-            fn_workers[fn_name] = worker
-            worker.start()
+                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
 
-            # Set our stop event - this signals all tasks to stop
-            self.stop_event.set()
-
-            # Send shutdown message to the subprocess
-            try:
-                logger.debug("Sending shutdown message to subprocess")
-                self.parent_conn.send({"type": "shutdown"})
-                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)
-
-            # If still alive, escalate to terminate
             if self.process.is_alive():
-                logger.debug(
-                    "Process still alive after graceful shutdown, forcing termination"
-                )
+                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}")
 
-                # Last resort: kill
-                if self.process.is_alive():
-                    logger.debug(
-                        "Process still alive after terminate, killing forcefully"
-                    )
-                    self.process.kill()
-                    self.process.join(timeout=1)
+        # Set stop event before closing pipes
+        self.stop_event.set()
 
-        except Exception as e:
-            logger.exception(f"Error during process shutdown: {e}")
+        # Close all connections
+        for conn in [
+            self.parent_conn,
+            self.child_conn,
+            self.stdout_parent_conn,
+            self.stdout_child_conn,
+        ]:
+            conn.close()
 
-        # Now handle the async tasks and threads
-        try:
-            # Cancel the stdout processor task if it exists
-            if self.stdout_processor_task:
-                self.stdout_processor_task.cancel()
-
-            # Close all connections - this will cause pending operations to fail fast
-            for conn in [
-                self.parent_conn,
-                self.child_conn,
-                self.stdout_parent_conn,
-                self.stdout_child_conn,
-            ]:
-                try:
-                    conn.close()
-                except:
-                    pass
+        self.stdout_thread.join(timeout=2)  # Add timeout to thread join
 
-            # Join the stdout thread with timeout
-            if self.stdout_thread and self.stdout_thread.is_alive():
-                self.stdout_thread.join(timeout=2)
-                if self.stdout_thread.is_alive():
-                    logger.debug("Stdout thread failed to terminate within timeout")
+        if self.stdout_thread.is_alive():
+            logger.debug("Stdout thread failed to terminate within timeout")
 
-        except Exception as e:
-            logger.exception(f"Error during resource cleanup: {e}")
+        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():
@@ -391,59 +290,3 @@ def get_task_metadata(in_memory_fn, exporter_obj):
             exporter_obj.var_name_reverse_mapping[d] for d in in_memory_fn.dependencies
         )
     return dependencies
-
-
-# Class for capturing and redirecting stdout/stderr
-class OutputCapture:
-    def __init__(self, stdout_pipe):
-        self.stdout_pipe = stdout_pipe
-        self.lock = threading.Lock()
-
-    def write(self, text):
-        with self.lock:
-            self.stdout_pipe.send(text)
-
-    def flush(self):
-        pass
-
-
-def process_message(message, exporter_obj):
-    """Process a message before passing it to a function"""
-    if exporter_obj:
-        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
-        return exporter_obj.output
-    return message.content
-
-
-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

{setta-0.0.14.dev5.dist-info → setta-0.0.14.dev7.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-setta/__init__.py,sha256=dRhS5q6Sal0dV1Xm-wF5fYy5g9gBiwNKZ8YDlE48FV4,28
+setta/__init__.py,sha256=-qJsuUle95TwTi4vroNItCFbufX5VZwZ055MmNPMVro,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=2bykjmSDPZ6lFqeaKTFYPN1eqHtrKDIZJpIi4PztL9Q,1232
-setta/tasks/tasks.py,sha256=o8YVQvEW3uzhMTF38HFk_IgHVe4Wyye7ybb7QZm_-TQ,11695
-setta/tasks/utils.py,sha256=8MuTZ7vlVCJXkrLZ6Wc1KB4fkucjsb7fHhukeMW9_TM,16629
+setta/tasks/task_runner.py,sha256=gMXpfZWFMQbix2MfrHVCKB7BxQCjO8JH2P8cxUmt1ms,849
+setta/tasks/tasks.py,sha256=jhfTdncE6fMtxMUdnmixMbbtKV-Qu_xHLvbDkmm3M4g,10993
+setta/tasks/utils.py,sha256=iqbsLYBcu4Qd-MAHd0SWK9wPaJezgEh1Yg5YC9goOLU,10631
 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.dev5.dist-info/LICENSE,sha256=us9fuCq9wmiZVzayjKxNZ2iJYF6dROe0Qp57ToCO7XU,11361
-setta-0.0.14.dev5.dist-info/METADATA,sha256=WuaVIRGFo3c2OFa0v-oEEm6WRybmN8EBfGvlLQCe8UY,7517
-setta-0.0.14.dev5.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-setta-0.0.14.dev5.dist-info/entry_points.txt,sha256=P0qCESy9fWF2q1EQ9JufGldCSnPHplDPn8J6Bgk5hB0,42
-setta-0.0.14.dev5.dist-info/top_level.txt,sha256=8G4lmRzVOnJ11_DescPVHE6MQZH-o06A0nGsDDV2ngY,6
-setta-0.0.14.dev5.dist-info/RECORD,,
+setta-0.0.14.dev7.dist-info/LICENSE,sha256=us9fuCq9wmiZVzayjKxNZ2iJYF6dROe0Qp57ToCO7XU,11361
+setta-0.0.14.dev7.dist-info/METADATA,sha256=__vIVEdqunD4s14DQMi8rgEP6OOJEwD5isI9wH-6k3E,7517
+setta-0.0.14.dev7.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+setta-0.0.14.dev7.dist-info/entry_points.txt,sha256=P0qCESy9fWF2q1EQ9JufGldCSnPHplDPn8J6Bgk5hB0,42
+setta-0.0.14.dev7.dist-info/top_level.txt,sha256=8G4lmRzVOnJ11_DescPVHE6MQZH-o06A0nGsDDV2ngY,6
+setta-0.0.14.dev7.dist-info/RECORD,,