setta 0.0.3.dev3__tar.gz → 0.0.3.dev6__tar.gz

{setta-0.0.3.dev3/backend/setta.egg-info → setta-0.0.3.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: setta
-Version: 0.0.3.dev3
+Version: 0.0.3.dev6
 Home-page: https://setta.dev
 Project-URL: GitHub, https://github.com/settadev/setta
 License-File: LICENSE

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

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

setta-0.0.3.dev6/backend/setta/cli/__init__.py

@@ -0,0 +1 @@
+from .logger import Setta, SettaImg, SettaList

{setta-0.0.3.dev3 → setta-0.0.3.dev6}/backend/setta/code_gen/create_runnable_scripts.py

@@ -402,8 +402,46 @@ def prune_and_topological_sort(code_dict, to_keep):
     return topological_sort(section_dependencies), section_dependencies
 
 
+# TODO: eliminate redundancy between this and prune_and_topological_sort
+def prune_and_find_top_nodes(code_dict, to_keep):
+    section_dependencies = {k: v["section_dependencies"] for k, v in code_dict.items()}
+    section_dependencies = prune_dict(section_dependencies, to_keep)
+    return find_top_nodes(section_dependencies), section_dependencies
+
+
+def get_import_order_for_top_node(top_node, dependency_dict):
+    # Build a subgraph consisting of top_node and all its descendants.
+    subgraph = get_subgraph(top_node, dependency_dict)
+    # Get a topologically sorted list where each dependency comes before the node that depends on it.
+    sorted_nodes = topological_sort(subgraph)
+    # Because you plan to import starting from the end of the list and work backwards,
+    # reverse the topological order so that the deepest dependency is imported first.
+    import_order = sorted_nodes[::-1]
+    return import_order
+
+
+def find_top_nodes(dependency_dict):
+    all_nodes = set(dependency_dict.keys())
+    all_deps = {dep for deps in dependency_dict.values() for dep in deps}
+    return all_nodes - all_deps
+
+
+def get_subgraph(top_node, dependency_dict):
+    visited = set()
+
+    def dfs(node):
+        if node not in visited:
+            visited.add(node)
+            for dep in dependency_dict.get(node, []):
+                dfs(dep)
+
+    dfs(top_node)
+    return {node: dependency_dict.get(node, []) for node in visited}
+
+
+# TODO: is this function actually necessary anymore?
 def topological_sort(objects):
-    graph = {id: refs for id, refs in objects.items()}
+    graph = {node: refs for node, refs in objects.items()}
     visiting, visited = set(), set()
     order = []
 
@@ -412,16 +450,15 @@ def topological_sort(objects):
             raise ValueError("Circular reference detected")
         if node not in visited:
             visiting.add(node)
-            for neighbour in graph[node]:
-                dfs(neighbour)
+            for neighbor in graph.get(node, []):
+                dfs(neighbor)
             visiting.remove(node)
             visited.add(node)
             order.append(node)
 
-    for id in objects.keys():
-        if id not in visited:
-            dfs(id)
-
+    for node in graph.keys():
+        if node not in visited:
+            dfs(node)
     return order[::-1]
 
 

{setta-0.0.3.dev3 → setta-0.0.3.dev6}/backend/setta/lsp/file_watcher.py

@@ -75,17 +75,34 @@ class LSPEventHandler(FileSystemEventHandler):
         self.callback = callback
         self.loop = loop
 
-    def on_any_event(self, event: FileSystemEvent):
+    def on_created(self, event: FileSystemEvent):
         if event.is_directory:
             return
+        changes = [{"uri": self._path_to_uri(event.src_path), "type": 1}]
+        self._send_changes(changes)
 
-        changes = [
-            {
-                "uri": self._path_to_uri(event.src_path),
-                "type": self._get_change_type(event),
-            }
-        ]
+    def on_modified(self, event: FileSystemEvent):
+        if event.is_directory:
+            return
+        changes = [{"uri": self._path_to_uri(event.src_path), "type": 2}]
+        self._send_changes(changes)
+
+    def on_deleted(self, event: FileSystemEvent):
+        if event.is_directory:
+            return
+        changes = [{"uri": self._path_to_uri(event.src_path), "type": 3}]
+        self._send_changes(changes)
 
+    def on_moved(self, event: FileSystemEvent):
+        if event.is_directory:
+            return
+        # Treat move as deletion of the old path and creation of the new path.
+        changes_del = [{"uri": self._path_to_uri(event.src_path), "type": 3}]
+        changes_cre = [{"uri": self._path_to_uri(event.dest_path), "type": 1}]
+        self._send_changes(changes_del)
+        self._send_changes(changes_cre)
+
+    def _send_changes(self, changes):
         if asyncio.iscoroutinefunction(self.callback):
             self.loop.call_soon_threadsafe(
                 lambda: self.loop.create_task(self.callback(changes))
@@ -94,20 +111,4 @@ class LSPEventHandler(FileSystemEventHandler):
             self.callback(changes)
 
     def _path_to_uri(self, path: str) -> str:
-        """Convert file path to URI format."""
         return Path(path).as_uri()
-
-    def _get_change_type(self, event: FileSystemEvent) -> int:
-        """
-        Convert watchdog event type to LSP change type.
-        1: Created
-        2: Changed
-        3: Deleted
-        """
-        if event.event_type == "created":
-            return 1
-        elif event.event_type == "modified":
-            return 2
-        elif event.event_type == "deleted":
-            return 3
-        return 2  # Default to changed

{setta-0.0.3.dev3 → setta-0.0.3.dev6}/backend/setta/lsp/server.py

@@ -147,4 +147,4 @@ class LanguageServerInteractor:
         return obj["version"]
 
     def get_code_metadata(self, uri):
-        return self.code_metadata[uri.lower()]
+        return self.code_metadata[uri]

{setta-0.0.3.dev3 → setta-0.0.3.dev6}/backend/setta/lsp/writer.py

@@ -268,7 +268,7 @@ class LanguageServerWriter(LanguageServerInteractor):
         asyncio.create_task(async_task)
 
     def get_workspace_uri(self):
-        return f"file://{self.workspace_folder}".lower()
+        return f"file://{self.workspace_folder}"
 
     def get_base_uri(self, code_id):
         return self.code_folder / f"{code_id}.py"
@@ -277,7 +277,7 @@ class LanguageServerWriter(LanguageServerInteractor):
     def get_uri(self, code_id, virtual):
         base_uri = self.get_base_uri(code_id)
         prefix = "untitled:" if virtual else "file://"
-        uri = f"{prefix}{base_uri}".lower()
+        uri = f"{prefix}{base_uri}"
         if platform.system() == "Windows":
             uri += "/"  # need trailing slash on Windows for some reason
         return uri

{setta-0.0.3.dev3 → setta-0.0.3.dev6}/backend/setta/routers/interactive.py

@@ -4,7 +4,8 @@ from pydantic import BaseModel
 
 from setta.code_gen.create_runnable_scripts import (
     generate_final_code_for_sections,
-    prune_and_topological_sort,
+    get_import_order_for_top_node,
+    prune_and_find_top_nodes,
     sanitize_section_path_full_name,
 )
 from setta.code_gen.export_selected import (
@@ -13,6 +14,7 @@ from setta.code_gen.export_selected import (
     get_section_code,
     get_section_type,
 )
+from setta.code_gen.find_placeholders import parse_template_var
 from setta.tasks.fns.utils import replace_template_vars_with_random_names
 from setta.utils.constants import C
 from setta.utils.utils import multireplace
@@ -23,7 +25,7 @@ router = APIRouter()
 
 
 class UpdateInteractiveCodeRequest(BaseModel):
-    project: dict
+    projects: list
 
 
 class FormatCodeRequest(BaseModel):
@@ -37,7 +39,19 @@ async def route_update_interactive_code(
     tasks=Depends(get_tasks),
     lsp_writers=Depends(get_lsp_writers),
 ):
-    p = x.project
+    idx = 0
+    dependencies = set()
+    content = []
+    for p in x.projects:
+        result = await update_interactive_code(p, tasks, lsp_writers, idx)
+        dependencies.update(result["dependencies"])
+        content.extend(result["content"])
+        idx += 1
+    dependencies = list(dependencies)
+    return {"dependencies": dependencies, "content": content}
+
+
+async def update_interactive_code(p, tasks, lsp_writers, idx):
     exporter_obj = export_selected(
         p, always_export_args_objs=False, force_include_template_var=True
     )
@@ -46,11 +60,11 @@ async def route_update_interactive_code(
     template_var_replacement_values = {}
     for variant in p["sectionVariants"].values():
         for t in variant["templateVars"]:
-            if not t["sectionId"]:
-                continue
-            template_var_replacement_values[
-                t["keyword"]
-            ] = create_in_memory_module_name(p, t["sectionId"])
+            _, keyword_type = parse_template_var(t["keyword"])
+            if t["sectionId"] and keyword_type == C.TEMPLATE_VAR_IMPORT_PATH_SUFFIX:
+                template_var_replacement_values[
+                    t["keyword"]
+                ] = create_in_memory_module_name(p, t["sectionId"])
 
     code_dict = await generate_final_code_for_sections(
         p,
@@ -62,24 +76,29 @@ async def route_update_interactive_code(
         template_var_replacement_values=template_var_replacement_values,
     )
 
-    to_import, _ = prune_and_topological_sort(code_dict, p["importCodeBlocks"])
-    to_import = to_import[::-1]  # we want to import the dependencies first
-    code_list = []
-    for section_id in to_import:
-        v = code_dict[section_id]
-        task_name = create_in_memory_module_name(p, section_id)
-        code_list.append(
+    top_node_ids, section_dependencies = prune_and_find_top_nodes(
+        code_dict, p["runCodeBlocks"]
+    )
+    code_graph = []
+    project_config_id = p["projectConfig"]["id"]
+    for section_id in top_node_ids:
+        code_graph.append(
             {
-                "code": v["code"],
-                "module_name": task_name,
+                "subprocess_key": f"{project_config_id}-{section_id}-{idx}",
+                "code": code_dict[section_id]["code"],
+                "imports": get_import_order_for_top_node(
+                    section_id, section_dependencies
+                ),
+                "module_name": create_in_memory_module_name(p, section_id),
             }
         )
 
-    metadata, error_msgs, content = await tasks.add_custom_fns(
-        code_list,
+    dependencies, content = await tasks.add_custom_fns(
+        code_graph,
         to_cache=exporter_obj_in_memory,
     )
-    return {"metadata": metadata, "errorMsgs": error_msgs, "content": content}
+
+    return {"dependencies": dependencies, "content": content}
 
 
 @router.post(C.ROUTE_FORMAT_CODE)