setta 0.0.2.dev0__py3-none-any.whl → 0.0.3__py3-none-any.whl

setta/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.2.dev0"
+__version__ = "0.0.3"

setta/cli/__init__.py

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

setta/cli/logger.py

@@ -26,9 +26,7 @@ class Setta:
         if root_path:
             self.root_path = Path(root_path)
         else:
-            self.root_path = Path(
-                os.environ.get(CODE_FOLDER_ENV_VARIABLE, os.path.relpath(os.getcwd()))
-            )
+            self.root_path = Path(os.environ.get(CODE_FOLDER_ENV_VARIABLE, "."))
 
         self.name_path_type_to_id = {}
 

setta/code_gen/create_runnable_scripts.py

@@ -1,15 +1,15 @@
 import copy
-import os
 from datetime import datetime
 from pathlib import Path
 
 from setta.code_gen.export_selected import (
     export_selected,
     get_gen_code_template_var,
+    get_section_name,
     get_section_type,
     get_selected_section_variant,
 )
-from setta.code_gen.find_placeholders import remove_tp, tp
+from setta.code_gen.find_placeholders import parse_template_var, tp
 from setta.code_gen.python.generate_code import (
     convert_var_names_to_readable_form,
     generate_code,
@@ -23,6 +23,7 @@ from setta.code_gen.utils import process_refs
 from setta.utils.constants import (
     CODE_FOLDER,
     CODE_FOLDER_ENV_VARIABLE,
+    CWD,
     USER_SETTINGS,
     C,
 )
@@ -56,13 +57,13 @@ async def runCode(message, lsp_writers):
     id_to_relpath = {}
     for sid in to_write:
         curr_code = code_dict[sid]
-        rel_path = write_code_to_file(
+        rel_path_str = write_code_to_file(
             folder_path,
             curr_code["sanitized_full_name"],
             curr_code["code"],
             curr_code["codeLanguage"],
         )
-        id_to_relpath[sid] = rel_path
+        id_to_relpath[sid] = rel_path_str
 
     # Only run code that isn't referenced by other code
     run_order = [
@@ -71,8 +72,8 @@ async def runCode(message, lsp_writers):
 
     # create a wrapper script if there are multiple files to run
     if len(run_order) > 1:
-        rel_path = create_wrapper_bash_script(folder_path, run_order, code_dict)
-        command = codeCallStr(rel_path, "bash")
+        rel_path_str = create_wrapper_bash_script(folder_path, run_order, code_dict)
+        command = codeCallStr(rel_path_str, "bash")
     else:
         sid = run_order[0]
         command = codeCallStr(id_to_relpath[sid], code_dict[sid]["codeLanguage"])
@@ -280,17 +281,41 @@ def get_template_var_replacement_value_fn(
                     chars_before_template_var,
                 )
             else:
-                section_dependencies.append(template_var["sectionId"])
-                keyword = remove_tp(keyword)
-                return construct_module_path(folder_path, keyword)
+                return process_non_hardcoded_template_var(
+                    keyword,
+                    template_var,
+                    exporter_obj,
+                    section_dependencies,
+                    folder_path,
+                )
+
         elif codeLanguage == "bash":
-            section_dependencies.append(template_var["sectionId"])
-            keyword = sanitize_section_path_full_name(remove_tp(keyword))
-            return codePathStr(Path(os.path.relpath(folder_path)), keyword, "python")
+            return process_non_hardcoded_template_var(
+                keyword, template_var, exporter_obj, section_dependencies, folder_path
+            )
 
     return get_template_var_replacement_value
 
 
+def process_non_hardcoded_template_var(
+    keyword, template_var, exporter_obj, section_dependencies, folder_path
+):
+    keyword, keyword_type = parse_template_var(keyword)
+    if keyword_type == C.TEMPLATE_VAR_IMPORT_PATH_SUFFIX:
+        section_dependencies.append(template_var["sectionId"])
+        return construct_module_path(folder_path, keyword)
+    elif keyword_type == C.TEMPLATE_VAR_VERSION_SUFFIX:
+        version_name = get_selected_section_variant(
+            exporter_obj.p, template_var["sectionId"]
+        )["name"]
+        section_name = get_section_name(exporter_obj.p, template_var["sectionId"])
+        return f'"{section_name}@{version_name}"'
+    elif keyword_type == C.TEMPLATE_VAR_FILE_PATH_SUFFIX:
+        section_dependencies.append(template_var["sectionId"])
+        keyword = sanitize_section_path_full_name(keyword)
+        return f'"{codePathStr(folder_path, keyword, "python")}"'
+
+
 def get_absolute_decl_position_from_rel_position(
     template_var, var_name_to_decl_rel_position_dict
 ):
@@ -337,7 +362,7 @@ def preprocess_template_vars(code, evRefs, templateVars, cursor_position):
 
 
 def convert_folder_path_to_module_path(folder_path):
-    return os.path.relpath(folder_path).replace("/", ".").replace("\\", ".")
+    return folder_path.relative_to(CWD).as_posix().replace("/", ".").replace("\\", ".")
 
 
 def languageToExtension(x):
@@ -351,7 +376,7 @@ def languageToCall(x):
 def codePathStr(folder_path, filename, codeLanguage):
     extension = languageToExtension(codeLanguage)
     output = folder_path / f"{filename}{extension}"
-    return os.path.relpath(output).replace(os.sep, "/")
+    return output.relative_to(CWD).as_posix()
 
 
 def codeCallStr(filepath, codeLanguage):
@@ -377,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 = []
 
@@ -387,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]
 
 
@@ -407,28 +469,19 @@ def create_timestamped_folder(base_dir, prefix=""):
     folder_name = f"_{prefix}{timestamp}"
     # Full path for the new folder
     folder_path = Path(base_dir) / folder_name
-
-    if not os.path.exists(folder_path):
-        try:
-            os.makedirs(folder_path)
-        except FileExistsError:
-            pass
-
+    folder_path.mkdir(parents=True, exist_ok=True)
     return folder_path
 
 
 def write_code_to_file(folder_path, filename, code, codeLanguage):
     extension = languageToExtension(codeLanguage)
     filepath = write_string_to_file(folder_path, f"{filename}{extension}", code)
-    return os.path.relpath(filepath).replace(os.sep, "/")
+    return filepath.relative_to(CWD).as_posix()
 
 
 def write_string_to_file(folder, filename, content):
-    # Full path to the file
-    file_path = os.path.join(folder, filename)
-    # Write the content to the file
-    with open(file_path, "w") as file:
-        file.write(content)
+    file_path = Path(folder) / filename
+    file_path.write_text(content)
     return file_path
 
 

setta/code_gen/export_selected.py

@@ -11,10 +11,6 @@ from .find_placeholders import tp
 from .utils import process_refs
 
 
-def get_args_var_name(var_name):
-    return f"{C.ARGS_PREFIX}{var_name}"
-
-
 def get_section_type(p, id):
     ui_type_id = p["sections"][id]["uiTypeId"]
     ui_type = p["uiTypes"].get(ui_type_id) or BASE_UI_TYPES[ui_type_id]
@@ -144,7 +140,7 @@ def no_entered_value(value):
 
 
 def get_var_name(var_name_mapping):
-    return f"__x{len(var_name_mapping)}"
+    return f"{C.ARGS_PREFIX}x{len(var_name_mapping)}"
 
 
 def get_for_section_id(p, section_id):

setta/code_gen/find_placeholders.py

@@ -9,5 +9,16 @@ def remove_tp(x):
     return x.lstrip(C.TEMPLATE_PREFIX)
 
 
-def needs_yaml(script):
-    return tp("SETTA_YAML_FILE") in script
+def parse_template_var(template_str: str) -> tuple[str, str | None]:
+    suffixes = [
+        f"{tp(C.TEMPLATE_VAR_IMPORT_PATH_SUFFIX)}",
+        f"{tp(C.TEMPLATE_VAR_VERSION_SUFFIX)}",
+        f"{tp(C.TEMPLATE_VAR_FILE_PATH_SUFFIX)}",
+    ]
+
+    for suffix in suffixes:
+        if template_str.endswith(suffix):
+            base_str = remove_tp(template_str[: -len(suffix)])
+            return base_str, remove_tp(suffix)
+
+    return template_str, None

setta/database/backup.py

@@ -1,5 +1,4 @@
 import logging
-import os
 import shutil
 import time
 from datetime import datetime
@@ -54,7 +53,7 @@ def create_backup(db_path):
     ensure_backup_dir_exists()
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     backup_filename = f"backup_{timestamp}.db"
-    backup_path = os.path.join(DB_BACKUP_FOLDER, backup_filename)
+    backup_path = DB_BACKUP_FOLDER / backup_filename
     logger.debug(f"creating backup: {backup_path}")
 
     shutil.copy2(db_path, backup_path)

setta/database/db/artifacts/save.py

@@ -35,23 +35,28 @@ def save_artifacts(db, artifacts):
     db.executemany(query, query_params)
 
 
-def save_artifact_groups(db, artifact_groups):
+def save_artifact_groups(db, artifact_groups, sections):
     query = """
-        INSERT INTO ArtifactGroupId (id, name, data)
-        VALUES (:id, :name, :data)
+        INSERT INTO ArtifactGroupId (id, name, data, "order")
+        VALUES (:id, :name, :data, :order)
         ON CONFLICT (id)
         DO UPDATE SET
         name = :name,
-        data = :data
+        data = :data,
+        "order" = :order
     """
     query_params = []
     for k, group in artifact_groups.items():
+        order = get_artifact_group_idx(k, sections)
+        if order is None:
+            continue
         data_keys = group.keys() - {"name", "artifactTransforms"}
         query_params.append(
             {
                 "id": k,
                 "name": group["name"],
                 "data": json.dumps(filter_dict(group, data_keys)),
+                "order": order,
             }
         )
     db.executemany(query, query_params)
@@ -83,3 +88,14 @@ def save_artifact_groups(db, artifact_groups):
             )
 
     db.executemany(query, query_params)
+
+
+def get_artifact_group_idx(artifact_group_id, sections):
+    for section in sections.values():
+        try:
+            if "artifactGroupIds" in section:
+                idx = section["artifactGroupIds"].index(artifact_group_id)
+                return idx
+        except ValueError:
+            continue
+    return None

setta/database/db/projects/save.py

@@ -25,7 +25,7 @@ def save_project_details(db, p):
     save_json_source_data(p)
     remove_json_source_data(p)
     save_artifacts(db, p["artifacts"])
-    save_artifact_groups(db, p["artifactGroups"])
+    save_artifact_groups(db, p["artifactGroups"], p["sections"])
     save_code_info(db, p["codeInfo"])
     save_code_info_col(db, p["codeInfoCols"])
     save_ui_types(db, p["uiTypes"])

setta/database/db/sections/load.py

@@ -57,8 +57,11 @@ def load_sections(db, ids):
                 SELECT
                     originSectionId,
                     GROUP_CONCAT(id) AS artifactGroupIds
-                FROM
-                    ArtifactGroupId
+                FROM (
+                    SELECT id, originSectionId
+                    FROM ArtifactGroupId
+                    ORDER BY "order"
+                )
                 GROUP BY
                     originSectionId
             ) AS A ON S.id = A.originSectionId

