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

setta/database/seed.py

@@ -0,0 +1,41 @@
+import glob
+import json
+
+from setta.database.db.projects.utils import add_defaults_to_project
+from setta.utils.constants import BASE_UI_TYPES, SEED_FOLDER
+from setta.utils.utils import get_absolute_path
+
+from .db.projects.save import save_project_details
+from .db.uiTypes.save import save_ui_types
+
+
+def seed_base_ui_types(db):
+    save_ui_types(db, BASE_UI_TYPES)
+
+
+def seed_examples(db):
+    example_jsons = glob.glob(
+        str(get_absolute_path(__file__, SEED_FOLDER / "examples/**/*.json"))
+    )
+    for filepath in example_jsons:
+        # if (
+        #     "reviews" not in filepath
+        #     and "medical" not in filepath
+        #     and "financial" not in filepath
+        # ):
+        #     continue
+        # if "hf" not in filepath:
+        #     continue
+        # if "img_to_img" not in filepath:
+        #     continue
+        with open(filepath, "r") as f:
+            data = json.load(f)
+        add_defaults_to_project(data)  # json files don't have all the defaults
+        save_project_details(db, data)
+
+
+def seed(db, with_examples=False, with_base_ui_types=False):
+    if with_base_ui_types:
+        seed_base_ui_types(db)
+    if with_examples:
+        seed_examples(db)

setta/database/settings_file.py

@@ -0,0 +1,118 @@
+import json
+import logging
+import os
+
+from setta.code_gen.export_selected import get_selected_section_variant
+from setta.database.db.projects.utils import (
+    add_defaults_to_project_and_load_json_sources,
+    filter_data_for_json_export,
+)
+from setta.database.db.sections.jsonSource import (
+    remove_json_source_data,
+    save_json_source_data,
+)
+from setta.utils.constants import CONSTANTS_FOLDER, USER_SETTINGS
+from setta.utils.utils import get_absolute_path, save_json_to_file
+
+logger = logging.getLogger(__name__)
+
+
+class SettingsFile:
+    def __init__(self):
+        self.meta_settings_file = MetaSettingsFile()
+        self.load_settings()
+
+    def save_settings(self, settings):
+        logger.debug("Saving settings")
+        paths = self.meta_settings_file.get_settings_paths()
+        to_be_saved = {}
+        for settings_slice, path in paths.items():
+            if path not in to_be_saved:
+                to_be_saved[path] = {}
+            to_be_saved[path].update({settings_slice: settings[settings_slice]})
+
+        for filename, data in to_be_saved.items():
+            save_json_to_file(filename, data)
+
+        USER_SETTINGS.update(settings)
+
+    def load_settings(self):
+        logger.debug("Loading settings")
+        paths = self.meta_settings_file.get_settings_paths()
+        output = {}
+        for settings_slice, path in paths.items():
+            with open(path, "r") as f:
+                output[settings_slice] = json.load(f)[settings_slice]
+
+        USER_SETTINGS.update(output)
+        return output
+
+    def load_settings_project(self):
+        return self.meta_settings_file.load_settings_project()
+
+    def save_settings_project(self, p):
+        self.meta_settings_file.save_settings_project(p)
+        return self.load_settings()
+
+
+class MetaSettingsFile:
+    def __init__(self):
+        self.path_seed_settings = get_absolute_path(
+            __file__, CONSTANTS_FOLDER / "Settings.json"
+        )
+        self.path_seed_meta_settings = get_absolute_path(
+            __file__, CONSTANTS_FOLDER / "settingsProject.json"
+        )
+        self.path_default_settings = "setta-settings.json"
+        self.path_meta_settings = "setta-meta-settings.json"
+        self.load_seed_files()
+
+    def get_settings_paths(self):
+        settings_slice_to_path = {}
+        p = self.load_meta_settings()
+        for k in self.obj_seed_settings.keys():
+            path = self.find_path_for_settings_slice(p, k)
+            if not path:
+                self.seed_settings(self.path_default_settings)
+            elif not os.path.exists(path):
+                self.seed_settings(path)
+            settings_slice_to_path[k] = path
+        return settings_slice_to_path
+
+    def find_path_for_settings_slice(self, p, slice):
+        for sectionId, section in p["sections"].items():
+            if section["jsonSourceKeys"] == [slice]:
+                variant = get_selected_section_variant(p, sectionId)
+                return variant["name"]
+        return None
+
+    def seed_settings(self, path):
+        if not os.path.exists(path):
+            save_json_to_file(path, self.obj_seed_settings)
+
+    def seed_meta_settings(self):
+        if not os.path.exists(self.path_meta_settings):
+            save_json_to_file(self.path_meta_settings, self.obj_seed_meta_settings)
+
+    def load_meta_settings(self):
+        logger.debug("Loading meta settings")
+        self.seed_meta_settings()
+        with open(self.path_meta_settings, "r") as f:
+            return json.load(f)
+
+    def load_settings_project(self):
+        p = self.load_meta_settings()
+        add_defaults_to_project_and_load_json_sources(p)
+        return p
+
+    def load_seed_files(self):
+        with open(self.path_seed_settings, "r") as f:
+            self.obj_seed_settings = json.load(f)
+        with open(self.path_seed_meta_settings, "r") as f:
+            self.obj_seed_meta_settings = json.load(f)
+
+    def save_settings_project(self, p):
+        save_json_source_data(p)
+        remove_json_source_data(p, keepCodeInfoThatHaveUITypes=False)
+        filter_data_for_json_export(p)
+        save_json_to_file(self.path_meta_settings, p)

