setta 0.0.8.dev0__py3-none-any.whl → 0.0.9__py3-none-any.whl

setta/lsp/specific_file_watcher.py

@@ -0,0 +1,278 @@
+import asyncio
+import glob
+import logging
+import os
+from typing import Dict, List, Set
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+logger = logging.getLogger(__name__)
+
+
+class SpecificFileWatcher:
+    """File watcher that monitors specific files and notifies via a single callback."""
+
+    def __init__(self, callback):
+        """
+        Initialize the file watcher for specific files.
+
+        Args:
+            callback: Function to call when any watched file changes
+                     Callback receives (file_path, event_type) where event_type is
+                     one of 'created', 'modified', 'deleted', or 'moved'
+        """
+        self.observer = Observer()
+        self.watched_files: Set[str] = set()
+        self.file_to_patterns = {}
+        self.handler = SpecificFileEventHandler(
+            callback,
+            asyncio.get_event_loop(),
+            self.watched_files,
+            self.file_to_patterns,
+        )
+
+    def add_file(self, file_path: str) -> bool:
+        """
+        Add a specific file to watch.
+
+        Args:
+            file_path: Absolute path to the file to watch
+
+        Returns:
+            bool: True if the file was added, False if it doesn't exist
+        """
+        if not os.path.exists(file_path):
+            return False
+
+        absolute_path = os.path.abspath(file_path)
+        dir_path = os.path.dirname(absolute_path)
+
+        # Add file to watched files if not already there
+        if absolute_path not in self.watched_files:
+            self.watched_files.add(absolute_path)
+        else:
+            # Already watching this file
+            return True
+
+        # Schedule the directory for watching if needed
+        if not self.observer.emitters:
+            # No directories are being watched yet
+            self.observer.schedule(self.handler, dir_path, recursive=False)
+        else:
+            # Check if the directory is already being watched
+            is_dir_watched = False
+            for emitter in self.observer.emitters:
+                if emitter.watch.path == dir_path:
+                    is_dir_watched = True
+                    break
+
+            if not is_dir_watched:
+                self.observer.schedule(self.handler, dir_path, recursive=False)
+
+        return True
+
+    def remove_file(self, file_path: str) -> None:
+        """
+        Remove a file from being watched.
+
+        Args:
+            file_path: Path to the file
+        """
+        absolute_path = os.path.abspath(file_path)
+
+        if absolute_path in self.watched_files:
+            self.watched_files.remove(absolute_path)
+
+    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:
+            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)
+        ]
+        absolute_paths_set = set(absolute_paths)
+
+        # Calculate differences
+        files_to_add = absolute_paths_set - self.watched_files
+        files_to_remove = self.watched_files - absolute_paths_set
+
+        # Track which files were successfully added
+        added_files = []
+
+        # Add new files
+        for file_path in files_to_add:
+            success = self.add_file(file_path)
+            if success:
+                added_files.append(file_path)
+
+        # Remove files no longer in the list
+        for file_path in files_to_remove:
+            self.remove_file(file_path)
+
+        # 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()
+        self.started = True
+
+    def stop(self) -> None:
+        """Stop the file watcher."""
+        self.observer.stop()
+        self.observer.join()
+        self.started = False
+
+
+class SpecificFileEventHandler(FileSystemEventHandler):
+    """Event handler for specific file events."""
+
+    def __init__(self, callback, loop, watched_files_ref, file_to_patterns):
+        """
+        Initialize the event handler.
+
+        Args:
+            callback: Function to call when a watched file changes
+            loop: Asyncio event loop for async callbacks
+            watched_files_ref: Reference to the set of files being watched
+        """
+        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."""
+        if not event.is_directory:
+            file_path = os.path.abspath(event.src_path)
+            if file_path in self.watched_files_ref:
+                self._send_event(event, "created")
+
+    def on_modified(self, event: FileSystemEvent):
+        """Handle file modification event."""
+        if not event.is_directory:
+            file_path = os.path.abspath(event.src_path)
+            if file_path in self.watched_files_ref:
+                self._send_event(event, "modified")
+
+    def on_deleted(self, event: FileSystemEvent):
+        """Handle file deletion event."""
+        if not event.is_directory:
+            file_path = os.path.abspath(event.src_path)
+            if file_path in self.watched_files_ref:
+                self._send_event(event, "deleted")
+
+    def on_moved(self, event: FileSystemEvent):
+        """Handle file move event."""
+        if not event.is_directory:
+            # For moved events, we need to check both source and destination
+            src_path = os.path.abspath(event.src_path)
+            dest_path = (
+                os.path.abspath(event.dest_path)
+                if hasattr(event, "dest_path")
+                else None
+            )
+
+            # If the source was being watched, notify about the move
+            if src_path in self.watched_files_ref:
+                self._send_event(event, "moved")
+
+            # If the destination is also being watched, notify about modification
+            if (
+                dest_path
+                and dest_path in self.watched_files_ref
+                and dest_path != src_path
+            ):
+                # Create a modified event for the destination
+                self._send_event(event, "modified")
+
+    def _send_event(self, event: FileSystemEvent, event_type: str):
+        """
+        Process and send the event to the callback.
+
+        Args:
+            event: The file system event
+            event_type: The type of event ('created', 'modified', 'deleted', 'moved')
+        """
+        logger.debug("_send_event")
+        # Get absolute path
+        abs_path = os.path.abspath(event.src_path)
+
+        # Get relative path to current working directory
+        rel_path = os.path.relpath(abs_path)
+
+        # Get file contents for created and modified events
+        file_content = None
+        if event_type in ("created", "modified"):
+            try:
+                with open(abs_path, "r", encoding="utf-8") as f:
+                    file_content = f.read()
+            except Exception as e:
+                logger.debug(f"Error reading file {abs_path}: {e}")
+                file_content = None
+
+        # For moved events, get the content of the destination file
+        dest_abs_path = None
+        dest_rel_path = None
+        if event_type == "moved" and hasattr(event, "dest_path"):
+            dest_abs_path = os.path.abspath(event.dest_path)
+            dest_rel_path = os.path.relpath(dest_abs_path)
+            try:
+                with open(dest_abs_path, "r", encoding="utf-8") as f:
+                    file_content = f.read()
+            except Exception as e:
+                logger.debug(f"Error reading destination file {dest_abs_path}: {e}")
+                file_content = None
+
+        # Prepare event info object
+        event_info = {
+            "absPath": abs_path,
+            "relPath": rel_path,
+            "eventType": event_type,
+            "fileContent": file_content,
+            "matchingGlobPatterns": list(self.file_to_patterns[abs_path]),
+        }
+
+        # Add destination paths for moved events
+        if event_type == "moved" and dest_abs_path:
+            event_info["destAbsPath"] = dest_abs_path
+            event_info["destRelPath"] = dest_rel_path
+
+        logger.debug(f"will send {event_info}")
+        if asyncio.iscoroutinefunction(self.callback):
+            self.loop.call_soon_threadsafe(
+                lambda: self.loop.create_task(self.callback(event_info))
+            )
+        else:
+            self.callback(event_info)

setta/lsp/utils.py

@@ -1,8 +1,15 @@
+import logging
+
+from setta.utils.constants import C
+
 from .file_watcher import LSPFileWatcher
 from .reader import LanguageServerReader
 from .server import LanguageServer
+from .specific_file_watcher import SpecificFileWatcher
 from .writer import LanguageServerWriter
 
+logger = logging.getLogger(__name__)
+
 
 def create_lsps(
     workspace_folder,
@@ -42,6 +49,19 @@ def create_file_watcher(lsps, lsp_writers):
     return file_watcher
 
 
+def create_specific_file_watcher(websocket_manager):
+    async def callback(event_info):
+        logger.debug(f"callback {event_info}")
+        await websocket_manager.broadcast(
+            {
+                "content": event_info,
+                "messageType": C.WS_SPECIFIC_FILE_WATCHER_UPDATE,
+            }
+        )
+
+    return SpecificFileWatcher(callback)
+
+
 async def start_lsps(lsps, lsp_readers, lsp_writers):
     for k, v in lsps.items():
         await v.start_server()

setta/routers/dependencies.py

@@ -47,3 +47,7 @@ def get_lsp_writers(request: Request):
 
 def get_lsp_writers_from_websocket(websocket: WebSocket):
     return websocket.app.state.lsp_writers
+
+
+def get_specific_file_watcher(request: Request):
+    return request.app.state.specific_file_watcher

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
 
 

setta/routers/sections.py

@@ -2,7 +2,7 @@ import os
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from fastapi import APIRouter, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
 
 from setta.code_gen.export_selected import (
@@ -21,6 +21,7 @@ from setta.database.db.sections.copy import (
 )
 from setta.database.db.sections.jsonSource import save_json_source_data
 from setta.database.db.sections.load import load_json_sources_into_data_structures
+from setta.routers.dependencies import get_specific_file_watcher
 from setta.utils.constants import C
 from setta.utils.generate_new_filename import generate_new_filename
 
@@ -53,8 +54,7 @@ class GlobalParamSweepSectionToYamlRequest(BaseModel):
 
 class LoadSectionJSONSourceRequest(BaseModel):
     project: dict
-    sectionId: str
-    jsonSource: str
+    sectionIdToJSONSource: Dict[str, str]
 
 
 class SaveSectionJSONSourceRequest(BaseModel):
@@ -67,6 +67,10 @@ class NewJSONVersionNameRequest(BaseModel):
     filenameGlob: str
 
 
+class CreateFileRequest(BaseModel):
+    filepath: str
+
+
 class GetJSONSourcePathToBeDeleted(BaseModel):
     variantName: str
 
@@ -75,6 +79,10 @@ class DeleteFileRequest(BaseModel):
     filepath: str
 
 
+class FileWatchListRequest(BaseModel):
+    filepaths: List[str]
+
+
 @router.post(C.ROUTE_COPY_SECTIONS)
 def route_sections_make_copy(x: SectionsMakeCopyRequest):
     output = copy_sections_and_other_info(x.sectionsAndOtherInfo)
@@ -126,13 +134,14 @@ def route_global_param_sweep_section_to_yaml(x: GlobalParamSweepSectionToYamlReq
 @router.post(C.ROUTE_LOAD_SECTION_JSON_SOURCE)
 def route_load_section_json_source(x: LoadSectionJSONSourceRequest):
     p = x.project
-    p["sections"][x.sectionId]["jsonSource"] = x.jsonSource
+    for k, v in x.sectionIdToJSONSource.items():
+        p["sections"][k]["jsonSource"] = v
     load_json_sources_into_data_structures(
         p["sections"],
         p["codeInfo"],
         p["codeInfoCols"],
         p["sectionVariants"],
-        section_ids=[x.sectionId],
+        section_ids=list(x.sectionIdToJSONSource.keys()),
     )
     return {"project": p}
 
@@ -145,6 +154,12 @@ def route_new_json_version_name(x: NewJSONVersionNameRequest):
     return new_filename
 
 
+@router.post(C.ROUTE_CREATE_FILE)
+def route_create_file(x: CreateFileRequest):
+    Path(x.filepath).parent.mkdir(parents=True, exist_ok=True)
+    Path(x.filepath).touch()
+
+
 @router.post(C.ROUTE_SAVE_SECTION_JSON_SOURCE)
 def route_save_section_json_source(x: SaveSectionJSONSourceRequest):
     save_json_source_data(x.project, [x.sectionId], x.forking_from)
@@ -172,3 +187,11 @@ def route_delete_file(x: DeleteFileRequest):
             status_code=status.HTTP_404_NOT_FOUND,
             detail=f"Failed to delete file: {str(e)}",
         )
+
+
+@router.post(C.ROUTE_FILE_WATCH_LIST)
+def route_file_watch_list(
+    x: FileWatchListRequest, specific_file_watcher=Depends(get_specific_file_watcher)
+):
+    # x.filepaths is the current list of file paths or glob patterns that should be watched
+    specific_file_watcher.update_watch_list(x.filepaths)

setta/server.py

@@ -16,6 +16,7 @@ from setta.lsp.utils import (
     create_lsp_readers,
     create_lsp_writers,
     create_lsps,
+    create_specific_file_watcher,
     kill_lsps,
     start_lsps,
 )
@@ -52,6 +53,9 @@ async def lifespan(app: FastAPI):
     app.state.file_watcher = create_file_watcher(app.state.lsps, app.state.lsp_writers)
     app.state.terminal_websockets = TerminalWebsockets()
     app.state.websocket_manager = WebsocketManager()
+    app.state.specific_file_watcher = create_specific_file_watcher(
+        app.state.websocket_manager
+    )
     app.state.tasks = Tasks(app.state.lsp_writers)
     app.state.lsp_readers = create_lsp_readers(
         app.state.lsps, app.state.websocket_manager
@@ -73,6 +77,7 @@ async def lifespan(app: FastAPI):
         app.state.lsp_writers,
     )
     app.state.file_watcher.start()
+    app.state.specific_file_watcher.start()
 
     if not is_dev_mode():
         # Mount the 'frontend/dist' directory at '/static'
@@ -98,6 +103,7 @@ async def lifespan(app: FastAPI):
     finally:
         app.state.tasks.close()
         app.state.file_watcher.stop()
+        app.state.specific_file_watcher.stop()
         await kill_lsps(app.state.lsps, app.state.lsp_readers)
 
 

setta/static/constants/constants.json

@@ -89,11 +89,12 @@
   "ROUTE_ADD_DEFAULT_DATA_FOR_JSON_IMPORT": "/addDefaultDataForJSONImport",
   "ROUTE_GET_JSON_SOURCE_PATH_TO_BE_DELETED": "/getJsonSourcePathToBeDeleted",
   "ROUTE_MAKE_EV_REF_TEMPLATE_VAR_REPLACEMENTS": "/makeEVRefReplacements",
+  "ROUTE_CREATE_FILE": "/createFile",
   "ROUTE_DELETE_FILE": "/deleteFile",
   "ROUTE_CHECK_IF_FILE_EXISTS": "/checkIfFileExists",
   "ROUTE_LOAD_ARTIFACT_FROM_DISK": "/loadArtifactFromDisk",
   "ROUTE_RESTART_LANGUAGE_SERVER": "/restartLanguageServer",
-  "JSON_SOURCE_PREFIX": "JSON-",
+  "ROUTE_FILE_WATCH_LIST": "/fileWatchList",
   "NESTED_PARAM": "NESTED_PARAM",
   "ARGS_PREFIX": "__",
   "TEMPLATE_PREFIX": "$",
@@ -105,6 +106,7 @@
   "WS_TERMINAL_RESIZE": "terminalResize",
   "WS_LSP_STATUS": "lspStatus",
   "WS_IN_MEMORY_FN_AVG_RUN_TIME": "inMemoryFnAvgRunTime",
+  "WS_SPECIFIC_FILE_WATCHER_UPDATE": "specificFileWatcherUpdate",
   "SETTA_GENERATED_PYTHON": "SETTA_GENERATED_PYTHON",
   "SETTA_GENERATED_PYTHON_IMPORTS": "SETTA_GENERATED_PYTHON_IMPORTS",
   "TEMPLATE_VAR_IMPORT_PATH_SUFFIX": "import_path",

setta/static/constants/defaultValues.json

@@ -65,7 +65,7 @@
     "aspectRatioExtraWidth": 0,
     "columnWidth": null,
     "renderedValue": null,
-    "subprocessStartMethod": "fork",
+    "subprocessStartMethod": "spawn",
     "headingAsSectionName": false
   },
   "sectionVariant": {
@@ -94,7 +94,8 @@
     "isFrozen": false,
     "isSelected": false,
     "evRefs": [],
-    "ignoreTypeErrors": false
+    "ignoreTypeErrors": false,
+    "jsonSource": null
   },
   "codeInfoCol": {
     "children": { "null": [] }