setta/database/db/sections/save.py

@@ -110,14 +110,14 @@ def save_sections(db, sections, section_variants):
     query = """
         UPDATE ArtifactGroupId
         SET originSectionId = :sectionId
-        WHERE id = :artifactId
+        WHERE id = :artifactGroupId
     """
     for s in sections.values():
         for a in s["artifactGroupIds"]:
             query_params.append(
                 {
                     "sectionId": s["id"],
-                    "artifactId": a,
+                    "artifactGroupId": a,
                 }
             )
     db.executemany(query, query_params)

setta/database/db_objs.py

@@ -1,6 +1,8 @@
 import queue
 import sqlite3
 
+from setta.utils.constants import SETTA_FILES_FOLDER
+
 
 class DB:
     def __init__(self, path):
@@ -100,3 +102,7 @@ class DBQueue:
     def __exit__(self, *args, **kwargs):
         self.curr.__exit__(*args, **kwargs)
         self.put_back_curr()
+
+
+def get_default_db_path():
+    return SETTA_FILES_FOLDER / "setta.db"

setta/database/export_db/export_raw.py

@@ -1,9 +1,9 @@
 import logging
-import os
-from pathlib import Path
 
 import yaml
 
+from setta.utils.constants import SETTA_FILES_FOLDER
+
 logger = logging.getLogger(__name__)
 
 