setta/database/utils.py

@@ -0,0 +1,32 @@
+import copy
+from uuid import uuid4
+
+
+def create_new_id():
+    return str(uuid4())
+
+
+def maybe_new_id(x):
+    return x if x else create_new_id()
+
+
+def rename_keys(x, to_rename):
+    output = copy.deepcopy(x)
+    for old_key in to_rename.keys():
+        new_key = to_rename[old_key]
+        if old_key in output and new_key != old_key:
+            output[new_key] = output[old_key]
+            del output[old_key]
+    return output
+
+
+def create_id_map(old_ids):
+    return dict((x, create_new_id()) for x in old_ids)
+
+
+def remap_ids(x, old_ids=None):
+    if old_ids is None:
+        old_ids = list(x.keys())
+    id_map = create_id_map(old_ids)
+    new_obj = rename_keys(x, id_map)
+    return new_obj, id_map

setta/lsp/file_watcher.py

@@ -0,0 +1,113 @@
+import asyncio
+import os
+import site
+from pathlib import Path
+from typing import Set
+
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+from watchdog.observers import Observer
+
+
+class LSPFileWatcher:
+    def __init__(self, notify_callback):
+        """
+        Initialize the file watcher.
+
+        Args:
+            notify_callback: Callback function that sends notifications to the LSP server.
+                           Should accept FileSystemEvent as parameter.
+        """
+        self.observer = Observer()
+        self.watched_paths: Set[str] = set()
+        self.handler = LSPEventHandler(notify_callback, asyncio.get_event_loop())
+
+    def add_workspace_folder(self, path: str) -> None:
+        """
+        Add a workspace folder to watch.
+
+        Args:
+            path: Path to the workspace folder
+        """
+        if not os.path.exists(path):
+            raise ValueError(f"Path does not exist: {path}")
+
+        absolute_path = os.path.abspath(path)
+        if absolute_path not in self.watched_paths:
+            self.watched_paths.add(absolute_path)
+            self.observer.schedule(self.handler, absolute_path, recursive=True)
+
+    def add_python_site_packages(self) -> None:
+        """Add Python site-packages directories to watched paths."""
+        for path in site.getsitepackages():
+            try:
+                self.add_workspace_folder(path)
+            except ValueError:
+                continue  # Skip if path doesn't exist
+
+    def start(self) -> None:
+        """Start the file watcher."""
+        self.observer.start()
+
+    def stop(self) -> None:
+        """Stop the file watcher."""
+        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):
+        self.callback = callback
+        self.loop = loop
+
+    def on_any_event(self, event: FileSystemEvent):
+        if event.is_directory:
+            return
+
+        changes = [
+            {
+                "uri": self._path_to_uri(event.src_path),
+                "type": self._get_change_type(event),
+            }
+        ]
+
+        if asyncio.iscoroutinefunction(self.callback):
+            self.loop.call_soon_threadsafe(
+                lambda: self.loop.create_task(self.callback(changes))
+            )
+        else:
+            self.callback(changes)
+
+    def _path_to_uri(self, path: str) -> str:
+        """Convert file path to URI format."""
+        return Path(path).as_uri()
+
+    def _get_change_type(self, event: FileSystemEvent) -> int:
+        """
+        Convert watchdog event type to LSP change type.
+        1: Created
+        2: Changed
+        3: Deleted
+        """
+        if event.event_type == "created":
+            return 1
+        elif event.event_type == "modified":
+            return 2
+        elif event.event_type == "deleted":
+            return 3
+        return 2  # Default to changed

