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

setta/code_gen/find_placeholders.py

@@ -0,0 +1,13 @@
+from setta.utils.constants import C
+
+
+def tp(x):
+    return f"{C.TEMPLATE_PREFIX}{x}"
+
+
+def remove_tp(x):
+    return x.lstrip(C.TEMPLATE_PREFIX)
+
+
+def needs_yaml(script):
+    return tp("SETTA_YAML_FILE") in script

setta/code_gen/python/ast_utils.py

@@ -0,0 +1,183 @@
+import ast
+import builtins
+from typing import Set
+
+
+def not_in_root_imports(import_path, root_imports):
+    return not any(
+        import_path.startswith(root + ".") or import_path == root
+        for root in root_imports
+    )
+
+
+def is_instance_attribute(node: ast.AST) -> bool:
+    """
+    Determines if an attribute access chain involves an instance parameter (self/cls/etc).
+    Checks if any part of the attribute chain starts with the first parameter of a method.
+    """
+    if not isinstance(node, ast.Attribute):
+        return False
+
+    # Walk up the AST to find the enclosing function
+    current = node
+    while current and not isinstance(current, ast.FunctionDef):
+        current = getattr(current, "parent", None)
+
+    if not current:  # Not in a function
+        return False
+
+    # Check if the function is a method (has at least one argument)
+    if not current.args.args:
+        return False
+
+    # Get the instance parameter name (traditionally 'self' but could be anything)
+    instance_param = current.args.args[0].arg
+
+    # Build the complete attribute chain
+    base = node
+    while isinstance(base, ast.Attribute):
+        base = base.value
+
+    # Check if the chain starts with the instance parameter
+    return isinstance(base, ast.Name) and base.id == instance_param
+
+
+def find_missing_imports(code: str) -> Set[str]:
+    """
+    Analyzes Python code and returns a set of missing imports.
+    If a module is explicitly imported (directly or with alias), its submodules are not considered missing.
+
+    Args:
+        code (str): String containing Python code to analyze
+
+    Returns:
+        Set[str]: Set of import statements that are missing
+
+    Example:
+        >>> code = "import torch; x = torch.nn.CrossEntropyLoss()"
+        >>> find_missing_imports(code)
+        set()  # torch.nn is not considered missing since torch is imported
+    """
+    # Get set of built-in names
+    builtin_names = set(dir(builtins))
+
+    # Track existing imports, defined names, and missing imports
+    existing_imports = set()
+    root_imports = set()  # Track the root modules that are explicitly imported
+    defined_names = set()
+    missing_imports = set()
+
+    # Parse the code into an AST
+    try:
+        tree = ast.parse(code)
+    except SyntaxError as e:
+        raise ValueError(f"Invalid Python code: {str(e)}")
+
+    # Add parent references to make context checking easier
+    for parent in ast.walk(tree):
+        for child in ast.iter_child_nodes(parent):
+            child.parent = parent
+
+    # First pass: collect existing imports and defined names
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for name in node.names:
+                if name.asname:  # Alias
+                    existing_imports.add(name.asname)
+                    root_imports.add(name.asname)  # Add alias as root
+                else:
+                    existing_imports.add(name.name)  # Original name
+                    root_imports.add(name.name.split(".")[0])  # Add root module
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                for name in node.names:
+                    if name.asname:  # Alias
+                        existing_imports.add(name.asname)
+                        root_imports.add(name.asname)
+                    else:
+                        existing_imports.add(name.name)
+                        root_imports.add(name.name.split(".")[0])  # Add root module
+        elif isinstance(node, ast.FunctionDef):
+            defined_names.add(node.name)
+        elif isinstance(node, ast.ClassDef):
+            defined_names.add(node.name)
+        elif isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
+            defined_names.add(node.id)
+        elif isinstance(node, ast.arg):
+            defined_names.add(node.arg)
+
+    # Second pass: find potential missing imports
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name):
+            # Skip if it's a built-in, already imported, or locally defined
+            if (
+                node.id not in builtin_names
+                and node.id not in existing_imports
+                and node.id not in defined_names
+                and isinstance(node.ctx, ast.Load)
+                and not_in_root_imports(node.id, root_imports)
+            ):
+                missing_imports.add(node.id)
+        elif isinstance(node, ast.Attribute):
+            # Build the full attribute chain
+            attr_chain = []
+            current = node
+            while isinstance(current, ast.Attribute):
+                attr_chain.append(current.attr)
+                current = current.value
+
+            if isinstance(current, ast.Name):
+                attr_chain.append(current.id)
+
+                # Skip instance attributes (where chain starts with self/cls)
+                if is_instance_attribute(node):
+                    continue
+
+                # Skip if the root is a local name
+                if attr_chain[-1] in defined_names:
+                    continue
+
+                # Reverse to get correct order
+                attr_chain.reverse()
+
+                # Generate all possible import paths
+                for i in range(1, len(attr_chain)):
+                    import_path = ".".join(attr_chain[:i])
+                    if (
+                        import_path not in existing_imports
+                        and import_path not in builtin_names
+                        and import_path not in defined_names
+                        and not_in_root_imports(import_path, root_imports)
+                    ):
+                        missing_imports.add(import_path)
+
+    return missing_imports
+
+
+def find_top_level_symbols(source: str) -> Set[str]:
+    """Find all top-level symbol names that could cause naming conflicts."""
+    root = ast.parse(source)
+    symbols = set()
+
+    # Only look at top-level nodes
+    for node in root.body:
+        # Get top-level assignments
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    symbols.add(target.id)
+
+        # Get function and class names
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            symbols.add(node.name)
+
+        # Get import aliases and imported names
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                symbols.add(alias.asname if alias.asname else alias.name.split(".")[0])
+
+        elif isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                symbols.add(alias.asname if alias.asname else alias.name)
+
+    return symbols

