setta 0.0.9.dev0__tar.gz → 0.0.9.dev2__tar.gz

{setta-0.0.9.dev0/backend/setta.egg-info → setta-0.0.9.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: setta
-Version: 0.0.9.dev0
+Version: 0.0.9.dev2
 Summary: Python without the donkeywork.
 Home-page: https://setta.dev
 Author: Kevin Musgrave, Jeff Musgrave

setta-0.0.9.dev2/backend/setta/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.9.dev2"

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/code_gen/python/generate_code.py

@@ -258,6 +258,8 @@ def convert_var_names_to_readable_form(
         # only create nice_var_name if we haven't already created it for this var_name
         if var_name not in var_name_to_nice_var_name_mapping:
             nice_name = exporter_obj.output[var_name]["name"]
+            # TODO: do the same thing on the frontend to find naming conflicts
+            nice_name = nice_name.replace(" ", "_")
             nice_var_name = create_nice_var_name(top_level_symbols, nice_name)
             top_level_symbols.add(nice_var_name)
             var_name_to_nice_var_name_mapping[var_name] = nice_var_name

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/database/db/codeInfo/copy.py

@@ -1,11 +1,8 @@
 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)})
+    new_code_info, code_info_id_map = remap_ids(code_info)
 
     for c in new_code_info.values():
         c["id"] = code_info_id_map[c["id"]]

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/database/db/projects/saveAs.py

@@ -1,12 +1,10 @@
 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
@@ -21,7 +19,6 @@ def save_as_new_project_config(db, project, new_config_name, with_refs):
 
 
 def save_as_existing_project_config(db, project, config_name):
