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

setta/database/db/artifacts/save.py

@@ -0,0 +1,85 @@
+import json
+
+from setta.utils.constants import DEFAULT_VALUES
+from setta.utils.utils import filter_dict
+
+
+def save_artifacts(db, artifacts):
+    query = """
+        INSERT INTO Artifact (id, name, path, value, type)
+        VALUES (:id, :name, :path, :value, :type)
+        ON CONFLICT (id)
+        DO UPDATE SET
+        name = :name,
+        path = :path,
+        value = :value,
+        type = :type
+    """
+
+    query_params = []
+
+    for id, data in artifacts.items():
+        if data["path"]:
+            # set value to null if path is specified
+            data["value"] = DEFAULT_VALUES["artifact"]["value"]
+        query_params.append(
+            {
+                "id": id,
+                "name": data["name"],
+                "path": data["path"],
+                "value": json.dumps(data["value"]),
+                "type": data["type"],
+            }
+        )
+
+    db.executemany(query, query_params)
+
+
+def save_artifact_groups(db, artifact_groups):
+    query = """
+        INSERT INTO ArtifactGroupId (id, name, data)
+        VALUES (:id, :name, :data)
+        ON CONFLICT (id)
+        DO UPDATE SET
+        name = :name,
+        data = :data
+    """
+    query_params = []
+    for k, group in artifact_groups.items():
+        data_keys = group.keys() - {"name", "artifactTransforms"}
+        query_params.append(
+            {
+                "id": k,
+                "name": group["name"],
+                "data": json.dumps(filter_dict(group, data_keys)),
+            }
+        )
+    db.executemany(query, query_params)
+
+    placeholders = ", ".join(["?"] * len(artifact_groups))
+    query = f"""
+        DELETE FROM ArtifactGroup
+        WHERE idid IN ({placeholders})
+    """
+    query_params = list(artifact_groups.keys())
+    db.execute(query, query_params)
+
+    query = """
+        INSERT INTO ArtifactGroup (idid, artifactId, data, "order")
+        VALUES (:idid, :artifactId, :data, :order)
+    """
+
+    query_params = []
+    for id, group in artifact_groups.items():
+        for order, artifactTransform in enumerate(group["artifactTransforms"]):
+            data_keys = artifactTransform.keys() - {"artifactId"}
+            query_params.append(
+                {
+                    "idid": id,
+                    "artifactId": artifactTransform["artifactId"],
+                    "data": json.dumps(filter_dict(artifactTransform, data_keys)),
+                    "order": order,
+                }
+            )
+
+    db.executemany(query, query_params)

setta/database/db/artifacts/save_or_create.py

@@ -0,0 +1,68 @@
+import json
+
+from setta.database.utils import create_new_id
+
+
+def get_artifact_value_for_db(artifact, saveTo):
+    if saveTo == "disk":
+        return None
+    return json.dumps(artifact["value"])
+
+
+def save_or_create_artifacts(db, artifacts, saveTo):
+    # Convert to parameters, using new IDs for anything without an ID
+    params = [
+        (
+            art.get("id") or create_new_id(),
+            art["name"],
+            art["path"],
+            get_artifact_value_for_db(art, saveTo),
+            art["type"],
+        )
+        for art in artifacts
+    ]
+
+    # Do the upsert
+    db.executemany(
+        """
+        INSERT INTO Artifact (id, name, path, value, type)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT (id) DO UPDATE
+        SET name=excluded.name,
+            path=excluded.path,
+            value=excluded.value,
+            type=excluded.type
+        ON CONFLICT (name, path, type) DO UPDATE
+        SET value=excluded.value
+        """,
+        params,
+    )
+
+    # Get all the actual IDs
+    id_map = lookup_artifacts(db, artifacts)
+    return [id_map[(art["name"], art["path"], art["type"])] for art in artifacts]
+
+
+def lookup_artifacts(db, artifacts):
+    """
+    Look up existing artifacts by name/path/type.
+    Returns a map of (name, path, type) -> id for found artifacts.
+    """
+    if not artifacts:
+        return {}
+
+    lookup_params = [(art["name"], art["path"], art["type"]) for art in artifacts]
+    placeholders = " OR ".join("(name=? AND path=? AND type=?)" for _ in artifacts)
+
+    db.execute(
+        f"SELECT name, path, type, id FROM Artifact WHERE {placeholders}",
+        [param for params in lookup_params for param in params],
+    )
+    rows = db.fetchall()
+
+    return {(row["name"], row["path"], row["type"]): row["id"] for row in rows}
+
+
+def get_artifact_ids(db, artifacts):
+    id_map = lookup_artifacts(db, artifacts)
+    return [id_map.get((art["name"], art["path"], art["type"])) for art in artifacts]

