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

setta/database/db/sectionVariants/load.py

@@ -0,0 +1,139 @@
+import json
+
+from setta.database.db.sectionVariants.utils import (
+    with_ev_entry_defaults,
+    with_section_variant_defaults,
+)
+
+
+def load_section_variants(db, ids):
+    placeholders = ", ".join(["?"] * len(ids))
+    query = f"""
+        SELECT SectionVariantId.id, SectionVariantId.name, SectionVariantId.data, SectionVariantId.selectedItem, SectionVariantId.codeInfoColId, SectionVariantEV.codeInfoId, SectionVariantEV.data as valueData
+        FROM SectionVariantId
+        LEFT JOIN SectionVariantEV
+        ON SectionVariantId.id = SectionVariantEV.idid
+        WHERE SectionVariantId.id in ({placeholders})
+    """
+    db.execute(query, ids)
+    output = {}
+    for row in db.fetchall():
+        id = row["id"]
+        if id not in output:
+            output[id] = with_section_variant_defaults(
+                name=row["name"],
+                selectedItem=row["selectedItem"],
+                codeInfoColId=row["codeInfoColId"],
+                **json.loads(row["data"]),
+            )
+        if row["valueData"]:
+            output[id]["values"][row["codeInfoId"]] = with_ev_entry_defaults(
+                **json.loads(row["valueData"])
+            )
+
+    query = f"""
+        SELECT SectionVariantId.id, SectionVariantChildren.childId, SectionVariantChildren."order"
+        FROM SectionVariantId
+        JOIN SectionVariantChildren
+        ON SectionVariantId.id = SectionVariantChildren.idid
+        WHERE SectionVariantId.id in ({placeholders})
+        ORDER BY SectionVariantChildren."order"
+    """
+    db.execute(query, ids)
+    for row in db.fetchall():
+        output[row["id"]]["children"].append(row["childId"])
+
+    query = f"""
+        SELECT SectionVariantId.id, SectionVariantParamSweep.selectedItemGroupNum, SectionVariantParamSweep.paramInfoGroupNum, SectionVariantParamSweep.selectedItem, SectionVariantParamSweep.paramInfoId, SectionVariantParamSweep.value
+        FROM SectionVariantId
+        LEFT JOIN SectionVariantParamSweep
+        ON SectionVariantId.id = SectionVariantParamSweep.idid
+        WHERE SectionVariantId.id in ({placeholders})
+        ORDER BY SectionVariantParamSweep."order"
+    """
+    db.execute(query, ids)
+    for row in db.fetchall():
+        id = row["id"]
+        if "sweep" not in output[id]:
+            output[id]["sweep"] = []
+        curr = output[id]["sweep"]
+
+        selectedItemGroupNum = row["selectedItemGroupNum"]
+        if selectedItemGroupNum is None:
+            continue
+        if len(curr) <= selectedItemGroupNum:
+            curr.append({"selectedItem": row["selectedItem"], "params": []})
+        curr = curr[selectedItemGroupNum]["params"]
+
+        paramInfoGroupNum = row["paramInfoGroupNum"]
+        if paramInfoGroupNum is None:
+            continue
+        if len(curr) <= paramInfoGroupNum:
+            curr.append({"paramInfoId": row["paramInfoId"], "values": []})
+        curr = curr[paramInfoGroupNum]["values"]
+
+        if row["value"] is not None:
+            curr.append(row["value"])
+
+    query = f"""
+        SELECT
+            SectionVariantId.id,
+            SectionVariantRunGroup.sectionId,
+            SectionVariantRunGroup.parentVariantId,
+            SectionVariantRunGroup.selected,
+            SectionVariantRunGroupVersions.versionId,
+            SectionVariantRunGroupVersions.selected as version_selected,
+            SectionVariantRunGroupParamSweeps.sweepId,
+            SectionVariantRunGroupParamSweeps.selected as sweep_selected
+        FROM SectionVariantId
+        LEFT JOIN SectionVariantRunGroup
+            ON SectionVariantId.id = SectionVariantRunGroup.idid
+        LEFT JOIN SectionVariantRunGroupVersions
+            ON SectionVariantRunGroup.idid = SectionVariantRunGroupVersions.idid
+            AND SectionVariantRunGroup.sectionId = SectionVariantRunGroupVersions.sectionId
+            AND (
+                (SectionVariantRunGroup.parentVariantId IS NULL AND SectionVariantRunGroupVersions.parentVariantId IS NULL)
+                OR SectionVariantRunGroup.parentVariantId = SectionVariantRunGroupVersions.parentVariantId
+            )
+        LEFT JOIN SectionVariantRunGroupParamSweeps
+            ON SectionVariantRunGroup.idid = SectionVariantRunGroupParamSweeps.idid
+            AND SectionVariantRunGroup.sectionId = SectionVariantRunGroupParamSweeps.sectionId
+            AND (
+                (SectionVariantRunGroup.parentVariantId IS NULL AND SectionVariantRunGroupParamSweeps.parentVariantId IS NULL)
+                OR SectionVariantRunGroup.parentVariantId = SectionVariantRunGroupParamSweeps.parentVariantId
+            )
+        WHERE SectionVariantId.id in ({placeholders})
+    """
+    db.execute(query, ids)
+    for row in db.fetchall():
+        id = row["id"]
+        if "runGroup" not in output[id]:
+            output[id]["runGroup"] = {}
+        curr = output[id]["runGroup"]
+        sectionId = row["sectionId"]
+
+        if not sectionId:
+            continue
+
+        if sectionId not in curr:
+            curr[sectionId] = {}
+        if row["parentVariantId"] not in curr[sectionId]:
+            curr[sectionId][row["parentVariantId"]] = {
+                "selected": bool(row["selected"]),
+                "versions": {},
+                "paramSweeps": {},
+            }
+
+        # Add version data if present
+        if row["versionId"] is not None:
+            curr[sectionId][row["parentVariantId"]]["versions"][
+                row["versionId"]
+            ] = bool(row["version_selected"])
+
+        # Add param sweep data if present
+        if row["sweepId"] is not None:
+            curr[sectionId][row["parentVariantId"]]["paramSweeps"][
+                row["sweepId"]
+            ] = bool(row["sweep_selected"])
+
+    return output