@@ -26,7 +26,7 @@ def export_raw(db, filename):
     yaml.add_representer(str, literal_presenter)
 
     # For YAML export, PyYAML is used; ensure it's installed
-    filepath = Path(os.getcwd()) / f"{filename}_export.yaml"
+    filepath = SETTA_FILES_FOLDER / f"{filename}_export.yaml"
     logger.debug(f"saving raw db to {filepath}")
     with open(filepath, "w") as file:
         yaml.dump(database_export, file, allow_unicode=True, sort_keys=False)

setta/database/export_db/utils.py

@@ -1,16 +1,15 @@
-import os
 from collections import defaultdict
-from pathlib import Path
 
 import yaml
 from yaml.representer import Representer
 
 from setta.database.db.projects.load import load_full_project
+from setta.utils.constants import SETTA_FILES_FOLDER
 
 
 def get_configs_and_root_folder(db, filename):
     # export defaultdict the same way as dict
     yaml.add_representer(defaultdict, Representer.represent_dict)
     configs = load_full_project(db)
-    root_folder = Path(os.getcwd()) / f"{filename}_export"
+    root_folder = SETTA_FILES_FOLDER / f"{filename}_export"
     return configs, root_folder

setta/database/settings_file.py

@@ -11,7 +11,7 @@ from setta.database.db.sections.jsonSource import (
     remove_json_source_data,
     save_json_source_data,
 )
