setta 0.0.15.dev1__py3-none-any.whl → 0.0.17__py3-none-any.whl

setta/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.15.dev1"
+__version__ = "0.0.17"

setta/code_gen/export_selected.py

@@ -313,7 +313,7 @@ class Exporter:
                 (
                     used_params,
                     unused_params,
-                    positionalOnlyParams,
+                    passingStyles,
                 ) = self.export_section_params(id)
 
                 selected_item_ev_refs = get_selected_item_ev_refs(self.p, id)
@@ -334,7 +334,7 @@ class Exporter:
                     "callable": callable,
                     "usedParams": used_params,
                     "unusedParams": unused_params,
-                    "positionalOnlyParams": positionalOnlyParams,
+                    "passingStyles": passingStyles,
                 }
                 info["dependencies"] = [*used_params, *used_ref_var_names]
                 info["ref_var_name_positions"] = ref_var_name_positions
@@ -397,7 +397,7 @@ class Exporter:
             (
                 used_params,
                 unused_params,
-                positionalOnlyParams,
+                passingStyles,
             ) = self.export_section_params(id)
             info = {
                 "sectionId": id,
@@ -407,7 +407,7 @@ class Exporter:
                     "callable": None,
                     "usedParams": used_params,
                     "unusedParams": unused_params,
-                    "positionalOnlyParams": positionalOnlyParams,
+                    "passingStyles": passingStyles,
                 },
                 "dependencies": used_params,
                 "ref_var_name_positions": [],  # has to be populated when the code is generated
@@ -424,7 +424,7 @@ class Exporter:
         var_names = [x for x in var_names if x]
         used_params = []
         unused_params = []
-        positionalOnlyParams = set()
+        passingStyles = {}
         for v in var_names:
             if no_entered_value(self.output[v]["value"]):
                 unused_params.append(v)
@@ -432,12 +432,10 @@ class Exporter:
                 used_params.append(v)
 
             curr_param_info_id = self.output[v]["paramInfoId"]
