ivoryos 1.3.9__py3-none-any.whl → 1.4.1__py3-none-any.whl

ivoryos/utils/db_models.py

@@ -122,7 +122,7 @@ class Script(db.Model):
                 pass
         raise TypeError(f"Input type error: cannot convert '{args}' to {arg_type}.")
 
-    def update_by_uuid(self, uuid, args, output):
+    def update_by_uuid(self, uuid, args, output, batch_action=False):
         action = self.find_by_uuid(uuid)
         if not action:
             return
@@ -134,6 +134,7 @@ class Script(db.Model):
             pass
         action['args'] = args
         action['return'] = output
+        action['batch_action'] = batch_action
 
     @staticmethod
     def eval_list(args, arg_types):
@@ -402,7 +403,7 @@ class Script(db.Model):
         """
 
         return_list = set([action['return'] for action in self.script_dict['script'] if not action['return'] == ''])
-        output_str = "return {"
+        output_str = "{"
         for i in return_list:
             output_str += "'" + i + "':" + i + ","
         output_str += "}"
@@ -451,7 +452,80 @@ class Script(db.Model):
                 ]
         return line_collection
 
-    def compile(self, script_path=None):
+    def render_script_lines(self, script_dict):
+        """
+        Convert the script_dict structure into a dict of displayable Python-like lines,
+        keeping ID consistency for highlighting.
+        """
+
+        def render_args(args):
+            if not args:
+                return ""
+            return ", ".join(f"{k}={v}" for k, v in args.items())
+
+        def parse_block(block):
+            lines = []
+            indent = 0
+            stack = []
+
+            for action in block:
+                act = action["action"]
+                _id = action["id"]
+
+                # Handle control structures
+                if act == "if":
+                    stmt = action["args"].get("statement", "")
+                    lines.append("    " * indent + f"if {stmt}:   # id:{_id}")
+                    indent += 1
+                    stack.append("if")
+
+                elif act == "else":
+                    indent -= 1
+                    lines.append("    " * indent + f"else:   # id:{_id}")
+                    indent += 1
+
+                elif act in ("endif", "endwhile"):
+                    if stack:
+                        stack.pop()
+                    indent = max(indent - 1, 0)
+                    lines.append("    " * indent + f"# {act}   # id:{_id}")
+
+                elif act == "while":
+                    stmt = action["args"].get("statement", "")
+                    lines.append("    " * indent + f"while {stmt}:   # id:{_id}")
+                    indent += 1
+                    stack.append("while")
+
+                else:
+                    # Regular function call
+                    instr = action["instrument"]
+                    args = render_args(action.get("args", {}))
+                    ret = action.get("return")
+                    line = "    " * indent
+                    if ret:
+                        line += f"{ret} = {instr}.{act}({args})   # id:{_id}"
+                    else:
+                        line += f"{instr}.{act}({args})   # id:{_id}"
+                    lines.append(line)
+
+            # Ensure empty control blocks get "pass"
+            final_lines = []
+            for i, line in enumerate(lines):
+                final_lines.append(line)
+                # if line.strip().startswith("else") and (
+                #         i == len(lines) - 1 or lines[i + 1].startswith("#") or "endif" in lines[i + 1]
+                # ):
+                    # final_lines.append("    " * (indent) + "pass")
+
+            return final_lines
+
+        return {
+            "prep": parse_block(script_dict.get("prep", [])),
+            "script": parse_block(script_dict.get("script", [])),
+            "cleanup": parse_block(script_dict.get("cleanup", []))
+        }
+
+    def compile(self, script_path=None, batch=False, mode="sample"):
         """
         Compile the current script to a Python file.
         :return: String to write to a Python file.
@@ -467,7 +541,7 @@ class Script(db.Model):
         for i in self.stypes:
             if self.script_dict[i]:
                 is_async = any(a.get("coroutine", False) for a in self.script_dict[i])