setta/lsp/reader.py

@@ -0,0 +1,184 @@
+import asyncio
+import json
+import logging
+
+from setta.lsp.reader_fns.completion import process_completion_response
+from setta.lsp.reader_fns.definition import process_definition_response
+from setta.lsp.reader_fns.diagnostics import process_diagnostics_response
+from setta.lsp.reader_fns.documentHighlight import process_document_highlight_response
+from setta.lsp.reader_fns.references import process_references_response
+from setta.lsp.reader_fns.signatureHelp import process_signature_help_response
+from setta.utils.constants import C
+
+from .server import LanguageServerInteractor
+
+logger = logging.getLogger(__name__)
+
+
+class LanguageServerReader(LanguageServerInteractor):
+    def __init__(self, server, websocket_manager):
+        self.server = server
+        self.websocket_manager = websocket_manager
+        self.stop_event = asyncio.Event()
+        self.started = asyncio.Event()
+        self.reader_task = None
+
+    async def start_listener(self):
+        logger.debug(f"Starting {self.server.name} language server reader")
+        self.stop_event.clear()  # Reset the stop event
+        self.reader_task = asyncio.create_task(self.read_response())
+        await self.started.wait()
+
+    async def stop(self):
+        logger.debug(f"Stopping {self.server.name} language server reader")
+        self.stop_event.set()
+        self.started.clear()
+        if self.reader_task:
+            self.reader_task.cancel()
+            try:
+                await self.reader_task
+            except asyncio.CancelledError:
+                pass
+
+    async def read_response(self):
+        self.started.set()
+        while not self.stop_event.is_set():
+            try:
+                await self.read_and_process_message()
+            except Exception as e:
+                logging.error(f"Error reading from language server: {e}")
+                # Optional: add a small delay to prevent tight loop if there's a persistent error
+                await asyncio.sleep(0.1)
+
+    async def read_and_process_message(self):
+        headers = b""
+        while not self.stop_event.is_set():
+            chunk = await self.server.stdout.read(1)
+            if not chunk:
+                # Server stdout closed/EOF reached
+                self.stop_event.set()  # Signal to stop
+                return
+            headers += chunk
+            if headers.endswith(b"\r\n\r\n"):
+                break
+
+        if self.stop_event.is_set():
+            return
+
+        headers_str = headers.decode("utf-8")
+        header_parts = headers_str.split("\r\n")
+        content_length = 0
+        for header in header_parts:
+            if header.startswith("Content-Length:"):
+                content_length = int(header.split(":")[1].strip())
+                break
+
+        response = b""
+        while len(response) < content_length and not self.stop_event.is_set():
+            chunk = await self.server.stdout.read(content_length - len(response))
+            if not chunk:
+                # Server stdout closed/EOF reached
+                self.stop_event.set()  # Signal to stop
+                return
+            response += chunk
+
+        if self.stop_event.is_set():
+            return
+
+        try:
+            response = json.loads(response.decode("utf-8"))
+            await self.process_response(response)
+        except json.JSONDecodeError as e:
+            logger.debug(f"Error decoding JSON response: {e}")
+            return
+        except Exception as e:
+            logger.debug(f"Error processing response: {e}")
+            return
+
+    async def process_response(self, response):
+        logger.debug(f"Processing response: {response}")
+        id = response.get("id", None)
+        method = response.get("method", None)
+        if id:
+            output = self.process_response_with_id(id, method, response)
+        else:
+            output = self.process_response_without_id(method, response)
+
+        if id in self.pending_requests:
+            self.pending_requests[id].set_result(output["content"])
+        elif output["websocket_method"] == "return_to_requester":
+            await self.websocket_manager.send_message_to_requester(
+                output["websocket_return_id"], output["content"]
+            )
+        elif output["websocket_method"] == "broadcast":
+            await self.websocket_manager.broadcast(
+                {
+                    "messageType": output["websocket_message_type"],
+                    "content": output["content"],
+                }
+            )
+
+    def process_response_with_id(self, id, method, response):
+        metadata = self.msg_id_to_metadata.pop(id, {})
+        method = method if method else metadata["method"]
+        content = None
+        websocket_return_id = id
+        websocket_method = None
+        websocket_message_type = None
+        if (
+            not self.server.is_initialized
+            and id == self.server.initialization_request_id
+        ):
+            self.server.is_initialized = True
+            content = "Initialized"
+            websocket_method = "broadcast"
+            websocket_message_type = C.WS_LSP_STATUS
+        elif method == "textDocument/completion":
+            content = process_completion_response(response, metadata)
+            websocket_method = "return_to_requester"
+        elif method == "textDocument/signatureHelp":
+            content = process_signature_help_response(response)
+            websocket_method = "return_to_requester"
+        elif method == "textDocument/references":
+            content, websocket_return_id = process_references_response(
+                response, metadata
+            )
+            websocket_method = "return_to_requester"
+        elif method == "textDocument/documentHighlight":
+            content, websocket_return_id = process_document_highlight_response(
+                response, metadata
+            )
+            websocket_method = "return_to_requester"
+        elif method == "textDocument/definition":
+            content = process_definition_response(response)
+            websocket_method = "return_to_requester"
+
+        content = {"data": content, "otherData": metadata.get("otherData")}
+
+        return {
+            "content": content,
+            "websocket_return_id": websocket_return_id,
+            "websocket_method": websocket_method,
+            "websocket_message_type": websocket_message_type,
+        }
+
+    def process_response_without_id(self, method, response):
+        content = None
+        websocket_return_id = None
+        websocket_method = None
+        websocket_message_type = None
+
+        if method == "textDocument/publishDiagnostics":
+            content, needsDiagnostics = process_diagnostics_response(
+                response, self.get_code_metadata
+            )
+            if needsDiagnostics:
+                websocket_method = "broadcast"
+                websocket_message_type = C.WS_LSP_DIAGNOSTICS
+
+        return {
+            "content": content,
+            "websocket_return_id": websocket_return_id,
+            "websocket_method": websocket_method,
+            "websocket_message_type": websocket_message_type,
+        }

