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

setta/database/db/projects/load.py

@@ -0,0 +1,184 @@
+import json
+
+from setta.database.db.evRefs.load import (
+    load_ev_refs_into_data_structures,
+    load_template_vars_into_data_structures,
+)
+from setta.database.db.projects.utils import with_project_config_defaults
+from setta.utils.utils import recursive_dict_merge
+
+from ..codeInfo.load import load_code_info_cols
+from ..sections.load import (
+    load_json_sources_into_data_structures,
+    load_section_configs,
+    load_sections,
+)
+
+
+class ProjectNotFound(Exception):
+    pass
+
+
+def load_all_project_config_metadata(db):
+    query = """
+        SELECT
+            pc.id,
+            pc.name,
+            pc.data,
+            pcc.x,
+            pcc.y,
+            pcc.zIndex,
+            pcc.w,
+            pcc.h
+        FROM
+            ProjectConfig pc
+        LEFT JOIN
+            ProjectConfigChildren pcc ON pc.id = pcc.parentId
+        ORDER BY
+            pc.id;
+    """
+    db.execute(query)
+    output = {}
+    for row in db.fetchall():
+        id = row["id"]
+        if id not in output:
+            output[id] = with_project_config_defaults(
+                id=row["id"],
+                name=row["name"],
+                childrenForPreviewImg=[],
+                **json.loads(row["data"]),
+            )
+        if row["x"]:
+            output[id]["childrenForPreviewImg"].append(
+                {
+                    "x": row["x"],
+                    "y": row["y"],
+                    "zIndex": row["zIndex"],
+                    "w": row["w"],
+                    "h": row["h"],
+                }
+            )
+
+    default_name = load_default_config_name(db)
+    return list(output.values()), default_name
+
+
+def load_project_config_metadata(db, config_name):
+    query = """
+        SELECT
+            ProjectConfig.id,
+            ProjectConfig.name,
+            ProjectConfig.data,
+            pcc.childId as childId,
+            pcc.x,
+            pcc.y,
+            pcc.zIndex,
+            pcc.w,
+            pcc.h
+        FROM
+            ProjectConfig
+        LEFT JOIN
+            ProjectConfigChildren pcc
+        ON
+            ProjectConfig.id = pcc.parentId
+        WHERE
+            name = :name
+    """
+
+    query_params = {"name": config_name}
+    db.execute(query, query_params)
+    output = {}
+    for row in db.fetchall():
+        id = row["id"]
+        if id not in output:
+            output[id] = with_project_config_defaults(
+                id=row["id"],
+                name=row["name"],
+                **json.loads(row["data"]),
+            )
+        if row["childId"]:
+            output[id]["children"][row["childId"]] = {
+                "x": row["x"],
+                "y": row["y"],
+                "zIndex": row["zIndex"],
+                "w": row["w"],
+                "h": row["h"],
+            }
+
+    if len(output) > 1:
+        raise ValueError(f"output should be of length 1 but has length {len(output)}")
+    if len(output) == 0:
+        raise ProjectNotFound(f"{config_name} not found")
+
+    return list(output.values())[0]
+
+
+def load_project_config(db, project_config_name):
+    projectConfig = load_project_config_metadata(db, project_config_name)
+    sections_data = load_sections(db, list(projectConfig["children"].keys()))
+    sectionConfigs = load_section_configs(db, projectConfig["id"])
+    sections = recursive_dict_merge(
+        sections_data["sections"], sectionConfigs, strict_top_level_keys=True
+    )
+    sectionVariants = sections_data["sectionVariants"]
+    artifactGroups = sections_data["artifactGroups"]
+    uiTypeCols = sections_data["uiTypeCols"]
+    uiTypes = sections_data["nonPresetUITypes"]
+    codeInfo, codeInfoCols = load_code_info_cols(db, sectionVariants)
+    load_ev_refs_into_data_structures(db, sectionVariants, codeInfo)
+    load_template_vars_into_data_structures(db, sectionVariants)
+    load_json_sources_into_data_structures(
+        sections, codeInfo, codeInfoCols, sectionVariants
+    )
+
+    return {
+        "projectConfig": projectConfig,
+        "sections": sections,
+        "sectionVariants": sectionVariants,
+        "artifactGroups": artifactGroups,
+        "uiTypes": uiTypes,
+        "uiTypeCols": uiTypeCols,
+        "codeInfo": codeInfo,
+        "codeInfoCols": codeInfoCols,
+    }
+
+
+def load_project_config_names(db, excludeProjectConfigName=None):
+    query = """
+        SELECT
+            name
+        FROM
+            ProjectConfig
+    """
+
+    if excludeProjectConfigName:
+        query += "WHERE name != :excludeProjectConfigName"
+
+    db.execute(query, {"excludeProjectConfigName": excludeProjectConfigName})
+
+    return [r[0] for r in db.fetchall()]
+
+
+def load_full_project(db, excludeProjectConfigName=None):
+    config_names = load_project_config_names(db, excludeProjectConfigName)
+    configs = []
+    for c in config_names:
+        p = load_project_config(db, c)
+        configs.append(p)
+
+    return configs
+
+
+def load_default_config_name(db):
+    query = """
+        SELECT pc.name
+        FROM Metadata m
+        JOIN ProjectConfig pc ON m.defaultProject = pc.id
+        WHERE m.id = 1;
+    """
+
+    db.execute(query)
+    results = db.fetchall()
+    if len(results) > 0:
+        return results[0][0]
+    return None