-                func_str = self._generate_function_header(run_name, i, is_async) + self._generate_function_body(i)
+                func_str = self._generate_function_header(run_name, i, is_async, batch) + self._generate_function_body(i, batch, mode)
                 exec_str_collection[i] = func_str
         if script_path:
             self._write_to_file(script_path, run_name, exec_str_collection)
@@ -485,7 +559,7 @@ class Script(db.Model):
             name += '_'
         return name
 
-    def _generate_function_header(self, run_name, stype, is_async):
+    def _generate_function_header(self, run_name, stype, is_async, batch=False):
         """
         Generate the function header.
         """
@@ -499,37 +573,54 @@ class Script(db.Model):
         function_header = f"{async_str}def {run_name}{script_type}("
 
         if stype == "script":
-            function_header += ", ".join(configure)
-
+            if batch:
+                function_header += "param_list" if configure else "n: int"
+            else:
+                function_header += ", ".join(configure)
         function_header += "):"
         # function_header += self.indent(1) + f"global {run_name}_{stype}"
         return function_header
 
-    def _generate_function_body(self, stype):
+    def _generate_function_body(self, stype, batch=False, mode="sample"):
         """
         Generate the function body for each type in stypes.
         """
         body = ''
         indent_unit = 1
+        if batch and stype == "script":
+            return_str, return_list = self.config_return()
+            if return_list and stype == "script":
+                body += self.indent(indent_unit) + "result_list = []"
+            for index, action in enumerate(self.script_dict[stype]):
+                text, indent_unit = self._process_action(indent_unit, action, index, stype, batch)
+                body += text
+            if return_list and stype == "script":
+                body += self.indent(indent_unit) + f"result_list.append({return_str})"
+                body += self.indent(indent_unit) + "return result_list"
 
-        for index, action in enumerate(self.script_dict[stype]):
-            text, indent_unit = self._process_action(indent_unit, action, index, stype)
-            body += text
-        return_str, return_list = self.config_return()
-        if return_list and stype == "script":
-            body += self.indent(indent_unit) + return_str
+        else:
+            for index, action in enumerate(self.script_dict[stype]):
+                text, indent_unit = self._process_action(indent_unit, action, index, stype)
+                body += text
+            return_str, return_list = self.config_return()
+            if return_list and stype == "script":
+                body += self.indent(indent_unit) + f"return {return_str}"
         return body
 
-    def _process_action(self, indent_unit, action, index, stype):
+    def _process_action(self, indent_unit, action, index, stype, batch=False, mode="sample"):
         """
         Process each action within the script dictionary.
         """
+        configure, config_type = self.config(stype)
+
         instrument = action['instrument']
         statement = action['args'].get('statement')
         args = self._process_args(action['args'])
 
         save_data = action['return']
         action_name = action['action']
+        batch_action = action.get("batch_action", False)
+
         next_action = self._get_next_action(stype, index)
         # print(args)
         if instrument == 'if':
@@ -550,7 +641,8 @@ class Script(db.Model):
         #     return inspect.getsource(my_function)
         else:
             is_async = action.get("coroutine", False)
-            return self._process_instrument_action(indent_unit, instrument, action_name, args, save_data, is_async)
+            dynamic_arg = len(configure) > 0
+            return self._process_instrument_action(indent_unit, instrument, action_name, args, save_data, is_async, dynamic_arg, batch, batch_action)
 
     def _process_args(self, args):
         """
@@ -610,7 +702,8 @@ class Script(db.Model):
             indent_unit -= 1
         return exec_string, indent_unit
 
-    def _process_instrument_action(self, indent_unit, instrument, action, args, save_data, is_async=False):
+    def _process_instrument_action(self, indent_unit, instrument, action, args, save_data, is_async=False, dynamic_arg=False,
+                                   batch=False, batch_action=False):
         """
         Process actions related to instruments.
         """
@@ -632,7 +725,18 @@ class Script(db.Model):
         if save_data:
             save_data += " = "
 
-        return self.indent(indent_unit) + save_data + single_line, indent_unit
+        if batch and not batch_action:
+            arg_list = [args[arg][1:] for arg in args if isinstance(args[arg], str) and args[arg].startswith("#")]
+            param_str = [f"param['{arg_list}']" for arg_list in arg_list if arg_list]
+            args_str = self.indent(indent_unit + 1) +  ", ".join(arg_list) + " = " + ", ".join(param_str) if arg_list else ""
+            if dynamic_arg:
+                for_string = self.indent(indent_unit) + "for param in param_list:" + args_str
+            else:
+                for_string = self.indent(indent_unit) + "for _ in range(n):"
+            output_code = for_string + self.indent(indent_unit + 1) + save_data + single_line
+        else:
+            output_code = self.indent(indent_unit) + save_data + single_line
+        return output_code, indent_unit
 
     def _process_dict_args(self, args):
         """