setta/lsp/reader_fns/completion.py

@@ -0,0 +1,84 @@
+from setta.code_gen.python.position_line_col import line_col_to_position_batch
+
+
+def process_completion_response(response, metadata):
+    content = []
+    if response["result"] and response["result"]["items"]:
+        code = metadata["code"]
+        content = process_completion(
+            code,
+            response["result"]["items"],
+            metadata["generated_var_names"],
+            metadata["referencable_var_names"],
+            metadata["cursor_offset"],
+        )
+    return content
+
+
+def process_completion(
+    code, items, generated_var_names, referencable_var_names, cursor_offset
+):
+    content = []
+    line_cols = []
+    content_idx_with_text_edit = {}
+    for x in items:
+        if x["label"] in generated_var_names:
+            continue
+        c = {"label": x["label"], "type": type_mapping[x["kind"]]}
+        if "textEdit" in x:
+            content_idx_with_text_edit[len(content)] = len(line_cols)
+            r = x["textEdit"]["range"]
+            line_cols.append(
+                (
+                    r["start"]["line"],
+                    r["start"]["character"],
+                )
+            )
+            line_cols.append((r["end"]["line"], r["end"]["character"]))
+
+        content.append(c)
+
+    if len(line_cols) > 0:
+        # use the raw line/character values because the code
+        # contains generated code
+        positions = line_col_to_position_batch(code, line_cols)
+        for i, j in content_idx_with_text_edit.items():
+            # shift it back by cursor_offset so that it's ready
+            # for the frontend
+            content[i]["from"] = positions[j] - cursor_offset
+            content[i]["to"] = positions[j + 1] - cursor_offset
+
+    for x in referencable_var_names:
+        content.append({"label": x, "type": "variable"})
+
+    return content
+
+
+type_mapping = {
+    1: "File",
+    2: "Module",
+    3: "Namespace",
+    4: "Package",
+    5: "Class",
+    6: "Method",
+    7: "Property",
+    8: "Field",
+    9: "Constructor",
+    10: "Enum",
+    11: "Interface",
+    12: "Function",
+    13: "Variable",
+    14: "Constant",
+    15: "String",
+    16: "Number",
+    17: "Boolean",
+    18: "Array",
+    19: "Object",
+    20: "Key",
+    21: "Null",
+    22: "EnumMember",
+    23: "Struct",
+    24: "Event",
+    25: "Operator",
+    26: "TypeParameter",
+}