-from setta.utils.constants import CONSTANTS_FOLDER, USER_SETTINGS
+from setta.utils.constants import CONSTANTS_FOLDER, SETTA_FILES_FOLDER, USER_SETTINGS
 from setta.utils.utils import get_absolute_path, save_json_to_file
 
 logger = logging.getLogger(__name__)
@@ -63,8 +63,8 @@ class MetaSettingsFile:
         self.path_seed_meta_settings = get_absolute_path(
             __file__, CONSTANTS_FOLDER / "settingsProject.json"
         )
-        self.path_default_settings = "setta-settings.json"
-        self.path_meta_settings = "setta-meta-settings.json"
+        self.path_default_settings = SETTA_FILES_FOLDER / "setta-settings.json"
+        self.path_meta_settings = SETTA_FILES_FOLDER / "setta-meta-settings.json"
         self.load_seed_files()
 
     def get_settings_paths(self):

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/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/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/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,18 @@ async def route_update_interactive_code(
     tasks=Depends(get_tasks),
     lsp_writers=Depends(get_lsp_writers),
 ):
-    p = x.project
+    idx = 0
+    content = []
+    for p in x.projects:
+        initialContent = await update_interactive_code(p, tasks, lsp_writers, idx)
+        content.extend(initialContent)
+        idx += 1
+
+    inMemorySubprocessInfo = tasks.getInMemorySubprocessInfo()
+    return {"inMemorySubprocessInfo": inMemorySubprocessInfo, "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 +59,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 +75,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,
+    initialContent = await tasks.add_custom_fns(
+        code_graph,
         to_cache=exporter_obj_in_memory,
     )
-    return {"metadata": metadata, "errorMsgs": error_msgs, "content": content}
+
+    return initialContent
 
 
 @router.post(C.ROUTE_FORMAT_CODE)