setta/database/db/artifacts/utils.py

@@ -0,0 +1,13 @@
+import copy
+
+from setta.utils.constants import DEFAULT_VALUES
+from setta.utils.utils import recursive_dict_merge
+
+
+def with_artifact_defaults(**kwargs):
+    return recursive_dict_merge(copy.deepcopy(DEFAULT_VALUES["artifact"]), kwargs)
+
+
+def add_defaults_to_artifacts(artifacts):
+    for k, v in artifacts.items():
+        artifacts[k] = with_artifact_defaults(**v)

setta/database/db/codeInfo/copy.py

@@ -0,0 +1,26 @@
+from setta.database.utils import remap_ids, rename_keys
+from setta.utils.constants import is_from_json_source
+
+
+def copy_code_info(code_info):
+    ids_to_rename = [k for k in code_info.keys() if not is_from_json_source(k)]
+    new_code_info, code_info_id_map = remap_ids(code_info, ids_to_rename)
+    code_info_id_map.update({k: k for k in code_info.keys() if is_from_json_source(k)})
+
+    for c in new_code_info.values():
+        c["id"] = code_info_id_map[c["id"]]
+
+    return new_code_info, code_info_id_map
+
+
+def copy_code_info_col(code_info_cols, code_info_id_map):
+    new_code_info_cols, code_info_col_id_map = remap_ids(code_info_cols)
+
+    for col in new_code_info_cols.values():
+        col["children"] = rename_keys(col["children"], code_info_id_map)
+        for parentId in col["children"].keys():
+            col["children"][parentId] = [
+                code_info_id_map[x] for x in col["children"][parentId]
+            ]
+
+    return new_code_info_cols, code_info_col_id_map

setta/database/db/codeInfo/load.py

@@ -0,0 +1,65 @@
+import json
+
+from setta.database.db.codeInfo.utils import (
+    with_code_info_col_defaults,
+    with_code_info_defaults,
+)
+
+
+def load_code_info(db, codeInfoColIds):
+    placeholders = ", ".join(["?"] * len(codeInfoColIds))
+    query = f"""
+        WITH RECURSIVE DESCENDANTS AS (
+            SELECT c.idid, c.parentId, c.childId, c."order"
+            FROM CodeInfoCol c
+            WHERE c.idid IN ({placeholders})
+
+            UNION
+
+            SELECT X.idid, X.parentId, X.childId, X."order"
+            FROM CodeInfoCol X
+            JOIN DESCENDANTS d ON X.parentId = d.childId AND X.idid = d.idid
+        )
+        SELECT * FROM DESCENDANTS
+        ORDER BY idid, "order";
+    """
+    db.execute(query, tuple(codeInfoColIds))
+    results = db.fetchall()
+    all_ids = set()
+    code_info_cols = {}
+    for k in codeInfoColIds:
+        code_info_cols[k] = with_code_info_col_defaults()
+    for row in results:
+        (codeInfoColId, parentId, childId, _) = row
+        if parentId:
+            all_ids.add(parentId)
+        all_ids.add(childId)
+        children_dict = code_info_cols[codeInfoColId]["children"]
+        if parentId not in children_dict:
+            children_dict[parentId] = []
+        children_dict[parentId].append(childId)
+        if childId not in children_dict:
+            children_dict[childId] = []
+
+    all_ids = list(all_ids)
+
+    placeholders = ", ".join(["?"] * len(all_ids))
+    query = f"""
+        SELECT * FROM CodeInfo
+        WHERE id IN ({placeholders})
+    """
+    db.execute(query, all_ids)
+    code_info = {}
+    for row in db.fetchall():
+        code_info[row["id"]] = with_code_info_defaults(
+            id=row["id"], name=row["name"], **json.loads(row["data"])
+        )
+
+    return code_info, code_info_cols
+
+
+def load_code_info_cols(db, sectionVariants):
+    collection_ids = [
+        v["codeInfoColId"] for v in sectionVariants.values() if v["codeInfoColId"]
+    ]
+    return load_code_info(db, collection_ids)

setta/database/db/codeInfo/save.py