setta/code_gen/python/check_scope.py

@@ -0,0 +1,187 @@
+import ast
+from dataclasses import dataclass
+from typing import List, Set
+
+from setta.code_gen.python.position_line_col import position_to_line_col
+
+
+@dataclass
+class ScopeRange:
+    start_line: int
+    start_col: int
+    end_line: int
+    end_col: int
+    variable_names: Set[str]
+
+
+class ScopeVisitor(ast.NodeVisitor):
+    def __init__(self):
+        self.scopes: List[ScopeRange] = []
+        self._current_scope_vars: Set[str] = set()
+
+    def visit_Name(self, node: ast.Name):
+        if isinstance(node.ctx, ast.Store):
+            self._current_scope_vars.add(node.id)
+        self.generic_visit(node)
+
+    def _visit_scope_node(self, node: ast.AST):
+        # Save previous scope variables
+        prev_vars = self._current_scope_vars.copy()
+        self._current_scope_vars = set()
+
+        # Visit the node's children
+        self.generic_visit(node)
+
+        # Create scope range
+        scope = ScopeRange(
+            start_line=node.lineno,
+            start_col=node.col_offset,
+            end_line=node.end_lineno,
+            end_col=node.end_col_offset,
+            variable_names=self._current_scope_vars,
+        )
+        self.scopes.append(scope)
+
+        # Restore previous scope variables
+        self._current_scope_vars = prev_vars
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        self._visit_scope_node(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef):
+        # Save previous scope variables
+        prev_vars = self._current_scope_vars.copy()
+        self._current_scope_vars = set()
+
+        # Visit the node's children
+        self.generic_visit(node)
+
+        # Class variables are accessible in methods, so we need to add them to method scopes
+        class_vars = self._current_scope_vars.copy()
+        for child in node.body:
+            if isinstance(child, ast.FunctionDef):
+                scope = next(
+                    (s for s in self.scopes if s.start_line == child.lineno), None
+                )
+                if scope:
+                    scope.variable_names.update(class_vars)
+
+        # Create scope range for the class itself
+        scope = ScopeRange(
+            start_line=node.lineno,
+            start_col=node.col_offset,
+            end_line=node.end_lineno,
+            end_col=node.end_col_offset,
+            variable_names=self._current_scope_vars,
+        )
+        self.scopes.append(scope)
+
+        # Restore previous scope variables
+        self._current_scope_vars = prev_vars
+
+    def visit_Module(self, node: ast.Module):
+        # Module node is special - it represents the entire file
+        self._current_scope_vars = set()
+
+        # Visit all children
+        self.generic_visit(node)
+
+        # For Module, use first/last line of content
+        first_line = float("inf")
+        last_line = 0
+        first_col = float("inf")
+        last_col = 0
+
+        for child in ast.walk(node):
+            if hasattr(child, "lineno"):
+                first_line = min(first_line, child.lineno)
+                first_col = min(first_col, child.col_offset)
+            if hasattr(child, "end_lineno"):
+                last_line = max(last_line, child.end_lineno)
+                last_col = max(last_col, child.end_col_offset)
+
+        # Handle empty files
+        if first_line == float("inf"):
+            first_line = 1
+            first_col = 0
+            last_line = 1
+            last_col = 0
+
+        scope = ScopeRange(
+            start_line=first_line,
+            start_col=first_col,
+            end_line=last_line,
+            end_col=last_col,
+            variable_names=self._current_scope_vars,
+        )
+        self.scopes.append(scope)
+
+
+def are_positions_in_scope_with_variable(
+    code: str, positions: list[tuple[int, int]], variable_name: str
+) -> list[bool]:
+    """
+    Check if multiple positions in the code are in the same scope as a specific variable.
+
+    This function analyzes Python code to determine whether each given position (line, column)
+    falls within a scope where a specified variable is defined. A scope can be a module,
+    function, or class definition.
+
+    Args:
+        code (str): The Python source code to analyze
+        positions (list[tuple[int, int]]): List of (line, column) tuples representing
+            positions to check. Line and column numbers are 1-based.
+        variable_name (str): Name of the variable to check for in the scope
+
+    Returns:
+        list[bool]: List of boolean values corresponding to each position in the input,
+            where True indicates the position is in a scope where the variable is defined,
+            and False indicates it is not.
+
+    Raises:
+        SyntaxError: If the provided code contains syntax errors (handled internally
+            by returning all False values)
+
+    Example:
+        >>> code = '''
+        def func():
+            x = 1
+            return x
+        '''
+        >>> positions = [(2, 0), (3, 4), (4, 0)]
+        >>> are_positions_in_scope_with_variable(code, positions, 'x')
+        [True, True, False]
+    """
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return [False] * len(positions)  # Return correct number of Falses
+
+    visitor = ScopeVisitor()
+    visitor.visit(tree)
+
+    output = []
+
+    line_col_positions = []
+    for x in positions:
+        line, col = position_to_line_col(code, x)
+        line_col_positions.append((line + 1, col))
+
+    for line, col in line_col_positions:
+        in_scope = False
+        # Check each scope
+        for scope in visitor.scopes:
+            # Check if position is within this scope
+            if (
+                scope.start_line <= line <= scope.end_line
+                and (scope.start_line != line or scope.start_col <= col)
+                and (scope.end_line != line or col <= scope.end_col)
+            ):
+                # Check if variable is defined in this scope
+                if variable_name in scope.variable_names:
+                    in_scope = True
+                    break
+
+        output.append(in_scope)
+
+    return output