-    remove_json_source_data(project)
     query = """
         SELECT *
         FROM ProjectConfig

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/database/db/projects/utils.py

@@ -43,8 +43,8 @@ def remove_empty(x):
     return {k: v for k, v in x.items() if len(v) > 0}
 
 
-def filter_data_for_json_export(p, keepCodeInfoThatHaveUITypes):
-    remove_json_source_data(p, keepCodeInfoThatHaveUITypes)
+def filter_data_for_json_export(p):
+    remove_json_source_data(p)
 
     p["projectConfig"] = filter_dict(
         p["projectConfig"],

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/database/db/sectionVariants/copy.py

@@ -2,11 +2,20 @@ 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):
+def copy_section_variants(
+    sections, section_variants, code_info_id_map, code_info_col_id_map
+):
     new_section_variants, section_variant_id_map = remap_ids(section_variants)
+    keep_old_name = set()
+    for s in sections.values():
+        if not s["jsonSource"]:
+            continue
+        for v in s["variantIds"]:
+            keep_old_name.add(section_variant_id_map[v])
 
-    for obj in new_section_variants.values():
-        obj["name"] = generate_memorable_string()
+    for id, obj in new_section_variants.items():
+        if id not in keep_old_name:
+            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"]]

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/database/db/sections/copy.py

@@ -18,6 +18,9 @@ def copy_sections(
     for section in new_sections.values():
         section["id"] = section_id_map[section["id"]]
         section["variantId"] = section_variant_id_map[section["variantId"]]
+        section["defaultVariantId"] = section_variant_id_map[
+            section["defaultVariantId"]
+        ]
         section["uiTypeId"] = ui_type_id_map[section["uiTypeId"]]
         if section["uiTypeColId"]:
             section["uiTypeColId"] = ui_type_col_id_map[section["uiTypeColId"]]
@@ -41,7 +44,7 @@ def copy_sections_and_other_info(x):
         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
+        x["sections"], 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(

setta-0.0.9.dev2/backend/setta/database/db/sections/jsonSource.py

@@ -0,0 +1,186 @@
+import json
+from collections import defaultdict
+
+from setta.utils.constants import BASE_UI_TYPE_IDS, C
+from setta.utils.utils import (
+    recursive_dict_merge,
+    replace_null_keys_with_none,
+    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)
+
+    p["codeInfoCols"] = replace_null_keys_with_none(p["codeInfoCols"])
+
+    ancestor_paths = build_ancestor_paths(p["codeInfo"], p["codeInfoCols"])
+
+    for s in sections.values():
+        if not s["jsonSource"] or s["jsonSourceMissing"]:
+            continue
+
+        for variantId in s["variantIds"]:
+            variant = p["sectionVariants"][variantId]
+            codeInfoColId = variant["codeInfoColId"]
+            codeInfoCol = p["codeInfoCols"][codeInfoColId]
+            filename = variant["name"]
+
+            recursively_add_keys(
+                p,
+                variant,
+                codeInfoCol,
+                to_be_saved[filename],
+                None,
+                s["jsonSourceKeys"],
+                ancestor_paths,
+            )
+
+            # 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 build_ancestor_paths(codeInfo, codeInfoCols):
+    parent_map = {}
+    for col in codeInfoCols.values():
+        for parent_id, children in col["children"].items():
+            for child_id in children:
+                parent_map[(codeInfo[child_id]["jsonSource"], child_id)] = parent_id
+
+    ancestor_paths = {}
+    for node_id in codeInfo:
+        if node_id not in ancestor_paths:
+            path = []
+            current_id = node_id
+
+            # Traverse up to build the path
+            while current_id is not None:
+                if current_id in codeInfo:  # Skip if not a valid codeInfo node
+                    name = codeInfo[current_id]["name"]
+                    path.insert(0, name)
+
+                    # Get parent using the map
+                    parent_id = parent_map.get(
+                        (codeInfo[current_id]["jsonSource"], current_id)
+                    )
+                    current_id = parent_id
+                else:
+                    break
+
+            ancestor_paths[node_id] = path
+
+    return ancestor_paths
+
+
+def recursively_add_keys(
+    p, variant, codeInfoCol, input_dict, codeInfoId, jsonSourceKeys, ancestor_paths
+):
+    for k in codeInfoCol["children"][codeInfoId]:
+        children = codeInfoCol["children"][k]
+        json_source = p["codeInfo"][k].get("jsonSource")
+
+        if json_source:
+            # Get pre-computed key path
+            key_path = [*jsonSourceKeys, *ancestor_paths[k]]
+            value = try_getting_value(variant, k, children)
+
+            current_dict = add_key_path_to_dict(input_dict, 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
+
+        # Continue recursion regardless of whether this node has a jsonSource
+        recursively_add_keys(
+            p, variant, codeInfoCol, input_dict, k, jsonSourceKeys, ancestor_paths
+        )
+
+
+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 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 condition_keep_code_info(codeInfo, jsonCodeInfoWithUIType):
+    if not codeInfo:
+        return False
+    return not codeInfo["jsonSource"] or codeInfo["id"] in jsonCodeInfoWithUIType
+
+
+def remove_json_source_data(p):
+    for variant in p["sectionVariants"].values():
+        variant["values"] = {
+            k: v
+            for k, v in variant["values"].items()
+            if not p["codeInfo"][k]["jsonSource"]
+        }
+
+    jsonCodeInfoWithUIType = set()
+    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 (
+                p["codeInfo"][paramInfoId]["jsonSource"]
+                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(v, jsonCodeInfoWithUIType)
+    }
+
+    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(
+                p["codeInfo"].get(k),
+                jsonCodeInfoWithUIType,
+            )
+        }
+        for id, children in codeInfoCol["children"].items():
+            codeInfoCol["children"][id] = [
+                c
+                for c in children
+                if condition_keep_code_info(
+                    p["codeInfo"].get(c),
+                    jsonCodeInfoWithUIType,
+                )
+            ]

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/database/db/sections/load.py

@@ -7,10 +7,10 @@ from collections import defaultdict
 
 from setta.database.db.artifacts.load import load_artifact_groups
 from setta.database.db.codeInfo.utils import new_code_info_col, with_code_info_defaults
+from setta.database.db.sections.jsonSource import build_ancestor_paths
 from setta.database.db.sections.utils import with_section_defaults
 from setta.database.db.sectionVariants.utils import new_ev_entry, new_section_variant
 from setta.database.utils import create_new_id
-from setta.utils.constants import C
 
 from ..sectionVariants.load import load_section_variants
 from ..uiTypes.load import load_uitypecols, load_uitypes
@@ -214,34 +214,9 @@ def load_json_sources_into_data_structures(
             f'Attempting to read {s["jsonSource"]} with keys {s["jsonSourceKeys"]}'
         )
         new_data = load_json_source(s["jsonSource"], s["jsonSourceKeys"])
-        logger.debug(f"Loaded json: {new_data}")
-        for filename, data in new_data.items():
-            codeInfo.update(data["codeInfo"])
-            variantId = None
-            for vid in s["variantIds"]:
-                if sectionVariants[vid]["name"] == filename:
-                    variantId = vid
-                    break
-            if not variantId:
-                variantId, section_variant = new_section_variant(
-                    name=filename,
-                )
-                s["variantIds"].append(variantId)
-                sectionVariants[variantId] = section_variant
-
-            curr_section_variant = sectionVariants[variantId]
-            curr_section_variant["values"] = data["sectionVariantValues"]
-            codeInfoColId = curr_section_variant["codeInfoColId"]
-
-            if not codeInfoColId:
-                codeInfoColId = create_new_id()
-                curr_section_variant["codeInfoColId"] = codeInfoColId
-                codeInfoCols[codeInfoColId] = new_code_info_col()
-
-            codeInfoCols[codeInfoColId]["children"] = data["codeInfoColChildren"]
-
-            s["configLanguage"] = "json"
-            filenames_loaded.add(filename)
+        filenames_loaded.update(
+            merge_into_existing(new_data, s, sectionVariants, codeInfo, codeInfoCols)
+        )
 
     # delete variants that aren't associated with a loaded file
     to_delete = []
@@ -281,6 +256,74 @@ def load_json_sources_into_data_structures(
             s["defaultVariantId"] = s["variantId"]
 
 
+def merge_into_existing(new_data, section, sectionVariants, codeInfo, codeInfoCols):
+    filenames_loaded = set()
+    jsonSourceMetadata_to_id = {}
+    ancestor_paths = build_ancestor_paths(codeInfo, codeInfoCols)
+    for id, info in codeInfo.items():
+        jsonSourceMetadata_to_id[
+            createMetadataJsonString(info["jsonSource"], ancestor_paths[id])
+        ] = id
+
+    for filename, data in new_data.items():
+        replacements = {}
+        new_ancestor_paths = build_ancestor_paths(
+            data["codeInfo"], {None: {"children": data["codeInfoColChildren"]}}
+        )
+        for newId, newInfo in data["codeInfo"].items():
+            existingId = jsonSourceMetadata_to_id.get(
+                createMetadataJsonString(
+                    newInfo["jsonSource"], new_ancestor_paths[newId]
+                )
+            )
+            if existingId:
+                replacements[newId] = existingId
+            else:
+                codeInfo[newId] = newInfo
+
+        for newId, existingId in replacements.items():
+            del data["codeInfo"][newId]
+            data["codeInfoColChildren"][existingId] = [
+                replacements.get(x, x) for x in data["codeInfoColChildren"][newId]
+            ]
+            data["codeInfoColChildren"][None] = [
+                replacements.get(x, x) for x in data["codeInfoColChildren"][None]
+            ]
+            del data["codeInfoColChildren"][newId]
+            data["sectionVariantValues"][existingId] = data["sectionVariantValues"][
+                newId
+            ]
+            del data["sectionVariantValues"][newId]
+
+        variantId = None
+        for vid in section["variantIds"]:
+            if sectionVariants[vid]["name"] == filename:
+                variantId = vid
+                break
+        if not variantId:
+            variantId, section_variant = new_section_variant(
+                name=filename,
+            )
+            section["variantIds"].append(variantId)
+            sectionVariants[variantId] = section_variant
+
+        curr_section_variant = sectionVariants[variantId]
+        curr_section_variant["values"] = data["sectionVariantValues"]
+        codeInfoColId = curr_section_variant["codeInfoColId"]
+
+        if not codeInfoColId:
+            codeInfoColId = create_new_id()
+            curr_section_variant["codeInfoColId"] = codeInfoColId
+            codeInfoCols[codeInfoColId] = new_code_info_col()
+
+        codeInfoCols[codeInfoColId]["children"] = data["codeInfoColChildren"]
+
+        section["configLanguage"] = "json"
+        filenames_loaded.add(filename)
+
+    return filenames_loaded
+
+
 def load_json_source(filename_glob, jsonSourceKeys):
     new_data = {}
 
@@ -289,83 +332,97 @@ def load_json_source(filename_glob, jsonSourceKeys):
         try:
             with open(filename, "r") as f:
                 jsonSourceData = json.load(f)
-        except:
+        except json.JSONDecodeError:
+            jsonSourceData = {}
+        except FileNotFoundError:
             logger.debug(f"couldn't find: {filename}")
             continue
 
-        new_data[filename] = {
-            "codeInfo": {},
-            "codeInfoColChildren": {},
-            "sectionVariantValues": {},
-        }
-
-        try:
-            for k in jsonSourceKeys:
-                jsonSourceData = jsonSourceData[k]
-        except:
-            # TODO print warning or something
-            pass
-
-        process_json_object(
-            new_data, jsonSourceData, filename, filename_glob, jsonSourceKeys
+        new_data[filename] = process_json_object(
+            jsonSourceData, filename, jsonSourceKeys
         )
 
-        if len(jsonSourceKeys) > 0:
-            # point directly from None (the root) to the children
-            highest_key = create_json_code_info_key(filename_glob, jsonSourceKeys)
-            codeInfoChildren = new_data[filename]["codeInfoColChildren"]
-            codeInfoChildren[None] = codeInfoChildren[highest_key]
-            del codeInfoChildren[highest_key]
+    return new_data
+
+
+def process_json_object(jsonSourceData, filename, jsonSourceKeys):
+    new_data = {
+        "codeInfo": {},
+        "codeInfoColChildren": {},
+        "sectionVariantValues": {},
+    }
+
+    try:
+        for k in jsonSourceKeys:
+            jsonSourceData = jsonSourceData[k]
+    except:
+        # TODO print warning or something
+        pass
+
+    metadataToId = {}
+
+    highest_key = process_json_object_helper(
+        new_data, jsonSourceData, filename, jsonSourceKeys, metadataToId
+    )
+
+    if len(jsonSourceKeys) > 0:
+        # point directly from None (the root) to the children
+        codeInfoChildren = new_data["codeInfoColChildren"]
+        codeInfoChildren[None] = codeInfoChildren[highest_key]
+        del codeInfoChildren[highest_key]
 
     return new_data
 
 
-def process_json_object(output, obj, filename, filename_glob, current_path):
+def process_json_object_helper(output, obj, filename, current_path, metadataToId):
     if not isinstance(obj, dict):
         return
 
     children_keys = []
     for k, v in obj.items():
         path = current_path + [k]
-        full_key, is_dict = create_json_code_info(
-            filename, filename_glob, path, k, v, output
-        )
-        children_keys.append(full_key)
+        paramInfoId, is_dict = create_json_code_info(filename, k, v, output)
+        metadataToId[createMetadataJsonString(filename, path)] = paramInfoId
+        children_keys.append(paramInfoId)
         if is_dict:
-            process_json_object(output, v, filename, filename_glob, path)
+            process_json_object_helper(output, v, filename, path, metadataToId)
 
     parent_id = None
     if len(current_path) > 0:
-        parent_id = create_json_code_info_key(filename_glob, current_path)
+        metadata = createMetadataJsonString(filename, current_path)
+        parent_id = metadataToId.get(metadata)
+        if not parent_id:
+            parent_id = create_new_id()
+            metadataToId[metadata] = parent_id
 
-    output[filename]["codeInfoColChildren"][parent_id] = children_keys
+    output["codeInfoColChildren"][parent_id] = children_keys
+    return parent_id
 
 
-def create_json_code_info(filename, filename_glob, path, key, value, output):
-    full_key = create_json_code_info_key(filename_glob, path)
+def create_json_code_info(filename, key, value, output):
+    paramInfoId = create_new_id()
     # Create code info entry
-    output[filename]["codeInfo"][full_key] = with_code_info_defaults(
-        id=full_key, name=key
+    output["codeInfo"][paramInfoId] = with_code_info_defaults(
+        id=paramInfoId,
+        name=key,
+        editable=True,
+        jsonSource=filename,
     )
-    output[filename]["codeInfoColChildren"][full_key] = []
+    output["codeInfoColChildren"][paramInfoId] = []
 
     is_dict = isinstance(value, dict)
     # Create variant value entry
     if is_dict:
         # For objects, store empty value and process children
-        output[filename]["sectionVariantValues"][full_key] = new_ev_entry()
+        output["sectionVariantValues"][paramInfoId] = new_ev_entry()
     else:
         # For non-objects, store the value directly
-        output[filename]["sectionVariantValues"][full_key] = new_ev_entry(
+        output["sectionVariantValues"][paramInfoId] = new_ev_entry(
             value=json.dumps(value)
         )
 
-    return full_key, is_dict
+    return paramInfoId, is_dict
 
 
-def create_json_code_info_key(filename_glob, path):
-    # specify separators to make json.dumps equivalent to JSON.stringify
-    key = json.dumps(
-        {"filenameGlob": filename_glob, "key": path}, separators=(",", ":")
-    )
-    return f"{C.JSON_SOURCE_PREFIX}{key}"
+def createMetadataJsonString(filename, path):
+    return json.dumps({"filename": filename, "key": path})

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/database/settings_file.py

@@ -110,5 +110,5 @@ class MetaSettingsFile:
 
     def save_settings_project(self, p):
         save_json_source_data(p)
-        filter_data_for_json_export(p, keepCodeInfoThatHaveUITypes=False)
+        filter_data_for_json_export(p)
         save_json_to_file(self.path_meta_settings, p)

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/lsp/specific_file_watcher.py

@@ -1,4 +1,5 @@
 import asyncio
+import glob
 import logging
 import os
 from typing import Dict, List, Set
@@ -23,8 +24,12 @@ class SpecificFileWatcher:
         """
         self.observer = Observer()
         self.watched_files: Set[str] = set()