-            positionalOnly = self.p["codeInfo"][curr_param_info_id].get(
-                "positionalOnly", False
+            passingStyles[v] = self.p["codeInfo"][curr_param_info_id].get(
+                "passingStyle", None
             )
-            if positionalOnly:
-                positionalOnlyParams.add(v)
-        return used_params, unused_params, positionalOnlyParams
+        return used_params, unused_params, passingStyles
 
     def export_param(self, section_id, id):
         codeInfo = self.p["codeInfo"][id]

setta/code_gen/python/generate_code.py

@@ -2,7 +2,7 @@ from setta.code_gen.export_selected import get_gen_code_template_var
 from setta.code_gen.python.make_parseable import make_parseable
 from setta.utils.utils import replace_at_positions
 
-from ...utils.constants import C
+from ...utils.constants import C, ParameterPassingStyle
 from ..utils import push_var_deep
 from .ast_utils import find_missing_imports, find_top_level_symbols
 
@@ -12,13 +12,22 @@ def get_import_text(code, chars_before_template_var):
     return f"\n{chars_before_template_var}".join(imports)
 
 
-def get_mappings(var_names, selected, is_dict, positionalOnlyParams=None):
+def get_mappings(var_names, selected, is_dict=False, passingStyles=None):
+    if passingStyles is None:
+        passingStyles = {}
     output = ""
     relative_positions = []
     curr_position = 0
     for idx, v in enumerate(var_names):
         prefix = "" if idx == 0 else ", "
-        if is_dict or v not in positionalOnlyParams:
+        if passingStyles.get(v) == ParameterPassingStyle.ARGS:
+            prefix = "*"
+        elif passingStyles.get(v) == ParameterPassingStyle.KWARGS:
+            prefix = "**"
+        elif is_dict or (
+            passingStyles.get(v) == ParameterPassingStyle.DEFAULT
+            or passingStyles.get(v) == ParameterPassingStyle.KEYWORD_ONLY
+        ):
             var_decl_prefix = var_declaration(
                 selected[v]["name"],
                 v,
@@ -40,14 +49,12 @@ def get_dict_contents(var_names, selected):
     return get_mappings(var_names, selected, is_dict=True)
 
 
-def get_callable_params(var_names, positionalOnlyParams, selected):
-    return get_mappings(
-        var_names, selected, is_dict=False, positionalOnlyParams=positionalOnlyParams
-    )
+def get_callable_params(var_names, passingStyles, selected):
+    return get_mappings(var_names, selected, passingStyles=passingStyles)
 
 
 def get_list_of_vars(var_names):
-    return get_mappings(var_names, None, is_dict=False, positionalOnlyParams=var_names)
+    return get_mappings(var_names, None)
 
 
 def get_boolean(value):
@@ -97,7 +104,7 @@ def get_value(x, selected):
             prefix_len = len(prefix)
         else:
             output, relative_positions = get_callable_params(
-                x["value"]["usedParams"], x["value"]["positionalOnlyParams"], selected
+                x["value"]["usedParams"], x["value"]["passingStyles"], selected
             )
             prefix = f"{x['value']['callable']}("
             output = f"{prefix}{output})"

setta/lsp/reader_fns/signatureHelp.py

@@ -2,6 +2,8 @@ import re
 
 import docstring_parser
 
+from setta.utils.constants import ParameterPassingStyle
+
 
 def process_signature_help_response(response):
     content = None
@@ -40,13 +42,21 @@ def wrapper_parse_signature(signature, docstring, get_proposed_params):
     params = get_proposed_params(signature, docstring)
     param_info_list = []
     positional_only_indicator_idx = -1
+    keyword_only_indicator_idx = -1
 
-    for idx, (name, default, description) in enumerate(params):
+    for idx, (name, _, _) in enumerate(params):
         if name == "/":
             positional_only_indicator_idx = idx
+        if name == "*":
+            keyword_only_indicator_idx = idx
+
+    for idx, (name, default, description) in enumerate(params):
+        if name in [None, "/", "*", "", "..."]:
             continue
-        if name in [None, "", "*", "..."]:
-            continue
+
+        passingStyle = get_passing_style(
+            idx, positional_only_indicator_idx, keyword_only_indicator_idx, name
+        )
 
         if not default:
             default = ""
@@ -57,16 +67,13 @@ def wrapper_parse_signature(signature, docstring, get_proposed_params):
         # Append parsed information to list
         param_info_list.append(
             {
-                "name": name,
+                "name": name.lstrip("*"),
                 "defaultVal": default,
                 "description": description,
-                "positionalOnly": False,
+                "passingStyle": passingStyle,
             }
         )
 
-    for idx in range(0, positional_only_indicator_idx):
-        param_info_list[idx]["positionalOnly"] = True
-
     return param_info_list
 
 
@@ -79,21 +86,55 @@ def get_pyright_param_proposals(signature, _):
     params = [(p["label"], p["documentation"]["value"]) for p in parameters]
     proposals = []
     for param, description in params:
-        # Extract parameter name and default value
-        if param.startswith("/"):
-            proposals.append((param, None, None))
-            continue
-        parts = param.split("=")
-        name = extract_variable_name(parts[0].strip())
-        default = parts[1].strip() if len(parts) > 1 else None
+        name, _, default = parse_param_name(param)
         proposals.append((name, default, description))
 
     return proposals
 
 
-def extract_variable_name(code_string):
-    # Find potential variable names
-    potential_names = re.findall(r"\b[a-zA-Z_]\w*\b", code_string)
+def parse_param_name(param_string):
+    # Special cases for / and *
+    if param_string in ["/", "*"]:
+        return param_string, None, None
+
+    # Extract default value if present
+    default_value = None
+    if "=" in param_string:
+        param_string, default_part = param_string.split("=", 1)
+        default_value = default_part.strip()
+
+    # Extract type annotation if present
+    type_annotation = None
+    if ":" in param_string:
+        param_string, type_part = param_string.split(":", 1)
+        type_annotation = type_part.strip()
 
-    # Return the first valid identifier
-    return next((name for name in potential_names if name.isidentifier()), None)
+    # Variable name is what remains, trimmed of whitespace
+    name = extract_variable_name(param_string)
+
+    return name, type_annotation, default_value
+
+
+def extract_variable_name(code_string):
+    # Find potential variable names including * and ** prefixes
+    potential_names = re.findall(r"\*{1,2}?[a-zA-Z_]\w*|\b[a-zA-Z_]\w*\b", code_string)
+
+    # For names with * or **, we don't need to check isidentifier() since they're not standard identifiers
+    # Just return the first match
+    if potential_names:
+        return potential_names[0]
+    return None
+
+
+def get_passing_style(
+    idx, positional_only_indicator_idx, keyword_only_indicator_idx, name
+):
+    if name.startswith("**"):  # Check for **kwargs first
+        return ParameterPassingStyle.KWARGS
+    if name.startswith("*"):  # Check for *args second
+        return ParameterPassingStyle.ARGS
+    if 0 <= idx < positional_only_indicator_idx:  # Then check position
+        return ParameterPassingStyle.POSITIONAL_ONLY
+    if keyword_only_indicator_idx > -1 and idx > keyword_only_indicator_idx:
+        return ParameterPassingStyle.KEYWORD_ONLY
+    return ParameterPassingStyle.DEFAULT

setta/routers/interactive.py

@@ -17,12 +17,17 @@ from setta.code_gen.export_selected import (
     get_section_type,
 )
 from setta.code_gen.find_placeholders import parse_template_var
+from setta.database.db.notifications.load import (
+    create_notification_dict,
+    load_notification,
+)
+from setta.database.db.notifications.save import save_notification
 from setta.tasks.fns.utils import replace_template_vars_with_random_names
 from setta.tasks.tasks import construct_subprocess_key
 from setta.utils.constants import C
 from setta.utils.utils import multireplace
 
-from .dependencies import get_lsp_writers, get_tasks
+from .dependencies import get_dbq, get_lsp_writers, get_tasks
 
 router = APIRouter()
 
@@ -36,6 +41,10 @@ class FormatCodeRequest(BaseModel):
     candidateTemplateVars: dict
 
 
+class KillInMemorySubprocessesRequest(BaseModel):
+    projectConfigId: str
+
+
 @router.post(C.ROUTE_SEND_PROJECT_TO_INTERACTIVE_CODE)
 async def route_send_project_to_interactive_code(
     x: UpdateInteractiveCodeRequest,
@@ -68,9 +77,20 @@ async def route_update_interactive_code(
 
 async def process_returned_content_from_multiple_tasks(tasks, to_run):
     all_content = await asyncio.gather(*to_run)
-    content = [item for sublist in all_content for item in sublist]
+    content = []
+    exception_occurred = False
+    for sublist in all_content:
+        for item in sublist:
+            if isinstance(item, Exception):
+                exception_occurred = True
+            else:
+                content.append(item)
     inMemorySubprocessInfo = tasks.getInMemorySubprocessInfo()
-    return {"inMemorySubprocessInfo": inMemorySubprocessInfo, "content": content}
+    return {
+        "inMemorySubprocessInfo": inMemorySubprocessInfo,
+        "content": content,
+        "exceptionOccurred": exception_occurred,
+    }
 
 
 async def update_interactive_code(p, tasks, lsp_writers, idx):
@@ -139,6 +159,39 @@ async def update_interactive_code(p, tasks, lsp_writers, idx):
     return initialContent
 
 
+@router.post(C.ROUTE_KILL_IN_MEMORY_SUBPROCESSES)
+async def route_kill_in_memory_subprocesses(
+    x: KillInMemorySubprocessesRequest, tasks=Depends(get_tasks), dbq=Depends(get_dbq)
+):
+    notification = None
+    try:
+        num_killed = tasks.kill_in_memory_subprocesses()
+        if num_killed == 0:
+            notification = create_notification_dict(
+                message="No subprocesses to kill",
+                type=C.NOTIFICATION_TYPE_INFO,
+                temporary=True,
+            )
+        else:
+            with dbq as db:
+                notification_id = save_notification(
+                    db,
+                    x.projectConfigId,
+                    C.NOTIFICATION_TYPE_INFO,
+                    f"Killed {num_killed} subprocesses",
+                )
+                notification = load_notification(db, notification_id)
+
+    except Exception as e:
+        notification = create_notification_dict(
+            message="Failed to kill subprocesses",
+            type=C.NOTIFICATION_TYPE_ERROR,
+            temporary=True,
+        )
+
+    return {"notification": notification}
+
+
 @router.post(C.ROUTE_FORMAT_CODE)
 async def route_format_code(x: FormatCodeRequest):
     p = x.project

setta/routers/projects.py

@@ -5,6 +5,11 @@ from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel
 
 from setta.database.backup import maybe_create_backup
+from setta.database.db.notifications.delete import delete_notification
+from setta.database.db.notifications.load import (
+    create_notification_dict,
+    load_project_notifications,
+)
 from setta.database.db.projects.delete import delete_project_configs
 from setta.database.db.projects.load import (
     ProjectNotFound,
@@ -85,6 +90,14 @@ class AddDefaultDataForJSONImportRequest(BaseModel):
     project: dict
 
 
+class GetNotificationsRequest(BaseModel):
+    projectConfigId: str
+
+
+class DeleteNotificationRequest(BaseModel):
+    notificationId: str
+
+
 @router.post(C.ROUTE_ALL_PROJECT_CONFIG_METADATA)
 def route_all_project_config_metadata(dbq=Depends(get_dbq)):
     with dbq as db:
@@ -120,9 +133,21 @@ def route_load_full_project(x: ProjectLoadFullRequest, dbq=Depends(get_dbq)):
 @router.post(C.ROUTE_SAVE_PROJECT)
 def route_save_project(x: ProjectSaveRequest, dbq=Depends(get_dbq)):
     with dbq as db:
-        maybe_create_backup(db.path)
-        save_project_details(db, x.project)
-        maybe_export_database(db, db.path)
+        notification = None
+        try:
+            # Perform existing save operations
+            maybe_create_backup(db.path)
+            save_project_details(db, x.project)
+            maybe_export_database(db, db.path)
+            # Return success response with notification
+            notification = create_notification_dict(message="Saved!", temporary=True)
+
+        except Exception as e:
+            notification = create_notification_dict(
+                message="Failed to save", type=C.NOTIFICATION_TYPE_ERROR, temporary=True
+            )
+
+        return {"notification": notification}
 
 
 @router.post(C.ROUTE_CREATE_PROJECT_CONFIG)
@@ -186,3 +211,17 @@ def router_filter_data_for_json_export(x: FilterDataForJSONExportRequest):
 def router_add_default_data_for_json_import(x: FilterDataForJSONExportRequest):
     add_defaults_to_project_and_load_json_sources(x.project)
     return x.project
+
+
+@router.post(C.ROUTE_GET_NOTIFICATIONS)
+def route_get_notifications(x: GetNotificationsRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        notifications = load_project_notifications(db, x.projectConfigId)
+        return notifications
+
+
+@router.post(C.ROUTE_DELETE_NOTIFICATION)
+def route_delete_notification(x: DeleteNotificationRequest, dbq=Depends(get_dbq)):
+    with dbq as db:
+        success = delete_notification(db, x.notificationId)
+        return {"success": success}

setta/routers/settings.py

@@ -1,6 +1,7 @@
 from fastapi import APIRouter, Depends
 from pydantic import BaseModel
 
+from setta.database.db.notifications.load import create_notification_dict
 from setta.utils.constants import C
 
 from .dependencies import get_settings_file
@@ -32,7 +33,16 @@ def route_load_settings(settings_file=Depends(get_settings_file)):
 def route_save_settings_project(
     x: SaveSettingsProjectRequest, settings_file=Depends(get_settings_file)
 ):
-    return settings_file.save_settings_project(x.settingsProject)
+    notification = None
+    try:
+        settings_file.save_settings_project(x.settingsProject)
+        notification = create_notification_dict(message="Saved!", temporary=True)
+    except Exception as e:
+        notification = create_notification_dict(
+            message="Failed to save", type=C.NOTIFICATION_TYPE_ERROR, temporary=True
+        )
+
+    return {"notification": notification}
 
 
 @router.post(C.ROUTE_LOAD_SETTINGS_PROJECT)

setta/static/constants/Settings.json

@@ -13,11 +13,12 @@
     "loadShortcut": "Mod + L",
     "searchShortcut": "Mod + K",
     "advancedSearchShortcut": "Mod + P",
+    "commandPaletteShortcut": "Mod + Shift + P",
     "resetZoomShortcut": "Mod + Comma",
     "copyShortcut": "Mod + C",
     "pasteShortcut": "Mod + V",
     "pasteAsRefShortcut": "Mod + Shift + V",
-    "sortingShortcut": "Shift",
+    "sortingShortcut": "Mod + Alt",
     "movingFreeShortcut": "Alt",
     "showTooltipShortcut": "Q",
     "tooltipToPlaintextShortcut": "Q + S",

setta/static/constants/constants.json

@@ -71,6 +71,7 @@
   "ROUTE_COPY_SECTIONS": "/copySections",
   "ROUTE_UPDATE_INTERACTIVE_CODE": "/updateInteractiveCode",
   "ROUTE_SEND_PROJECT_TO_INTERACTIVE_CODE": "/sendProjectTointeractiveCode",
+  "ROUTE_KILL_IN_MEMORY_SUBPROCESSES": "/killInMemorySubprocesses",
   "ROUTE_FORMAT_CODE": "/formatCode",
   "ROUTE_SEND_ARTIFACT": "/sendArtfiact",
   "ROUTE_LOAD_ARTIFACTS": "/loadArtifacts",
@@ -96,6 +97,8 @@
   "ROUTE_LOAD_ARTIFACT_FROM_DISK": "/loadArtifactFromDisk",
   "ROUTE_RESTART_LANGUAGE_SERVER": "/restartLanguageServer",
   "ROUTE_FILE_WATCH_LIST": "/fileWatchList",
+  "ROUTE_GET_NOTIFICATIONS": "/getNotifications",
+  "ROUTE_DELETE_NOTIFICATION": "/deleteNotification",
   "NESTED_PARAM": "NESTED_PARAM",
   "ARGS_PREFIX": "__",
   "TEMPLATE_PREFIX": "$",
@@ -122,5 +125,10 @@
     "IMAGE": ["img"],
     "CHART": ["list"],
     "CHAT": ["chatHistory"]
-  }
+  },
+  "NOTIFICATION_TYPE_SUCCESS": "success",
+  "NOTIFICATION_TYPE_ERROR": "error",
+  "NOTIFICATION_TYPE_WARNING": "warning",
+  "NOTIFICATION_TYPE_INFO": "info",
+  "NOTIFICATION_TYPE_SAVE": "save"
 }

setta/static/constants/db_init.sql

@@ -221,6 +221,21 @@ CREATE TABLE IF NOT EXISTS ArtifactGroup (
     FOREIGN KEY (artifactId) REFERENCES Artifact(id) ON DELETE CASCADE
 );
 
+CREATE TABLE IF NOT EXISTS Notifications (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  projectConfigId TEXT NOT NULL,
+  timestamp TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+  type TEXT NOT NULL,
+  message TEXT NOT NULL,
+  metadata JSON,
+  read_status BOOLEAN NOT NULL DEFAULT 0,
+  FOREIGN KEY (projectConfigId) REFERENCES ProjectConfig(id)
+);
+
+
+
+
+
 -- INSERTS ---
 INSERT OR IGNORE INTO Metadata (id, defaultProject) VALUES (1, NULL);
 

setta/static/constants/defaultValues.json

@@ -90,7 +90,7 @@
     "rcType": "parameter",
     "defaultVal": "",
     "description": "",
-    "positionalOnly": false,
+    "passingStyle": "DEFAULT",
     "isPinned": false,
     "isFrozen": false,
     "isSelected": false,