ivoryos/utils/decorators.py

@@ -16,6 +16,7 @@ def block(_func=None, *, category="general"):
             "func": func,
             "signature": inspect.signature(func),
             "docstring": inspect.getdoc(func),
+            "coroutine": inspect.iscoroutinefunction(func),
             "path": module
         }
         return func

ivoryos/utils/form.py

@@ -332,7 +332,9 @@ def create_add_form(attr, attr_name, autofill: bool, script=None, design: bool =
     dynamic_form = create_form_for_method(signature, autofill, script, design)
     if design:
         return_value = StringField(label='Save value as', render_kw={"placeholder": "Optional"})
+        batch_action = BooleanField(label='Batch Action', render_kw={"placeholder": "Optional"})
         setattr(dynamic_form, 'return', return_value)
+        setattr(dynamic_form, 'batch_action', batch_action)
     hidden_method_name = HiddenField(name=f'hidden_name', description=docstring, render_kw={"value": f'{attr_name}'})
     setattr(dynamic_form, 'hidden_name', hidden_method_name)
     return dynamic_form
@@ -348,13 +350,16 @@ def create_form_from_module(sdl_module, autofill: bool = False, script=None, des
     """
     method_forms = {}
     for attr_name in dir(sdl_module):
-        method = getattr(sdl_module, attr_name)
-        if inspect.ismethod(method) and not attr_name.startswith('_'):
-            signature = inspect.signature(method)
-            docstring = inspect.getdoc(method)
-            attr = dict(signature=signature, docstring=docstring)
-            form_class = create_add_form(attr, attr_name, autofill, script, design)
-            method_forms[attr_name] = form_class()
+        try:
+            method = getattr(sdl_module, attr_name)
+            if inspect.ismethod(method) and not attr_name.startswith('_'):
+                signature = inspect.signature(method)
+                docstring = inspect.getdoc(method)
+                attr = dict(signature=signature, docstring=docstring)
+                form_class = create_add_form(attr, attr_name, autofill, script, design)
+                method_forms[attr_name] = form_class()
+        except Exception as e:
+            print(f"Error creating form for {attr_name}: {e}")
     return method_forms
 
 
@@ -407,12 +412,22 @@ def create_form_from_action(action: dict, script=None, design=True):
         value = args.get(name, "")
         if type(value) is dict and value:
             value = next(iter(value))
+        if not value or value == "None":
+            value = None
+        else:
+            value = f'{value}'
+
         field_kwargs = {
             "label": name,
-            "default": f'{value}',
-            "validators": [InputRequired()],
+            "default": f'{value}' if value else None,
+            # todo get optional/required from snapshot
+            "validators": [Optional()],
             **({"script": script})
         }
+        if type(param_type) is list:
+            none_type = param_type[1]
+            if none_type == "NoneType":
+                param_type = param_type[0]
         param_type = param_type if type(param_type) is str else f"{param_type}"
         field_class, placeholder_text = annotation_mapping.get(
             param_type,
@@ -425,6 +440,9 @@ def create_form_from_action(action: dict, script=None, design=True):
         setattr(DynamicForm, name, field)
 
     if design:
+        if "batch_action" in action:
+            batch_action = BooleanField(label='Batch Action', default=bool(action["batch_action"]))
+            setattr(DynamicForm, 'batch_action', batch_action)
         return_value = StringField(label='Save value as', default=f"{save_as}", render_kw={"placeholder": "Optional"})
         setattr(DynamicForm, 'return', return_value)
     return DynamicForm()
@@ -537,10 +555,12 @@ def _action_button(action: dict, variables: dict):
     """
     style = {
         "repeat": "background-color: lightsteelblue",
-        "if": "background-color: salmon",
-        "while": "background-color: salmon",
-        "pause": "background-color: goldenrod",
+        "if": "background-color: mistyrose",
+        "while": "background-color: #a8b5a2",
+        "pause": "background-color: palegoldenrod",
     }.get(action['instrument'], "")
+    if not style:
+        style = "background-color: thistle" if 'batch_action' in action and action["batch_action"] else ""
 
     if action['instrument'] in ['if', 'while', 'repeat']:
         text = f"{action['action']} {action['args'].get('statement', '')}"

ivoryos/utils/nest_script.py

@@ -0,0 +1,314 @@
+class ConditionalStructureError(Exception):
+    """Raised when conditional structure is invalid"""
+    pass
+
+
+class ConditionalStructureError(Exception):
+    """Raised when control flow structure is invalid"""
+    pass
+
+
+class ConditionalStructureError(Exception):
+    """Raised when control flow structure is invalid"""
+    pass
+
+
+def validate_and_nest_control_flow(flat_steps):
+    """
+    Validates and converts flat control flow structures to nested blocks.
+
+    Handles:
+    - if/else/endif -> if_block/else_block
+    - repeat/endrepeat -> repeat_block
+    - while/endwhile -> while_block
+
+    Raises:
+        ConditionalStructureError: If the control flow structure is invalid
+    """
+    nested_steps = []
+    i = 0
+
+    while i < len(flat_steps):
+        step = flat_steps[i]
+        action = step["action"]
+
+        # Check for misplaced closing/middle statements
+        if action in ["else", "endif", "endrepeat", "endwhile"]:
+            raise ConditionalStructureError(
+                f"Found '{action}' at position {i} without matching opening statement. "
+                f"UUID: {step.get('uuid')}"
+            )
+
+        # Handle IF statements
+        if action == "if":
+            nested_step, steps_consumed = process_if_block(flat_steps, i)
+            nested_steps.append(nested_step)
+            i += steps_consumed
+
+        # Handle REPEAT statements
+        elif action == "repeat":
+            nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+            nested_steps.append(nested_step)
+            i += steps_consumed
+
+        # Handle WHILE statements
+        elif action == "while":
+            nested_step, steps_consumed = process_while_block(flat_steps, i)
+            nested_steps.append(nested_step)
+            i += steps_consumed
+
+        else:
+            # Regular step - add as-is
+            nested_steps.append(step)
+            i += 1
+
+    return nested_steps
+
+
+def process_if_block(flat_steps, start_index):
+    """
+    Process an if/else/endif block starting at start_index.
+
+    Returns:
+        tuple: (nested_step_with_blocks, total_steps_consumed)
+    """
+    step = flat_steps[start_index].copy()
+    if_uuid = step["uuid"]
+    if_block = []
+    else_block = []
+    current_block = if_block
+    found_else = False
+    found_endif = False
+    i = start_index + 1
+
+    while i < len(flat_steps):
+        current_step = flat_steps[i]
+        current_action = current_step["action"]
+
+        if current_action == "else":
+            if current_step["uuid"] == if_uuid:
+                if found_else:
+                    raise ConditionalStructureError(
+                        f"Multiple 'else' blocks found for if statement with UUID {if_uuid}. "
+                        f"Second 'else' at position {i}"
+                    )
+                current_block = else_block
+                found_else = True
+                i += 1
+                continue
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'else' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endif for if with UUID {if_uuid}"
+                )
+
+        elif current_action == "endif":
+            if current_step["uuid"] == if_uuid:
+                found_endif = True
+                i += 1
+                break
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'endif' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endif for if with UUID {if_uuid}"
+                )
+
+        elif current_action == "if":
+            # Nested if - process it
+            try:
+                nested_step, steps_consumed = process_if_block(flat_steps, i)
+                current_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested if starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "repeat":
+            # Nested repeat - process it
+            try:
+                nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+                current_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested repeat starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "while":
+            # Nested while - process it
+            try:
+                nested_step, steps_consumed = process_while_block(flat_steps, i)
+                current_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested while starting at position {i}: {str(e)}"
+                )
+
+        else:
+            # Regular step
+            current_block.append(current_step)
+            i += 1
+
+    if not found_endif:
+        raise ConditionalStructureError(
+            f"Missing 'endif' for if statement with UUID {if_uuid} starting at position {start_index}"
+        )
+
+    step["if_block"] = if_block
+    step["else_block"] = else_block
+
+    return step, i - start_index
+
+
+def process_repeat_block(flat_steps, start_index):
+    """
+    Process a repeat/endrepeat block starting at start_index.
+
+    Returns:
+        tuple: (nested_step_with_block, total_steps_consumed)
+    """
+    step = flat_steps[start_index].copy()
+    repeat_uuid = step["uuid"]
+    repeat_block = []
+    found_endrepeat = False
+    i = start_index + 1
+
+    while i < len(flat_steps):
+        current_step = flat_steps[i]
+        current_action = current_step["action"]
+
+        if current_action == "endrepeat":
+            if current_step["uuid"] == repeat_uuid:
+                found_endrepeat = True
+                i += 1
+                break
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'endrepeat' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endrepeat for repeat with UUID {repeat_uuid}"
+                )
+
+        elif current_action == "if":
+            # Nested if - process it
+            try:
+                nested_step, steps_consumed = process_if_block(flat_steps, i)
+                repeat_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested if starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "repeat":
+            # Nested repeat - process it
+            try:
+                nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+                repeat_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested repeat starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "while":
+            # Nested while - process it
+            try:
+                nested_step, steps_consumed = process_while_block(flat_steps, i)
+                repeat_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested while starting at position {i}: {str(e)}"
+                )
+
+        else:
+            # Regular step
+            repeat_block.append(current_step)
+            i += 1
+
+    if not found_endrepeat:
+        raise ConditionalStructureError(
+            f"Missing 'endrepeat' for repeat statement with UUID {repeat_uuid} starting at position {start_index}"
+        )
+
+    step["repeat_block"] = repeat_block
+
+    return step, i - start_index
+
+
+def process_while_block(flat_steps, start_index):
+    """
+    Process a while/endwhile block starting at start_index.
+
+    Returns:
+        tuple: (nested_step_with_block, total_steps_consumed)
+    """
+    step = flat_steps[start_index].copy()
+    while_uuid = step["uuid"]
+    while_block = []
+    found_endwhile = False
+    i = start_index + 1
+
+    while i < len(flat_steps):
+        current_step = flat_steps[i]
+        current_action = current_step["action"]
+
+        if current_action == "endwhile":
+            if current_step["uuid"] == while_uuid:
+                found_endwhile = True
+                i += 1
+                break
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'endwhile' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endwhile for while with UUID {while_uuid}"
+                )
+
+        elif current_action == "if":
+            # Nested if - process it
+            try:
+                nested_step, steps_consumed = process_if_block(flat_steps, i)
+                while_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested if starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "repeat":
+            # Nested repeat - process it
+            try:
+                nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+                while_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested repeat starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "while":
+            # Nested while - process it
+            try:
+                nested_step, steps_consumed = process_while_block(flat_steps, i)
+                while_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested while starting at position {i}: {str(e)}"
+                )
+
+        else:
+            # Regular step
+            while_block.append(current_step)
+            i += 1
+
+    if not found_endwhile:
+        raise ConditionalStructureError(
+            f"Missing 'endwhile' for while statement with UUID {while_uuid} starting at position {start_index}"
+        )
+
+    step["while_block"] = while_block
+
+    return step, i - start_index