+        self.file_to_patterns = {}
         self.handler = SpecificFileEventHandler(
-            callback, asyncio.get_event_loop(), self.watched_files
+            callback,
+            asyncio.get_event_loop(),
+            self.watched_files,
+            self.file_to_patterns,
         )
 
     def add_file(self, file_path: str) -> bool:
@@ -79,17 +84,21 @@ class SpecificFileWatcher:
         if absolute_path in self.watched_files:
             self.watched_files.remove(absolute_path)
 
-    def update_watch_list(self, file_paths: List[str]) -> Dict[str, List[str]]:
+    def update_watch_list(
+        self, filepaths_and_glob_patterns: List[str]
+    ) -> Dict[str, List[str]]:
         """
         Update the entire list of files being watched with a single function call.
         This efficiently handles adding new files and removing files that are no longer needed.
 
         Args:
-            file_paths: List of file paths that should be watched
+            filepaths_and_glob_patterns: List of file paths that should be watched
 
         Returns:
             Dict containing 'added' and 'removed' lists of file paths
         """
+        file_paths = self.get_actual_file_paths_to_watch(filepaths_and_glob_patterns)
+
         # Convert all input paths to absolute paths (only if they exist)
         absolute_paths = [
             os.path.abspath(path) for path in file_paths if os.path.exists(path)
@@ -116,6 +125,24 @@ class SpecificFileWatcher:
         # Return information about what changed
         return {"added": added_files, "removed": list(files_to_remove)}
 
+    def get_actual_file_paths_to_watch(self, filepaths_and_glob_patterns):
+        actual_filepaths = set()
+        # Expand glob patterns and build the mapping
+        for pattern in filepaths_and_glob_patterns:
+            matching_files = glob.glob(pattern)
+            for file_path in matching_files:
+                # Only add actual files, not directories
+                if os.path.isfile(file_path):
+                    abs_path = os.path.abspath(file_path)
+                    actual_filepaths.add(abs_path)
+
+                    # Add to the mapping
+                    if abs_path not in self.file_to_patterns:
+                        self.file_to_patterns[abs_path] = set()
+                    self.file_to_patterns[abs_path].add(pattern)
+
+        return actual_filepaths
+
     def start(self) -> None:
         """Start the file watcher."""
         self.observer.start()
@@ -131,7 +158,7 @@ class SpecificFileWatcher:
 class SpecificFileEventHandler(FileSystemEventHandler):
     """Event handler for specific file events."""
 
-    def __init__(self, callback, loop, watched_files_ref):
+    def __init__(self, callback, loop, watched_files_ref, file_to_patterns):
         """
         Initialize the event handler.
 
@@ -143,6 +170,7 @@ class SpecificFileEventHandler(FileSystemEventHandler):
         self.callback = callback
         self.loop = loop
         self.watched_files_ref = watched_files_ref
+        self.file_to_patterns = file_to_patterns
 
     def on_created(self, event: FileSystemEvent):
         """Handle file creation event."""
@@ -233,6 +261,7 @@ class SpecificFileEventHandler(FileSystemEventHandler):
             "relPath": rel_path,
             "eventType": event_type,
             "fileContent": file_content,
+            "matchingGlobPatterns": list(self.file_to_patterns[abs_path]),
         }
 
         # Add destination paths for moved events

{setta-0.0.9.dev0 → setta-0.0.9.dev2}/backend/setta/routers/projects.py

@@ -178,7 +178,7 @@ def router_set_as_default_project(x: SetAsDefaultProjectRequest, dbq=Depends(get
 
 @router.post(C.ROUTE_FILTER_DATA_FOR_JSON_EXPORT)
 def router_filter_data_for_json_export(x: FilterDataForJSONExportRequest):
-    filter_data_for_json_export(x.project, keepCodeInfoThatHaveUITypes=True)
+    filter_data_for_json_export(x.project)
     return x.project