setta/database/db/sectionVariants/save.py

@@ -0,0 +1,140 @@
+import json
+
+from setta.utils.constants import (
+    DEFAULT_VALUES,
+    SECTION_VARIANT_EV_TABLE_DATA_JSON_FIELDS,
+    SECTION_VARIANT_ID_TABLE_DATA_JSON_FIELDS,
+)
+from setta.utils.utils import filter_dict
+
+
+def save_section_variants(db, section_variants):
+    query = """
+        INSERT INTO SectionVariantId (id, name, data, selectedItem, codeInfoColId)
+        VALUES (:id, :name, :data, :selectedItem, :codeInfoColId)
+        ON CONFLICT (id)
+        DO UPDATE SET
+        name = :name,
+        data = :data,
+        selectedItem = :selectedItem,
+        codeInfoColId = :codeInfoColId
+    """
+
+    query_params = [
+        {
+            "id": k,
+            "name": v["name"],
+            "selectedItem": v["selectedItem"],
+            "codeInfoColId": v["codeInfoColId"],
+            "data": json.dumps(
+                filter_dict(
+                    v,
+                    SECTION_VARIANT_ID_TABLE_DATA_JSON_FIELDS,
+                    DEFAULT_VALUES["sectionVariant"],
+                )
+            ),
+        }
+        for k, v in section_variants.items()
+    ]
+    db.executemany(query, query_params)
+
+    # delete entered values
+    placeholders = ", ".join(["?"] * len(section_variants))
+    query = f"""
+        DELETE FROM SectionVariantEV
+        WHERE idid IN ({placeholders})
+    """
+    query_params = list(section_variants.keys())
+    db.execute(query, query_params)
+
+    # add entered values
+    query = """
+        INSERT INTO SectionVariantEV (idid, codeInfoId, data)
+        VALUES (:idid, :codeInfoId, :data)
+    """
+    query_params = []
+    for idid, variant in section_variants.items():
+        for code_info_id, value_info in variant["values"].items():
+            query_params.append(
+                {
+                    "idid": idid,
+                    "codeInfoId": code_info_id,
+                    "data": json.dumps(
+                        filter_dict(
+                            value_info,
+                            SECTION_VARIANT_EV_TABLE_DATA_JSON_FIELDS,
+                            DEFAULT_VALUES["evEntry"],
+                        )
+                    ),
+                }
+            )
+    db.executemany(query, query_params)
+
+    query = f"""
+        DELETE FROM SectionVariantParamSweep
+        WHERE idid IN ({placeholders})
+    """
+    query_params = list(section_variants.keys())
+    db.execute(query, query_params)
+
+    query = """
+        INSERT INTO SectionVariantParamSweep (idid, selectedItemGroupNum, paramInfoGroupNum, selectedItem, paramInfoId, "order", value)
+        VALUES (:idid, :selectedItemGroupNum, :paramInfoGroupNum, :selectedItem, :paramInfoId, :order, :value)
+    """
+
+    query_params = []
+    for id, variant in section_variants.items():
+        order = 0
+        for selectedItemGroupNum, s in enumerate(variant["sweep"]):
+            selected_item = s["selectedItem"]
+            if len(s["params"]) == 0:
+                query_params.append(
+                    generate_query_param(
+                        id,
+                        selectedItemGroupNum,
+                        None,
+                        selected_item,
+                        None,
+                        order,
+                        None,
+                    )
+                )
+                order += 1
+            else:
+                for paramInfoGroupNum, param in enumerate(s["params"]):
+                    values = param["values"] or [None]
+                    for value in values:
+                        query_params.append(
+                            generate_query_param(
+                                id,
+                                selectedItemGroupNum,
+                                paramInfoGroupNum,
+                                selected_item,
+                                param["paramInfoId"],
+                                order,
+                                value,
+                            )
+                        )
+                        order += 1
+
+    db.executemany(query, query_params)
+
+
+def generate_query_param(
+    id,
+    selectedItemGroupNum,
+    paramInfoGroupNum,
+    selected_item,
+    param_info_id,
+    order,
+    value,
+):
+    return {
+        "idid": id,
+        "selectedItemGroupNum": selectedItemGroupNum,
+        "paramInfoGroupNum": paramInfoGroupNum,
+        "selectedItem": selected_item,
+        "paramInfoId": param_info_id,
+        "order": order,
+        "value": value,
+    }