@@ -0,0 +1,75 @@
+import json
+
+from setta.utils.constants import CODE_INFO_TABLE_DATA_JSON_FIELDS, DEFAULT_VALUES
+from setta.utils.utils import filter_dict, replace_null_keys_with_none
+
+
+def save_code_info(db, codeInfo):
+    query = """
+        INSERT INTO CodeInfo (id, name, data)
+        VALUES (:id, :name, :data)
+        ON CONFLICT (id)
+        DO UPDATE SET
+            name = :name,
+            data = :data
+    """
+
+    # insert into codeinfo table
+    query_params = []
+    for codeInfoId, c in codeInfo.items():
+        query_params.append(
+            {
+                "id": codeInfoId,
+                "name": c["name"],
+                "data": json.dumps(
+                    filter_dict(
+                        c, CODE_INFO_TABLE_DATA_JSON_FIELDS, DEFAULT_VALUES["codeInfo"]
+                    )
+                ),
+            }
+        )
+
+    db.executemany(query, query_params)
+
+
+def save_code_info_col(db, codeInfoCols):
+    codeInfoCols = replace_null_keys_with_none(codeInfoCols)
+
+    query = """
+        INSERT INTO CodeInfoColId (id)
+        VALUES (:id)
+        ON CONFLICT (id)
+        DO NOTHING
+    """
+
+    query_params = [{"id": k} for k in codeInfoCols.keys()]
+    db.executemany(query, query_params)
+
+    placeholders = ", ".join(["?"] * len(codeInfoCols))
+    query = f"""
+        DELETE FROM CodeInfoCol
+        WHERE idid IN ({placeholders})
+    """
+    query_params = list(codeInfoCols.keys())
+    db.execute(query, query_params)
+
+    # add children
+    query = """
+        INSERT INTO CodeInfoCol (idid, parentId, childId, "order")
+        VALUES (:idid, :parentId, :childId, :order)
+    """
+    query_params = []
+    for idid, c in codeInfoCols.items():
+        for parentId, children in c["children"].items():
+            order = 0
+            for childId in children:
+                query_params.append(
+                    {
+                        "idid": idid,
+                        "parentId": parentId,
+                        "childId": childId,
+                        "order": order,
+                    }
+                )
+                order += 1
+    db.executemany(query, query_params)

setta/database/db/codeInfo/utils.py

@@ -0,0 +1,33 @@
+import copy
+
+from setta.database.db.sectionVariants.utils import with_ev_ref_entry_defaults
+from setta.utils.constants import DEFAULT_VALUES
+from setta.utils.utils import recursive_dict_merge, replace_null_keys_with_none
+
+
+def with_code_info_defaults(**kwargs):
+    return recursive_dict_merge(copy.deepcopy(DEFAULT_VALUES["codeInfo"]), kwargs)
+
+
+def add_defaults_to_code_info(code_info):
+    for k, v in code_info.items():
+        code_info[k] = with_code_info_defaults(**v)
+        evRefs = code_info[k]["evRefs"]
+        for idx in range(len(evRefs)):
+            evRefs[idx] = with_ev_ref_entry_defaults(**evRefs[idx])
+
+
+def with_code_info_col_defaults(**kwargs):
+    return recursive_dict_merge(
+        replace_null_keys_with_none(copy.deepcopy(DEFAULT_VALUES["codeInfoCol"])),
+        replace_null_keys_with_none(kwargs),
+    )
+
+
+def add_defaults_to_code_info_cols(code_info_cols):
+    for k, v in code_info_cols.items():
+        code_info_cols[k] = with_code_info_col_defaults(**v)
+
+
+def new_code_info_col():
+    return copy.deepcopy(DEFAULT_VALUES["codeInfoCol"])

setta/database/db/evRefs/load.py

@@ -0,0 +1,45 @@
+def load_ev_refs_into_data_structures(db, section_variants, code_info):
+    variant_placeholders = ", ".join(["?"] * len(section_variants))
+    codeinfo_placeholders = ", ".join(["?"] * len(code_info))
+
+    query = f"""
+        SELECT *
+        FROM EVRefs
+        WHERE variantId IN ({variant_placeholders})
+        OR codeInfoId IN ({codeinfo_placeholders})
+    """
+
+    parameters = list(section_variants.keys()) + list(code_info.keys())
+    db.execute(query, parameters)
+
+    for row in db.fetchall():
+        row = dict(row)
+        row["isArgsObj"] = bool(row["isArgsObj"])
+        variantId = row.pop("variantId")
+        codeInfoId = row.pop("codeInfoId")
+        referringParamInfoId = row.pop("referringParamInfoId")
+        if codeInfoId:
+            code_info[codeInfoId]["evRefs"].append(row)
+        elif referringParamInfoId:
+            section_variants[variantId]["values"][referringParamInfoId][
+                "evRefs"
+            ].append(row)
+        else:
+            section_variants[variantId]["evRefs"].append(row)
+
+
+def load_template_vars_into_data_structures(db, section_variants):
+    variant_placeholders = ", ".join(["?"] * len(section_variants))
+
+    query = f"""
+        SELECT *
+        FROM TemplateVars
+        WHERE variantId IN ({variant_placeholders})
+    """
+
+    db.execute(query, list(section_variants.keys()))
+
+    for row in db.fetchall():
+        row = dict(row)
+        variantId = row.pop("variantId")
+        section_variants[variantId]["templateVars"].append(row)