setta/code_gen/python/generate_code.py

@@ -0,0 +1,280 @@
+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 import push_var_deep
+from .ast_utils import find_missing_imports, find_top_level_symbols
+
+
+def get_import_text(code, chars_before_template_var):
+    imports = [f"import {x}" for x in find_missing_imports(code)]
+    return f"\n{chars_before_template_var}".join(imports)
+
+
+def get_mappings(var_names, selected, is_dict, positionalOnlyParams=None):
+    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:
+            var_decl_prefix = var_declaration(
+                selected[v]["name"],
+                v,
+                is_dict,
+                return_prefix=True,
+                is_callable_param=True,
+            )
+            prefix += var_decl_prefix
+
+        curr_output = f"{prefix}{v}"
+        relative_positions.append({"startPos": curr_position + len(prefix), "value": v})
+        curr_position += len(curr_output)
+        output += curr_output
+
+    return output, relative_positions
+
+
+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_list_of_vars(var_names):
+    return get_mappings(var_names, None, is_dict=False, positionalOnlyParams=var_names)
+
+
+def get_boolean(value):
+    return "True" if value == "true" else "False"
+
+
+def var_declaration(
+    var_name, value, is_dict=False, return_prefix=False, is_callable_param=False
+):
+    if is_dict:
+        prefix = f'"{var_name}": '
+    else:
+        prefix = f"{var_name}=" if is_callable_param else f"{var_name} = "
+    if return_prefix:
+        return prefix
+    return f"{prefix}{value}"
+
+
+# returns the value and a relative_positions array (for populating some ref_var_name_positions) or None if not applicable
+# TODO: remove str(x["value"]). I don't think it's necessary since x["value"] should always be a string already.
+def get_value(x, selected):
+    type_value = x["type"]
+    if type_value == C.TEXT:
+        output = str(x["value"])
+        relative_positions = []
+    elif type_value == C.SLIDER or type_value == C.DROPDOWN:
+        output = str(x["value"])
+        relative_positions = []
+    elif type_value == C.SWITCH:
+        output = str(get_boolean(x["value"]))
+        relative_positions = []
+    elif type_value == C.COLOR_PICKER or type_value == C.PASSWORD:
+        output = f'"{x["value"]}"'
+        relative_positions = []
+    elif type_value == C.SECTION:
+        if not x["value"]["callable"]:
+            output, relative_positions = get_dict_contents(
+                x["value"]["usedParams"], selected
+            )
+            prefix = "{"
+            output = prefix + output + "}"
+            prefix_len = len(prefix)
+        else:
+            output, relative_positions = get_callable_params(
+                x["value"]["usedParams"], x["value"]["positionalOnlyParams"], selected
+            )
+            prefix = f"{x['value']['callable']}("
+            output = f"{prefix}{output})"
+            prefix_len = len(prefix)
+        relative_positions = [
+            {**r, "startPos": r["startPos"] + prefix_len} for r in relative_positions
+        ]
+    elif type_value == C.LIST_ROOT:
+        output, relative_positions = get_list_of_vars(x["value"])
+        output = f"[{output}]"
+        relative_positions = [
+            {**r, "startPos": r["startPos"] + 1} for r in relative_positions
+        ]
+    elif type_value in [C.DICT_ROOT, C.GROUP, C.NESTED_PARAM]:
+        output, relative_positions = get_dict_contents(x["value"], selected)
+        output = "{" + output + "}"
+        relative_positions = [
+            {**r, "startPos": r["startPos"] + 1} for r in relative_positions
+        ]
+    else:
+        output = None
+        relative_positions = []
+
+    return output, relative_positions
+
+
+def create_line(var_name, x, selected, force_appear):
+    value, relative_positions = get_value(x, selected)
+    # include any ref positions that were calculated in export_selected,
+    # because they too need to be shifted by the length of the variable declaration
+    relative_positions.extend(x["ref_var_name_positions"])
+    if value or force_appear:
+        prefix = var_declaration(var_name, value, return_prefix=True)
+        prefix_len = len(prefix)
+        value = f"{prefix}{value}"
+        relative_positions = [
+            {**r, "startPos": r["startPos"] + prefix_len} for r in relative_positions
+        ]
+    return value, relative_positions
+
+
+def generate_code(selected, chars_before_each_line, push_var_name=None):
+    code = ""
+    var_name_to_decl_position = {}
+    last_var_name = None
+    if push_var_name:
+        for v in selected.values():
+            if (
+                isinstance(v["value"], dict)
+                and push_var_name in v["value"]["unusedParams"]
+            ):
+                v["value"]["usedParams"].append(push_var_name)
+                v["dependencies"].append(push_var_name)
+                v["value"]["unusedParams"].remove(push_var_name)
+        selected = [{"var_name": k, **v} for k, v in selected.items()]
+        selected = push_var_deep(selected, push_var_name)
+        selected = {v.pop("var_name"): v for v in selected}
+
+    for var_name, x in selected.items():
+        force_appear = push_var_name == var_name
+        var_str, ref_var_name_positions = create_line(
+            var_name, x, selected, force_appear=force_appear
+        )
+        if var_str:
+            last_var_name = var_name
+            # We add the "before chars" after the new line.
+            # This way every var decl starts with the var instead of with the leading chars.
+            var_str = construct_var_decl_with_trailing_whitespace(
+                var_str, chars_before_each_line
+            )
+            startPos = len(code)
+            var_name_to_decl_position[var_name] = (
+                startPos,
+                var_str,
+                chars_before_each_line,
+            )
+            code += var_str
+            x["ref_var_name_positions"] = ref_var_name_positions
+
+    # Since each var declaration ends with the chars_before_each_line
+    # we need to remove the hanging one on the final variable declaration.
+    if last_var_name is not None:
+        startPos, var_str, chars_after_line = var_name_to_decl_position[last_var_name]
+        new_var_str = var_str.rstrip(chars_after_line)
+        var_name_to_decl_position[last_var_name] = startPos, new_var_str, ""
+        code = code.rstrip(chars_after_line)
+
+    return code, var_name_to_decl_position
+
+
+def construct_var_decl_with_trailing_whitespace(var_decl, chars_after_line):
+    return f"{var_decl}\n{chars_after_line}"
+
+
+def generate_imports(
+    code,
+    push_var_name,
+    var_name_to_decl_position,
+    template_var,
+    chars_before_template_var,
+):
+    if push_var_name:
+        startPos, var_decl, chars_after_line = var_name_to_decl_position[push_var_name]
+        endPos = startPos + len(var_decl)
+        parseable_str = make_parseable(code[startPos:endPos], push_var_name)
+        if parseable_str is None:
+            parseable_str = var_declaration(push_var_name, "None")
+        var_decl = construct_var_decl_with_trailing_whitespace(
+            parseable_str, chars_after_line
+        )
+        code = code[:startPos] + var_decl + code[endPos:]
+    startPos = template_var["startPos"]
+    endPos = startPos + len(template_var["keyword"])
+    # remove template var to infer imports, because ast will raise syntax error
+    code = code[:startPos] + code[endPos:]
+    imports = get_import_text(code, chars_before_template_var)
+    if len(imports) > 0:
+        imports += "\n"
+    return imports
+
+
+def convert_var_names_to_readable_form(
+    generated_code,
+    var_name_to_decl_rel_position,
+    exporter_obj,
+    ref_template_var_positions,
+    setup_code,
+):
+    # need to adjust line numbers and positions with prepended setup code length
+    # because the setup code has been prepended to the generated code
+    # after the line numbers and positions are calculated.
+    setup_code_len = len(setup_code)
+
+    all_ref_var_name_positions = [
+        (r["startPos"] + setup_code_len, r["value"])
+        for r in ref_template_var_positions["refs"]
+    ]
+
+    gen_code_template_var = get_gen_code_template_var(
+        ref_template_var_positions["templateVars"]
+    )
+
+    # convert to global positions
+    for var_name, (startPos, _, _) in var_name_to_decl_rel_position.items():
+        newStartPos = startPos + setup_code_len
+        if gen_code_template_var:
+            newStartPos += gen_code_template_var["startPos"]
+        all_ref_var_name_positions.append((newStartPos, var_name))
+        for r in exporter_obj.output[var_name]["ref_var_name_positions"]:
+            all_ref_var_name_positions.append((newStartPos + r["startPos"], r["value"]))
+
+    # create nice var names for references
+    top_level_symbols = find_top_level_symbols(generated_code)
+    var_name_to_nice_var_name_mapping = {}
+    for idx in range(len(all_ref_var_name_positions)):
+        position, var_name = all_ref_var_name_positions[idx]
+
+        # only create nice_var_name if we haven't already created it for this var_name
+        if var_name not in var_name_to_nice_var_name_mapping:
+            nice_name = exporter_obj.output[var_name]["name"]
+            nice_var_name = create_nice_var_name(top_level_symbols, nice_name)
+            top_level_symbols.add(nice_var_name)
+            var_name_to_nice_var_name_mapping[var_name] = nice_var_name
+
+        nice_var_name = var_name_to_nice_var_name_mapping[var_name]
+        all_ref_var_name_positions[idx] = position, var_name, nice_var_name
+
+    generated_code = replace_at_positions(generated_code, all_ref_var_name_positions)
+    return generated_code
+
+
+def create_nice_var_name(top_level_symbols, nice_name):
+    trial_name = nice_name
+    counter = 2
+    while trial_name in top_level_symbols:
+        trial_name = f"{nice_name}_{counter}"
+        counter += 1
+    return trial_name
+
+
+def get_chars_in_line_before_position(string, position):
+    last_newline = string.rfind("\n", 0, position)
+    if last_newline != -1:
+        return string[last_newline + 1 : position]
+    return ""