setta 0.0.2__tar.gz → 0.0.3__tar.gz

setta-0.0.3/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.2
+Name: setta
+Version: 0.0.3
+Summary: Python without the donkeywork.
+Home-page: https://setta.dev
+Author: Kevin Musgrave, Jeff Musgrave
+License: Apache-2.0
+Project-URL: GitHub, https://github.com/settadev/setta
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.8
+Requires-Dist: requests>=2.32.3
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: websockets>=15.0
+Requires-Dist: fastapi>=0.115.8
+Requires-Dist: uvicorn>=0.34.0
+Requires-Dist: docstring_parser>=0.16
+Requires-Dist: pywinpty>=2.0.15; platform_system == "Windows"
+Requires-Dist: ptyprocess>=0.7.0; platform_system != "Windows"
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: basedpyright>=1.27.1
+Requires-Dist: docstring-to-markdown>=0.15
+Requires-Dist: black>=23.7.0
+Requires-Dist: watchdog>=6.0.0
+Provides-Extra: dev
+Requires-Dist: black==23.7.0; extra == "dev"
+Requires-Dist: build==1.0.3; extra == "dev"
+Requires-Dist: isort==5.12.0; extra == "dev"
+Requires-Dist: flake8==6.1.0; extra == "dev"
+
+![Setta Logo](images/setta-github-light.png#gh-light-mode-only)
+![Setta Logo](images/setta-github-dark.png#gh-dark-mode-only)
+
+
+# Python Without The Donkeywork
+
+https://github.com/user-attachments/assets/0599b754-1fbc-470b-ad6f-ac44b01da761
+
+[![PyPI version](https://badge.fury.io/py/setta.svg)](https://badge.fury.io/py/setta)
+[![License](https://img.shields.io/pypi/l/setta)](https://github.com/settadev/setta/blob/main/LICENSE)
+[![Discord](https://img.shields.io/badge/Discord-Join-7389D8?logo=discord&logoColor=white)](https://discord.gg/MmHJz75bZ5)
+
+## What does Setta do?
+Setta enables you to:
+- Streamline your code. 
+- Skip the boilerplate parsers and frontend. 
+- Effortlessly expose your Python functions as a flexible UI. 
+- Configure, interact, and share with ease.
+
+## What Setta Is Not
+Setta is **not**:
+- A frontend framework.
+- A visual programming system.
+
+## Why Setta Is Betta
+
+
+<table>
+  <tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Built for Devs</h3>
+      <ul>
+        <li>Write your core logic wherever you want, whether that’s inside a Setta code block, or in your favorite IDE.</li>
+        <li>Set your configs inside Setta, with autocompletions, type-checking, and refactoring support.</li>
+        <li>Run. No config parsers needed.</li>
+        <li>Auto-export your Setta projects in a Git-friendly yaml format.</li>
+      </ul>
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/ab5786d4-cf3f-4f8d-8951-7a9fd4a9f9bf" />
+    </td>
+  </tr>
+  <tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Powerful Config Management</h3>
+      <ul>
+        <li>Version your configs at a granular level.</li>
+        <li>Share configurations between projects.</li>
+        <li>Run param sweeps across both scalar values and config versions.</li>
+      </ul>
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/3303294e-20e7-419a-8274-57ac8e5aea92" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Customizable, Integrated Documentation</h3>
+      Integrate your documentation, tooltips, markdown, social content, and images to make your configurations more approachable.
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/d08bcede-06b5-4b66-9559-c3f7574e5894" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Flexible UI</h3>
+      <ul>
+        <li>Create, organize and set your configs in a flexible drag-and-drop user interface.</li>
+        <li>Utilize common UI types like sliders, color pickers, switches, and text input fields.</li>
+      </ul>
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/8730c9f3-dbcb-47af-8290-a5d460e82e4b" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Monitor Long Running Scripts</h3>
+      Configure your machine-learning training runs, LLM evals, and data analysis scripts.
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/a118f895-19c5-4d0f-bebe-4a0b594ee405" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Interact In Real-Time</h3>
+      Inpaint your AI images and adjust data visualizations with real-time outputs in Setta.
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/3e04c72f-3422-40b7-ba08-328b4534ea2b" />
+    </td>
+  </tr>
+</table>
+
+
+## Installation
+
+```
+pip install setta
+```
+
+## Documentation
+
+Documentation is in progress: https://docs.setta.dev/
+
+## Examples
+
+Examples showing how to use Setta will be here: https://github.com/settadev/examples
+
+
+## Contributors
+
+- [Kevin Musgrave](https://github.com/KevinMusgrave): co-creator & full-stack developer.
+- [Jeff Musgrave](https://github.com/JeffMusgrave): co-creator, UI/UX developer, frontend developer, and designer.

setta-0.0.3/README.md

@@ -0,0 +1,116 @@
+![Setta Logo](images/setta-github-light.png#gh-light-mode-only)
+![Setta Logo](images/setta-github-dark.png#gh-dark-mode-only)
+
+
+# Python Without The Donkeywork
+
+https://github.com/user-attachments/assets/0599b754-1fbc-470b-ad6f-ac44b01da761
+
+[![PyPI version](https://badge.fury.io/py/setta.svg)](https://badge.fury.io/py/setta)
+[![License](https://img.shields.io/pypi/l/setta)](https://github.com/settadev/setta/blob/main/LICENSE)
+[![Discord](https://img.shields.io/badge/Discord-Join-7389D8?logo=discord&logoColor=white)](https://discord.gg/MmHJz75bZ5)
+
+## What does Setta do?
+Setta enables you to:
+- Streamline your code. 
+- Skip the boilerplate parsers and frontend. 
+- Effortlessly expose your Python functions as a flexible UI. 
+- Configure, interact, and share with ease.
+
+## What Setta Is Not
+Setta is **not**:
+- A frontend framework.
+- A visual programming system.
+
+## Why Setta Is Betta
+
+
+<table>
+  <tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Built for Devs</h3>
+      <ul>
+        <li>Write your core logic wherever you want, whether that’s inside a Setta code block, or in your favorite IDE.</li>
+        <li>Set your configs inside Setta, with autocompletions, type-checking, and refactoring support.</li>
+        <li>Run. No config parsers needed.</li>
+        <li>Auto-export your Setta projects in a Git-friendly yaml format.</li>
+      </ul>
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/ab5786d4-cf3f-4f8d-8951-7a9fd4a9f9bf" />
+    </td>
+  </tr>
+  <tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Powerful Config Management</h3>
+      <ul>
+        <li>Version your configs at a granular level.</li>
+        <li>Share configurations between projects.</li>
+        <li>Run param sweeps across both scalar values and config versions.</li>
+      </ul>
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/3303294e-20e7-419a-8274-57ac8e5aea92" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Customizable, Integrated Documentation</h3>
+      Integrate your documentation, tooltips, markdown, social content, and images to make your configurations more approachable.
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/d08bcede-06b5-4b66-9559-c3f7574e5894" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Flexible UI</h3>
+      <ul>
+        <li>Create, organize and set your configs in a flexible drag-and-drop user interface.</li>
+        <li>Utilize common UI types like sliders, color pickers, switches, and text input fields.</li>
+      </ul>
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/8730c9f3-dbcb-47af-8290-a5d460e82e4b" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Monitor Long Running Scripts</h3>
+      Configure your machine-learning training runs, LLM evals, and data analysis scripts.
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/a118f895-19c5-4d0f-bebe-4a0b594ee405" />
+    </td>
+  </tr>
+<tr>
+    <td style="vertical-align: top; padding-right: 20px;">
+      <h3>Interact In Real-Time</h3>
+      Inpaint your AI images and adjust data visualizations with real-time outputs in Setta.
+    </td>
+    <td style="vertical-align: top;">
+      <video src="https://github.com/user-attachments/assets/3e04c72f-3422-40b7-ba08-328b4534ea2b" />
+    </td>
+  </tr>
+</table>
+
+
+## Installation
+
+```
+pip install setta
+```
+
+## Documentation
+
+Documentation is in progress: https://docs.setta.dev/
+
+## Examples
+
+Examples showing how to use Setta will be here: https://github.com/settadev/examples
+
+
+## Contributors
+
+- [Kevin Musgrave](https://github.com/KevinMusgrave): co-creator & full-stack developer.
+- [Jeff Musgrave](https://github.com/JeffMusgrave): co-creator, UI/UX developer, frontend developer, and designer.

setta-0.0.3/backend/setta/__init__.py

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

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

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

{setta-0.0.2 → setta-0.0.3}/backend/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-0.0.2 → setta-0.0.3}/backend/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-0.0.2 → setta-0.0.3}/backend/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-0.0.3/backend/setta/code_gen/find_placeholders.py

@@ -0,0 +1,24 @@
+from setta.utils.constants import C
+
+
+def tp(x):
+    return f"{C.TEMPLATE_PREFIX}{x}"
+
+
+def remove_tp(x):
+    return x.lstrip(C.TEMPLATE_PREFIX)
+
+
+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-0.0.2 → setta-0.0.3}/backend/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-0.0.2 → setta-0.0.3}/backend/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-0.0.2 → setta-0.0.3}/backend/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-0.0.2 → setta-0.0.3}/backend/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-0.0.2 → setta-0.0.3}/backend/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-0.0.2 → setta-0.0.3}/backend/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"