setta/database/db/projects/save.py

@@ -0,0 +1,267 @@
+import json
+from collections import defaultdict
+
+from setta.code_gen.export_selected import get_section_variants
+from setta.database.db.artifacts.save import save_artifact_groups, save_artifacts
+from setta.database.db.evRefs.save import save_ev_refs, save_template_vars
+from setta.database.utils import create_new_id
+from setta.utils.constants import (
+    DEFAULT_VALUES,
+    PROJECT_CONFIG_TABLE_DATA_JSON_FIELDS,
+    SECTION_CONFIG_TABLE_DATA_JSON_FIELDS,
+    USER_SETTINGS,
+)
+from setta.utils.generate_memorable_string import generate_memorable_available_string
+from setta.utils.utils import filter_dict
+
+from ..codeInfo.save import save_code_info, save_code_info_col
+from ..sections.jsonSource import remove_json_source_data, save_json_source_data
+from ..sections.save import save_sections
+from ..sectionVariants.save import save_section_variants
+from ..uiTypes.save import save_ui_type_cols, save_ui_types
+
+
+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_code_info(db, p["codeInfo"])
+    save_code_info_col(db, p["codeInfoCols"])
+    save_ui_types(db, p["uiTypes"])
+    save_ui_type_cols(db, p["uiTypeCols"])
+    save_section_variants(db, p["sectionVariants"])
+    save_sections(db, p["sections"], p["sectionVariants"])
+    save_ev_refs(db, p["sectionVariants"], p["codeInfo"])
+    save_template_vars(db, p["sectionVariants"])
+    save_project(db, p["projectConfig"])
+    save_section_configs(db, p["projectConfig"]["id"], p["sections"])
+    update_linked_project_configs(db, p)
+
+
+def save_project(db, project):
+    query = """
+        INSERT INTO ProjectConfig (id, name, data)
+        VALUES (:id, :name, :data)
+        ON CONFLICT (id)
+        DO UPDATE SET
+        name = :name,
+        data = :data
+    """
+
+    query_params = {
+        "id": project["id"],
+        "name": project["name"],
+        "data": json.dumps(
+            filter_dict(
+                project,
+                PROJECT_CONFIG_TABLE_DATA_JSON_FIELDS,
+                DEFAULT_VALUES["projectConfig"],
+            )
+        ),
+    }
+    db.execute(query, query_params)
+
+    query = """
+        DELETE FROM ProjectConfigChildren
+        WHERE parentId = :parentId
+    """
+    db.execute(query, {"parentId": project["id"]})
+
+    query = """
+        INSERT INTO ProjectConfigChildren (parentId, childId, x, y, zIndex, w, h)
+        VALUES (:parentId, :childId, :x, :y, :zIndex, :w, :h)
+    """
+    query_params = []
+    query_params.extend(
+        [
+            {
+                "parentId": project["id"],
+                "childId": childId,
+                "x": details["x"],
+                "y": details["y"],
+                "zIndex": details["zIndex"],
+                "w": details["w"],
+                "h": details["h"],
+            }
+            for childId, details in project["children"].items()
+        ]
+    )
+    db.executemany(query, query_params)
+
+
+def create_project_config(db, name, previewImgColor):
+    query = """
+        SELECT name
+        FROM ProjectConfig
+    """
+    db.execute(query)
+    taken_names = [row[0] for row in db.fetchall()]
+
+    name = generate_memorable_available_string(taken_names)
+
+    query = """
+        INSERT INTO ProjectConfig (id, name, data)
+        VALUES (:id, :name, :data)
+    """
+    projectId = create_new_id()
+    query_params = {
+        "id": projectId,
+        "name": name,
+        "data": json.dumps(
+            {
+                "previewImgColor": previewImgColor,
+                "viewport": {
+                    "x": 0,
+                    "y": 0,
+                    "zoom": USER_SETTINGS["gui"]["defaultZoomLevel"],
+                },
+            }
+        ),
+    }
+    db.execute(query, query_params)
+    return name
+
+
+def save_project_config_name(db, curr_name, new_name):
+    query = """
+        UPDATE ProjectConfig
+        SET name = :new_name
+        WHERE name = :curr_name
+    """
+    query_params = {"curr_name": curr_name, "new_name": new_name}
+    db.execute(query, query_params)
+
+
+def set_as_default_project(db, projectId):
+    query = """
+        UPDATE Metadata
+        SET defaultProject = :projectId
+        WHERE id = 1;
+    """
+    db.execute(query, {"projectId": projectId})
+
+
+def save_section_configs(db, project_config_id, sections):
+    query_params = []
+    for section_id in sections.keys():
+        query_params.extend([project_config_id, section_id])
+    placeholders = ", ".join(["(?, ?)"] * (len(query_params) // 2))
+    query = f"""
+        DELETE FROM SectionConfig
+        WHERE (projectConfigId, sectionId) IN ({placeholders})
+    """
+    db.execute(query, query_params)
+
+    query = f"""
+        DELETE FROM SectionConfigSelectedVariants
+        WHERE (projectConfigId, sectionId) IN ({placeholders})
+    """
+    db.execute(query, query_params)
+
+    id_pairs = [(project_config_id, s) for s in sections.keys()]
+    insert_section_configs(db, sections, id_pairs)
+
+
+def insert_section_configs(db, sections, id_pairs):
+    query = """
+        INSERT INTO SectionConfig (projectConfigId, sectionId, variantId, data)
+        VALUES (:projectConfigId, :sectionId, :variantId, :data)
+    """
+
+    query_params = [
+        {
+            "projectConfigId": projectConfigId,
+            "sectionId": sections[c]["id"],
+            "variantId": sections[c]["variantId"],
+            "data": json.dumps(
+                filter_dict(
+                    sections[c],
+                    SECTION_CONFIG_TABLE_DATA_JSON_FIELDS,
+                    DEFAULT_VALUES["section"],
+                )
+            ),
+        }
+        for projectConfigId, c in id_pairs
+    ]
+
+    db.executemany(query, query_params)
+
+    query = """
+        INSERT INTO SectionConfigSelectedVariants (projectConfigId, sectionId, variantId)
+        VALUES (:projectConfigId, :sectionId, :variantId)
+    """
+    query_params = []
+    for projectConfigId, c in id_pairs:
+        query_params.extend(
+            {
+                "projectConfigId": projectConfigId,
+                "sectionId": sections[c]["id"],
+                "variantId": k,
+            }
+            for k in sections[c]["selectedVariantIds"].keys()
+        )
+
+    db.executemany(query, query_params)
+
+
+# If multiple project configs share a section,
+# and that section has children,
+# then if a new child is added in one of those project configs,
+# an entry in SectionConfig needs to be added for ALL project configs.
+# Otherwise when loading those other project configs,
+# the data for the new child will be missing.
+def update_linked_project_configs(db, project):
+    query = """
+        SELECT projectConfigId, sectionId
+        FROM SectionConfig
+        WHERE projectConfigId != ?
+    """
+    project_config = project["projectConfig"]
+    db.execute(query, (project_config["id"],))
+    sections_to_project_configs = defaultdict(set)
+    project_configs_to_sections = defaultdict(set)
+    for row in db.fetchall():
+        sections_to_project_configs[row["sectionId"]].add(row["projectConfigId"])
+        project_configs_to_sections[row["projectConfigId"]].add(row["sectionId"])
+
+    section_configs_to_add = set()
+    children_have_been_visited = set()
+    has_been_visited_as_child = set()
+    # we start with top level sections that are also in other project configs
+    ids = set(
+        k for k in project_config["children"].keys() if k in sections_to_project_configs
+    )
+    while len(ids) > 0:
+        curr = ids.pop()
+        if curr in children_have_been_visited:
+            continue
+        children_have_been_visited.add(curr)
+        for variant in get_section_variants(project, curr):
+            children = variant["children"]
+            for c in children:
+                if c in has_been_visited_as_child:
+                    continue
+                has_been_visited_as_child.add(c)
+                c_already_in_at_least_one_other_config = False
+                for other_project_config in sections_to_project_configs[curr]:
+                    other_project_section_configs = project_configs_to_sections[
+                        other_project_config
+                    ]
+                    # The parent (curr) is in other project configs, but the child is not.
+                    # So we need to add the child to the other project configs that it's not in.
+                    if c not in other_project_section_configs:
+                        section_configs_to_add.add((other_project_config, c))
+                    else:
+                        c_already_in_at_least_one_other_config = True
+
+                # The child is already in at least one other project config.
+                # So we need to recurse into the child, to see if its children
+                # need to be added.
+                if (
+                    c_already_in_at_least_one_other_config
+                    and c not in children_have_been_visited
+                ):
+                    ids.add(c)
+
+    insert_section_configs(db, project["sections"], section_configs_to_add)

setta/database/db/projects/saveAs.py

@@ -0,0 +1,40 @@
+import copy
+
+from ..sections.jsonSource import remove_json_source_data
+from .copy import copy_project_config, copy_project_details
+from .save import save_project_details
+
+
+def save_as_new_project_config(db, project, new_config_name, with_refs):
+    remove_json_source_data(project)
+    if not with_refs:
+        project_to_save = copy_project_details(
+            project, new_config_name, do_create_new_id=True
+        )
+    else:
+        project_to_save = copy.deepcopy(project)
+        project_to_save["projectConfig"] = copy_project_config(
+            project_to_save["projectConfig"], new_config_name, do_create_new_id=True
+        )
+    save_project_details(db, project_to_save)
+    return project_to_save
+
+
+def save_as_existing_project_config(db, project, config_name):
+    remove_json_source_data(project)
+    query = """
+        SELECT *
+        FROM ProjectConfig
+        WHERE name = :config_name
+    """
+
+    db.execute(query, {"config_name": config_name})
+    x = db.fetchone()
+    project["projectConfig"] = {
+        **project["projectConfig"],
+        "id": x["id"],
+        "name": x["name"],
+    }
+    project_to_save = copy_project_details(project)
+    save_project_details(db, project_to_save)
+    return project_to_save

setta/database/db/projects/utils.py

@@ -0,0 +1,135 @@
+import copy
+
+from setta.database.db.artifacts.utils import add_defaults_to_artifacts
+from setta.database.db.codeInfo.utils import (
+    add_defaults_to_code_info,
+    add_defaults_to_code_info_cols,
+)
+from setta.database.db.sections.load import load_json_sources_into_data_structures
+from setta.database.db.sections.utils import add_defaults_to_sections
+from setta.database.db.sectionVariants.utils import add_defaults_to_section_variants
+from setta.database.db.uiTypes.utils import (
+    add_defaults_to_ui_type_cols,
+    add_defaults_to_ui_types,
+)
+from setta.utils.constants import DEFAULT_VALUES
+from setta.utils.utils import filter_dict, recursive_dict_merge
+
+
+def with_project_config_defaults(**kwargs):
+    return recursive_dict_merge(copy.deepcopy(DEFAULT_VALUES["projectConfig"]), kwargs)
+
+
+def add_defaults_to_project(p):
+    p["projectConfig"] = with_project_config_defaults(**p["projectConfig"])
+    add_defaults_to_artifacts(p["artifacts"])
+    add_defaults_to_sections(p["sections"])
+    add_defaults_to_section_variants(p["sectionVariants"])
+    add_defaults_to_code_info(p["codeInfo"])
+    add_defaults_to_code_info_cols(p["codeInfoCols"])
+    add_defaults_to_ui_types(p["uiTypes"])
+    add_defaults_to_ui_type_cols(p["uiTypeCols"])
+
+
+def add_defaults_to_project_and_load_json_sources(p):
+    add_defaults_to_project(p)
+    load_json_sources_into_data_structures(
+        p["sections"], p["codeInfo"], p["codeInfoCols"], p["sectionVariants"]
+    )
+
+
+def remove_empty(x):
+    return {k: v for k, v in x.items() if len(v) > 0}
+
+
+def filter_data_for_json_export(p):
+    p["projectConfig"] = filter_dict(
+        p["projectConfig"],
+        DEFAULT_VALUES["projectConfig"].keys(),
+        DEFAULT_VALUES["projectConfig"],
+    )
+
+    for k, v in p["codeInfo"].items():
+        p["codeInfo"][k] = filter_dict(
+            p["codeInfo"][k],
+            DEFAULT_VALUES["codeInfo"].keys(),
+            DEFAULT_VALUES["codeInfo"],
+        )
+        for idx in range(len(v["evRefs"])):
+            v["evRefs"][idx] = filter_dict(
+                v["evRefs"][idx],
+                DEFAULT_VALUES["evRefEntry"].keys(),
+                DEFAULT_VALUES["evRefEntry"],
+            )
+
+    for k, v in p["codeInfoCols"].items():
+        p["codeInfoCols"][k] = filter_dict(
+            p["codeInfoCols"][k],
+            DEFAULT_VALUES["codeInfoCol"].keys(),
+            DEFAULT_VALUES["codeInfoCol"],
+        )
+    p["codeInfoCols"] = remove_empty(p["codeInfoCols"])
+
+    for k, v in p["uiTypes"].items():
+        p["uiTypes"][k] = filter_dict(
+            p["uiTypes"][k], DEFAULT_VALUES["uiType"].keys(), DEFAULT_VALUES["uiType"]
+        )
+
+    for k, v in p["uiTypeCols"].items():
+        for paramId, uiTypeColInfo in v.items():
+            p["uiTypeCols"][k][paramId] = filter_dict(
+                p["uiTypeCols"][k][paramId],
+                DEFAULT_VALUES["uiTypeColEntry"].keys(),
+                DEFAULT_VALUES["uiTypeColEntry"],
+            )
+
+        p["uiTypeCols"][k] = remove_empty(p["uiTypeCols"][k])
+    p["uiTypeCols"] = remove_empty(p["uiTypeCols"])
+
+    for k, v in p["sections"].items():
+        if len(p["uiTypeCols"].get(v["uiTypeColId"], {})) == 0:
+            v["uiTypeColId"] = None
+
+        p["sections"][k] = filter_dict(
+            p["sections"][k],
+            DEFAULT_VALUES["section"].keys(),
+            DEFAULT_VALUES["section"],
+        )
+
+    for k, v in p["sectionVariants"].items():
+        if len(p["codeInfoCols"].get(v["codeInfoColId"], {})) == 0:
+            v["codeInfoColId"] = None
+
+        curr = p["sectionVariants"]
+        curr[k] = filter_dict(
+            curr[k],
+            DEFAULT_VALUES["sectionVariant"].keys(),
+            DEFAULT_VALUES["sectionVariant"],
+        )
+
+        if "evRefs" in curr[k]:
+            evRefs = curr[k]["evRefs"]
+            for idx in range(len(evRefs)):
+                evRefs[idx] = filter_dict(
+                    evRefs[idx],
+                    DEFAULT_VALUES["evRefEntry"].keys(),
+                    DEFAULT_VALUES["evRefEntry"],
+                )
+
+        if "values" in curr[k]:
+            for paramId in curr[k]["values"].keys():
+                evRefs = curr[k]["values"][paramId]["evRefs"]
+                for idx in range(len(evRefs)):
+                    evRefs[idx] = filter_dict(
+                        evRefs[idx],
+                        DEFAULT_VALUES["evRefEntry"].keys(),
+                        DEFAULT_VALUES["evRefEntry"],
+                    )
+
+                curr[k]["values"][paramId] = filter_dict(
+                    curr[k]["values"][paramId],
+                    DEFAULT_VALUES["evEntry"].keys(),
+                    DEFAULT_VALUES["evEntry"],
+                )
+
+            curr[k]["values"] = remove_empty(curr[k]["values"])

setta/database/db/sectionVariants/copy.py

@@ -0,0 +1,28 @@
+from setta.database.utils import remap_ids, rename_keys
+from setta.utils.generate_memorable_string import generate_memorable_string
+
+
+def copy_section_variants(section_variants, code_info_id_map, code_info_col_id_map):
+    new_section_variants, section_variant_id_map = remap_ids(section_variants)
+
+    for obj in new_section_variants.values():
+        obj["name"] = generate_memorable_string()
+        obj["values"] = rename_keys(obj["values"], code_info_id_map)
+        if obj["codeInfoColId"]:
+            obj["codeInfoColId"] = code_info_col_id_map[obj["codeInfoColId"]]
+        if obj["selectedItem"]:
+            obj["selectedItem"] = code_info_id_map[obj["selectedItem"]]
+
+        # param sweep
+        for s in obj["sweep"]:
+            if s["selectedItem"]:
+                s["selectedItem"] = code_info_id_map[s["selectedItem"]]
+            for p in s["params"]:
+                p["paramInfoId"] = code_info_id_map[p["paramInfoId"]]
+
+    return new_section_variants, section_variant_id_map
+
+
+def update_section_variant_children(section_variants, section_id_map):
+    for obj in section_variants.values():
+        obj["children"] = [section_id_map[x] for x in obj["children"]]