setta 0.0.3.dev3__py3-none-any.whl → 0.0.3.dev5__py3-none-any.whl

setta/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.3.dev3"
+__version__ = "0.0.3.dev5"

setta/cli/__init__.py

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

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/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)