setta/database/db/sectionVariants/utils.py

@@ -0,0 +1,44 @@
+import copy
+
+from setta.database.utils import create_new_id
+from setta.utils.constants import DEFAULT_VALUES
+from setta.utils.generate_memorable_string import generate_memorable_string
+from setta.utils.utils import recursive_dict_merge
+
+
+def new_section_variant(**kwargs):
+    id = kwargs.get("id", create_new_id())
+    kwargs["name"] = kwargs.get("name", generate_memorable_string())
+    obj = with_section_variant_defaults(**kwargs)
+    return id, obj
+
+
+def with_section_variant_defaults(**kwargs):
+    return recursive_dict_merge(copy.deepcopy(DEFAULT_VALUES["sectionVariant"]), kwargs)
+
+
+def add_defaults_to_section_variants(section_variants):
+    for k, v in section_variants.items():
+        section_variants[k] = with_section_variant_defaults(**v)
+
+        for paramId, valueInfo in section_variants[k]["values"].items():
+            section_variants[k]["values"][paramId] = with_ev_entry_defaults(**valueInfo)
+            evRefs = section_variants[k]["values"][paramId]["evRefs"]
+            for idx in range(len(evRefs)):
+                evRefs[idx] = with_ev_ref_entry_defaults(**evRefs[idx])
+
+        evRefs = section_variants[k]["evRefs"]
+        for idx in range(len(evRefs)):
+            evRefs[idx] = with_ev_ref_entry_defaults(**evRefs[idx])
+
+
+def with_ev_entry_defaults(**kwargs):
+    return recursive_dict_merge(copy.deepcopy(DEFAULT_VALUES["evEntry"]), kwargs)
+
+
+def new_ev_entry(**kwargs):
+    return with_ev_entry_defaults(**kwargs)
+
+
+def with_ev_ref_entry_defaults(**kwargs):
+    return recursive_dict_merge(copy.deepcopy(DEFAULT_VALUES["evRefEntry"]), kwargs)

