setta 0.0.15.dev3__py3-none-any.whl → 0.0.16__py3-none-any.whl

setta/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.15.dev3"
+__version__ = "0.0.16"

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/static/constants/Settings.json

@@ -13,6 +13,7 @@
     "loadShortcut": "Mod + L",
     "searchShortcut": "Mod + K",
     "advancedSearchShortcut": "Mod + P",
+    "commandPaletteShortcut": "Mod + Shift + P",
     "resetZoomShortcut": "Mod + Comma",
     "copyShortcut": "Mod + C",
     "pasteShortcut": "Mod + V",

setta/static/constants/defaultValues.json

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