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

setta/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.8.dev0"
+__version__ = "0.0.9.dev0"

setta/code_gen/export_selected.py

@@ -549,7 +549,7 @@ class ExporterForInMemoryFn:
                 C.LIST_ROOT,
                 C.DICT_ROOT,
                 C.GROUP,
-                # C.IMAGE,
+                C.IMAGE,
                 # C.CHART,
                 C.DRAW,
                 C.CHAT,
@@ -588,9 +588,11 @@ class ExporterForInMemoryFn:
                     value[child_name] = self.export_section(
                         c, f'{name}["{child_name}"]'
                     )
-        # elif type in [C.IMAGE, C.CHART]:
-        #     value = get_artifacts(self.p, id)
-        #     self.create_var_mapping((id, "artifact"), name)
+        elif type in [C.IMAGE]:
+            artifacts = get_artifacts(self.p, id)
+            img = artifacts[0]["value"] if len(artifacts) > 0 else None
+            value = {"image": img}
+            self.create_var_mapping((id, "image"), f'{name}["image"]')
         elif type == C.DRAW:
             value = {"drawing": get_drawing(self.p, id)}
             self.create_var_mapping((id, "drawing"), f'{name}["drawing"]')

setta/database/db/sections/load.py

@@ -210,7 +210,11 @@ def load_json_sources_into_data_structures(
         if v["jsonSource"] and ((not section_ids) or k in section_ids)
     }
     for s in sections.values():
+        logger.debug(
+            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
@@ -244,6 +248,9 @@ def load_json_sources_into_data_structures(
     for s in sections.values():
         for vid in s["variantIds"]:
             if sectionVariants[vid]["name"] not in filenames_loaded:
+                logger.debug(
+                    f'Removing variant {sectionVariants[vid]["name"]} because the associated json was not found'
+                )
                 to_delete.append(vid)
 
     for vid in to_delete:
@@ -255,14 +262,22 @@ def load_json_sources_into_data_structures(
         s["jsonSourceMissing"] = False
         s["variantIds"] = [v for v in s["variantIds"] if v in sectionVariants]
         if len(s["variantIds"]) == 0:
+            logger.debug("Section has no variantIds. Creating new section variant.")
             variantId, variant = new_section_variant()
-            s["variantIds"].append(variantId)
             sectionVariants[variantId] = variant
+            s["variantId"] = variantId
+            s["variantIds"].append(variantId)
             s["jsonSourceMissing"] = True
         elif s["variantId"] not in s["variantIds"]:
+            logger.debug(
+                "Selected variantId is not in list of variantIds. Changing selected variantId"
+            )
             s["variantId"] = s["variantIds"][0]
 
         if s["defaultVariantId"] not in s["variantIds"]:
+            logger.debug(
+                "Default variantId is not in list of variantIds. Changing default variantId"
+            )
             s["defaultVariantId"] = s["variantId"]
 
 

setta/lsp/file_watcher.py

@@ -53,22 +53,6 @@ class LSPFileWatcher:
         self.observer.stop()
         self.observer.join()
 
-    def is_watching(self, path: str) -> bool:
-        """
-        Check if a path is being watched.
-
-        Args:
-            path: Path to check
-
-        Returns:
-            bool: True if the path is being watched
-        """
-        absolute_path = os.path.abspath(path)
-        return any(
-            absolute_path.startswith(watched_path)
-            for watched_path in self.watched_paths
-        )
-
 
 class LSPEventHandler(FileSystemEventHandler):
     def __init__(self, callback, loop):

setta/lsp/specific_file_watcher.py

@@ -0,0 +1,249 @@
+import asyncio
+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.handler = SpecificFileEventHandler(
+            callback, asyncio.get_event_loop(), self.watched_files
+        )
+
+    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, file_paths: 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
+
+        Returns:
+            Dict containing 'added' and 'removed' lists of file paths
+        """
+        # 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 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):
+        """
+        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
+
+    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,
+        }
+
+        # 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/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
 
@@ -75,6 +76,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)
@@ -172,3 +177,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 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

@@ -93,6 +93,7 @@
   "ROUTE_CHECK_IF_FILE_EXISTS": "/checkIfFileExists",
   "ROUTE_LOAD_ARTIFACT_FROM_DISK": "/loadArtifactFromDisk",
   "ROUTE_RESTART_LANGUAGE_SERVER": "/restartLanguageServer",
+  "ROUTE_FILE_WATCH_LIST": "/fileWatchList",
   "JSON_SOURCE_PREFIX": "JSON-",
   "NESTED_PARAM": "NESTED_PARAM",
   "ARGS_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",