setta/database/db/sections/copy.py

@@ -0,0 +1,70 @@
+from setta.database.utils import remap_ids, rename_keys
+
+from ..codeInfo.copy import copy_code_info, copy_code_info_col
+from ..sectionVariants.copy import (
+    copy_section_variants,
+    update_section_variant_children,
+)
+from ..uiTypes.copy import copy_ui_type_cols, copy_ui_types
+
+
+def copy_sections(
+    sections,
+    section_variant_id_map,
+    ui_type_id_map,
+    ui_type_col_id_map,
+):
+    new_sections, section_id_map = remap_ids(sections)
+    for section in new_sections.values():
+        section["id"] = section_id_map[section["id"]]
+        section["variantId"] = section_variant_id_map[section["variantId"]]
+        section["uiTypeId"] = ui_type_id_map[section["uiTypeId"]]
+        if section["uiTypeColId"]:
+            section["uiTypeColId"] = ui_type_col_id_map[section["uiTypeColId"]]
+        section["variantIds"] = [
+            section_variant_id_map[x] for x in section["variantIds"]
+        ]
+        section["nonPresetUITypeIds"] = [
+            ui_type_id_map[x] for x in section["nonPresetUITypeIds"]
+        ]
+        section["paramSweepSectionId"] = section_id_map.get(
+            section["paramSweepSectionId"], None
+        )
+        section["parentId"] = section_id_map.get(section["parentId"], None)
+
+    return new_sections, section_id_map
+
+
+def copy_sections_and_other_info(x):
+    new_code_info, code_info_id_map = copy_code_info(x["codeInfo"])
+    new_code_info_cols, code_info_col_id_map = copy_code_info_col(
+        x["codeInfoCols"], code_info_id_map
+    )
+    new_section_variants, section_variant_id_map = copy_section_variants(
+        x["sectionVariants"], code_info_id_map, code_info_col_id_map
+    )
+    new_ui_types, ui_type_id_map = copy_ui_types(x["uiTypes"])
+    new_ui_type_cols, ui_type_col_id_map = copy_ui_type_cols(
+        x["uiTypeCols"], ui_type_id_map, code_info_id_map
+    )
+    new_sections, section_id_map = copy_sections(
+        x["sections"],
+        section_variant_id_map,
+        ui_type_id_map,
+        ui_type_col_id_map,
+    )
+    update_section_variant_children(new_section_variants, section_id_map)
+
+    return {
+        "codeInfo": new_code_info,
+        "codeInfoCols": new_code_info_cols,
+        "sectionVariants": new_section_variants,
+        "uiTypes": new_ui_types,
+        "uiTypeCols": new_ui_type_cols,
+        "sections": new_sections,
+        "section_id_map": section_id_map,
+    }
+
+
+def copy_relative_positions(relative_positions, section_id_map):
+    return rename_keys(relative_positions, section_id_map)

setta/database/db/sections/jsonSource.py