setta/database/db/evRefs/save.py

@@ -0,0 +1,95 @@
+def save_ev_refs(db, section_variants, code_info):
+    placeholders = ", ".join(["?"] * len(section_variants))
+    query = f"""
+        DELETE FROM EVRefs
+        WHERE variantId IN ({placeholders})
+    """
+    query_params = list(section_variants.keys())
+    db.execute(query, query_params)
+
+    placeholders = ", ".join(["?"] * len(code_info))
+    query = f"""
+        DELETE FROM EVRefs
+        WHERE codeInfoId IN ({placeholders})
+    """
+    query_params = list(code_info.keys())
+    db.execute(query, query_params)
+
+    query = """
+        INSERT INTO EVRefs (variantId, codeInfoId, referringParamInfoId, sectionId, paramInfoId, isArgsObj, startPos, keyword)
+        VALUES (:variantId, :codeInfoId, :referringParamInfoId, :sectionId, :paramInfoId, :isArgsObj, :startPos, :keyword)
+    """
+
+    query_params = []
+    for variantId, variant in section_variants.items():
+        evRefs = variant["evRefs"]
+        query_params.extend(
+            [
+                {
+                    "variantId": variantId,
+                    "codeInfoId": None,
+                    "referringParamInfoId": None,
+                    **x,
+                }
+                for x in evRefs
+            ]
+        )
+
+        for referringParamInfoId, details in variant["values"].items():
+            evRefs = details["evRefs"]
+            query_params.extend(
+                [
+                    {
+                        "variantId": variantId,
+                        "codeInfoId": None,
+                        "referringParamInfoId": referringParamInfoId,
+                        **x,
+                    }
+                    for x in evRefs
+                ]
+            )
+
+    for codeInfoId, codeInfo in code_info.items():
+        evRefs = codeInfo["evRefs"]
+        query_params.extend(
+            [
+                {
+                    "variantId": None,
+                    "codeInfoId": codeInfoId,
+                    "referringParamInfoId": None,
+                    **x,
+                }
+                for x in evRefs
+            ]
+        )
+
+    db.executemany(query, query_params)
+
+
+def save_template_vars(db, section_variants):
+    placeholders = ", ".join(["?"] * len(section_variants))
+    query = f"""
+        DELETE FROM TemplateVars
+        WHERE variantId IN ({placeholders})
+    """
+    query_params = list(section_variants.keys())
+    db.execute(query, query_params)
+
+    query = """
+        INSERT INTO TemplateVars (variantId, sectionId, startPos, keyword)
+        VALUES (:variantId, :sectionId, :startPos, :keyword)
+    """
+
+    query_params = []
+    for variantId, variant in section_variants.items():
+        query_params.extend(
+            [
+                {
+                    "variantId": variantId,
+                    **x,
+                }
+                for x in variant["templateVars"]
+            ]
+        )
+
+    db.executemany(query, query_params)

setta/database/db/projects/copy.py

@@ -0,0 +1,36 @@
+import copy
+
+from setta.database.utils import create_new_id, rename_keys
+
+from ..sections.copy import copy_sections_and_other_info
+
+
+def copy_project_details(project, new_config_name=None, do_create_new_id=False):
+    new_info = copy_sections_and_other_info(project)
+    new_project_config = copy_project_config(
+        project["projectConfig"],
+        new_config_name,
+        do_create_new_id,
+        new_info["section_id_map"],
+    )
+
+    return {
+        **project,
+        **new_info,
+        "projectConfig": new_project_config,
+    }
+
+
+def copy_project_config(
+    project_config, new_config_name=None, do_create_new_id=False, section_id_map=None
+):
+    new_project_config = copy.deepcopy(project_config)
+    if new_config_name:
+        new_project_config["name"] = new_config_name
+    if do_create_new_id:
+        new_project_config["id"] = create_new_id()
+    if section_id_map:
+        new_project_config["children"] = rename_keys(
+            new_project_config["children"], section_id_map
+        )
+    return new_project_config

setta/database/db/projects/delete.py

@@ -0,0 +1,7 @@
+def delete_project_configs(db, ids):
+    placeholders = ", ".join(["?"] * len(ids))
+    query = f"""
+        DELETE FROM ProjectConfig
+        WHERE id IN ({placeholders});
+    """
+    db.execute(query, ids)