setta/lsp/reader_fns/definition.py

@@ -0,0 +1,2 @@
+def process_definition_response(response):
+    return bool(response["result"])

setta/lsp/reader_fns/diagnostics.py

@@ -0,0 +1,99 @@
+import re
+
+from setta.code_gen.export_selected import get_gen_code_template_var
+from setta.code_gen.python.position_line_col import line_col_to_position_batch
+
+
+def process_diagnostics_response(response, get_code_metadata):
+    params = response["params"]
+    metadata = get_code_metadata(params["uri"])
+    if not metadata["needsDiagnostics"] or metadata["version"] != params["version"]:
+        return None, False
+
+    convert_diagnostic_line_cols_to_positions(metadata["code"], params["diagnostics"])
+
+    code_split = metadata["code"].split("\n")
+    diagnostics = process_diagnostics(
+        params["diagnostics"],
+        code_split,
+        metadata["codeJson"],
+        metadata["ref_template_var_positions"],
+    )
+
+    return {
+        "projectConfigId": metadata["projectConfigId"],
+        "codeSectionId": metadata["codeSectionId"],
+        "diagnostics": diagnostics,
+    }, True
+
+
+def process_diagnostics(diagnostics, code_split, codeJson, ref_template_var_positions):
+    output = []
+    gen_code_template_var = get_gen_code_template_var(
+        ref_template_var_positions["templateVars"]
+    )
+    if gen_code_template_var:
+        gen_code_start = gen_code_template_var["startPos"]
+        gen_code_end = gen_code_start + len(gen_code_template_var["value"])
+    for d in diagnostics:
+        start, end = d["range"]["start"], d["range"]["end"]
+        if gen_code_template_var and gen_code_start <= start["position"] < gen_code_end:
+            result = process_gen_code_diagnostic(d, code_split, codeJson, start, end)
+            output.extend(result)
+        # TODO: process diagnostics for non-generated code:
+        # else:
+        #     output.append(d)
+
+    return output
+
+
+def process_gen_code_diagnostic(d, code_split, codeJson, start, end):
+    if "code" not in d or not codeJson:
+        return []
+    if d["code"] == "reportArgumentType":
+        problem_var = code_split[start["line"]][
+            start["character"] : end["character"]
+        ].strip()
+        return [get_message_with_ids(codeJson, problem_var, d["message"])]
+    elif d["code"] == "reportCallIssue" and "missing" in d["message"]:
+        missing_params = extract_parameters(d["message"])
+        # get variable to the left of the equal sign
+        assigned_to = code_split[start["line"]].split("=")[0].strip()
+        unusedParams = codeJson[assigned_to]["value"]["unusedParams"]
+        output = []
+        for potential_problem_var in unusedParams:
+            if codeJson[potential_problem_var]["name"] in missing_params:
+                output.append(
+                    get_message_with_ids(codeJson, potential_problem_var, d["message"])
+                )
+        return output
+    return []
+
+
+def get_message_with_ids(code_json, problem_var, message):
+    section_id, param_info_id = (
+        code_json[problem_var]["sectionId"],
+        code_json[problem_var]["paramInfoId"],
+    )
+    return {"sectionId": section_id, "paramInfoId": param_info_id, "message": message}
+
+
+def extract_parameters(error_string):
+    pattern = r'"([^"]+)"'
+    parameters = re.findall(pattern, error_string)
+    return parameters
+
+
+def convert_diagnostic_line_cols_to_positions(code, diagnostics):
+    line_cols = []
+    for d in diagnostics:
+        x = d["range"]["start"]
+        line_cols.append((x["line"], x["character"]))
+        x = d["range"]["end"]
+        line_cols.append((x["line"], x["character"]))
+
+    positions = line_col_to_position_batch(code, line_cols)
+
+    for i, d in enumerate(diagnostics):
+        d["range"]["start"]["position"] = positions[i * 2]
+        d["range"]["end"]["position"] = positions[(i * 2) + 1]