@@ -0,0 +1,119 @@
+import json
+from collections import defaultdict
+
+from setta.utils.constants import BASE_UI_TYPE_IDS, C, is_from_json_source
+from setta.utils.utils import recursive_dict_merge, save_json_to_file, try_json
+
+
+def save_json_source_data(p, section_ids=None, forking_from=None):
+    sections = {
+        k: v
+        for k, v in p["sections"].items()
+        if v.get("jsonSource", None) and ((not section_ids) or k in section_ids)
+    }
+
+    to_be_saved = defaultdict(dict)
+
+    forking_from_data = {}
+    if forking_from:
+        with open(forking_from, "r") as f:
+            forking_from_data = json.load(f)
+
+    for s in sections.values():
+        for variantId in s["variantIds"]:
+            variant = p["sectionVariants"][variantId]
+            codeInfoCol = p["codeInfoCols"][variant["codeInfoColId"]]
+            filename = variant["name"]
+            for k, children in codeInfoCol["children"].items():
+                if is_from_json_source(k):
+                    metadata = json.loads(k.removeprefix(C.JSON_SOURCE_PREFIX))
+                    key_path = metadata["key"]
+                    value = try_getting_value(variant, k, children)
+
+                    current_dict = add_key_path_to_dict(
+                        to_be_saved[filename], key_path[:-1]
+                    )
+
+                    # Set the value at the final position
+                    if key_path:  # Only set if we have a path
+                        current_dict[key_path[-1]] = value
+
+            # Make sure the jsonSourceKeys are present.
+            # (They might not be because they are completely empty)
+            add_key_path_to_dict(to_be_saved[filename], s["jsonSourceKeys"])
+
+    # Save each file
+    for filename, data in to_be_saved.items():
+        data = recursive_dict_merge(forking_from_data, data)
+        save_json_to_file(filename, data)
+
+    return to_be_saved
+
+
+def try_getting_value(variant, codeInfoId, codeInfoChildren):
+    if len(codeInfoChildren) == 0:
+        if codeInfoId in variant["values"]:
+            return try_json(variant["values"][codeInfoId]["value"])
+        return ""
+    return {}
+
+
+def add_key_path_to_dict(output, key_path):
+    for path_part in key_path:
+        # Create nested dictionaries if they don't exist
+        if path_part not in output:
+            output[path_part] = {}
+        output = output[path_part]
+    return output
+
+
+def condition_keep_code_info(k, jsonCodeInfoWithUIType, keepCodeInfoThatHaveUITypes):
+    if keepCodeInfoThatHaveUITypes:
+        return k in jsonCodeInfoWithUIType or not is_from_json_source(k)
+    return not is_from_json_source(k)
+
+
+def remove_json_source_data(p, keepCodeInfoThatHaveUITypes=True):
+    for variant in p["sectionVariants"].values():
+        variant["values"] = {
+            k: v for k, v in variant["values"].items() if not is_from_json_source(k)
+        }
+
+    jsonCodeInfoWithUIType = set()
+    if keepCodeInfoThatHaveUITypes:
+        for uiTypeCol in p["uiTypeCols"].values():
+            for paramInfoId, uiTypeInfo in uiTypeCol.items():
+                # we want to know which json source params have an associated uiTypeId
+                # only if it's not the base TEXT type, since that's the default
+                if (
+                    is_from_json_source(paramInfoId)
+                    and uiTypeInfo["uiTypeId"] != BASE_UI_TYPE_IDS[C.TEXT]
+                ):
+                    jsonCodeInfoWithUIType.add(paramInfoId)
+
+    p["codeInfo"] = {
+        k: v
+        for k, v in p["codeInfo"].items()
+        if condition_keep_code_info(
+            k, jsonCodeInfoWithUIType, keepCodeInfoThatHaveUITypes
+        )
+    }
+
+    for codeInfoColId in p["codeInfoCols"].keys():
+        codeInfoCol = p["codeInfoCols"][codeInfoColId]
+        codeInfoCol["children"] = {
+            k: v
+            for k, v in codeInfoCol["children"].items()
+            if k is None
+            or condition_keep_code_info(
+                k, jsonCodeInfoWithUIType, keepCodeInfoThatHaveUITypes
+            )
+        }
+        for id, children in codeInfoCol["children"].items():
+            codeInfoCol["children"][id] = [
+                c
+                for c in children
+                if condition_keep_code_info(
+                    c, jsonCodeInfoWithUIType, keepCodeInfoThatHaveUITypes
+                )
+            ]