ivoryos 0.1.12__py3-none-any.whl → 0.1.19__py3-none-any.whl

ivoryos/utils/form.py

@@ -1,3 +1,4 @@
+from wtforms.fields.choices import SelectField
 from wtforms.fields.core import Field
 from wtforms.validators import InputRequired
 from wtforms.widgets.core import TextInput
@@ -8,16 +9,15 @@ import inspect
 
 
 def find_variable(data, script):
-    # TODO: needs to check for valid order of variables, important when editting
-    added_variables: list[dict[str, str]] = [action for action in script.currently_editing_script if
-                                             action["instrument"] == "variable"
-                                             # or action["return"] # TODO find returns
-                                             ]
-    for added_variable in added_variables:
-        if added_variable["action"] == data:
-            return data, added_variable["args"]
-        # if added_variable["return"] == data:
-        #     return data, None
+    """
+    find user defined variables and return values in the script:Script
+    :param data: string of input variable name
+    :param script:Script object
+    """
+    variables: dict[str, str] = script.get_variables()
+    for variable_name, variable_type in variables.items():
+        if variable_name == data:
+            return data, variable_type  # variable_type int float str or "function_output"
     return None, None
 
 
@@ -36,7 +36,7 @@ class VariableOrStringField(Field):
 
     def _value(self):
         if self.script:
-            variable, value = find_variable(self.data, self.script)
+            variable, variable_type = find_variable(self.data, self.script)
             if variable:
                 return variable
 
@@ -52,7 +52,7 @@ class VariableOrFloatField(Field):
 
     def _value(self):
         if self.script:
-            variable, value = find_variable(self.data, self.script)
+            variable, variable_type = find_variable(self.data, self.script)
             if variable:
                 return variable
 
@@ -73,14 +73,15 @@ class VariableOrFloatField(Field):
         try:
             if self.script:
                 try:
-                    variable, value = find_variable(valuelist[0], self.script)
+                    variable, variable_type = find_variable(valuelist[0], self.script)
                     if variable:
-                        float(value)
-                        self.data = str(variable)
+                        if not variable_type == "function_output":
+                            if variable_type not in ["float", "int"]:
+                                raise ValueError("Variable is not a valid float")
+                        self.data = variable
                         return
                 except ValueError:
                     pass
-
             self.data = float(valuelist[0])
         except ValueError as exc:
             self.data = None
@@ -99,7 +100,7 @@ class VariableOrIntField(Field):
 
     def _value(self):
         if self.script:
-            variable, value = find_variable(self.data, self.script)
+            variable, variable_type = find_variable(self.data, self.script)
             if variable:
                 return variable
 
@@ -109,34 +110,16 @@ class VariableOrIntField(Field):
             return str(self.data)
         return ""
 
-    # def process_data(self, value):
-    #
-    #     if self.script:
-    #         variable, var_value = find_variable(value, self.script)
-    #         if variable:
-    #             try:
-    #                 int(var_value)
-    #                 self.data = str(variable)
-    #                 return
-    #             except ValueError:
-    #                 pass
-    #     if value is None or value is unset_value:
-    #         self.data = None
-    #         return
-    #     try:
-    #         self.data = int(value)
-    #     except (ValueError, TypeError) as exc:
-    #         self.data = None
-    #         raise ValueError(self.gettext("Not a valid integer value.")) from exc
-
     def process_formdata(self, valuelist):
         if not valuelist:
             return
         if self.script:
-            variable, var_value = find_variable(valuelist[0], self.script)
+            variable, variable_type = find_variable(valuelist[0], self.script)
             if variable:
                 try:
-                    int(var_value)
+                    if not variable_type == "function_output":
+                        if not variable_type == "int":
+                            raise ValueError("Not a valid integer value")
                     self.data = str(variable)
                     return
                 except ValueError:
@@ -155,6 +138,7 @@ class VariableOrIntField(Field):
 
 class VariableOrBoolField(BooleanField):
     widget = TextInput()
+    false_values = (False, "false", "", "False", "f", "F")
 
     def __init__(self, label='', validators=None, script=None, **kwargs):
         super(VariableOrBoolField, self).__init__(label, validators, **kwargs)
@@ -163,30 +147,34 @@ class VariableOrBoolField(BooleanField):
     def process_data(self, value):
 
         if self.script:
-            variable, var_value = find_variable(value, self.script)
+            variable, variable_type = find_variable(value, self.script)
             if variable:
-                try:
-                    bool(var_value)
-                    return variable
-                except ValueError:
-                    return
+                if not variable_type == "function_output":
+                    raise ValueError("Not accepting boolean variables")
+                return variable
 
         self.data = bool(value)
 
     def process_formdata(self, valuelist):
-        if not valuelist or type(valuelist) is list and valuelist[0] == '':
+        # todo
+        # print(valuelist)
+        if not valuelist or not type(valuelist) is list:
             self.data = False
-        elif valuelist and valuelist[0].startswith("#"):
-            if not self.script.editing_type == "script":
-                raise ValueError(self.gettext("Variable is not supported in prep/cleanup"))
-            self.data = valuelist[0]
         else:
-            self.data = True
+            value = valuelist[0] if type(valuelist) is list else valuelist
+            if value.startswith("#"):
+                if not self.script.editing_type == "script":
+                    raise ValueError(self.gettext("Variable is not supported in prep/cleanup"))
+                self.data = valuelist[0]
+            elif value in self.false_values:
+                self.data = False
+            else:
+                self.data = True
 
     def _value(self):
 
         if self.script:
-            variable, value = find_variable(self.raw_data, self.script)
+            variable, variable_type = find_variable(self.raw_data, self.script)
             if variable:
                 return variable
 
@@ -202,7 +190,15 @@ def format_name(name):
     return text.capitalize()
 
 
-def create_form_for_method(method, method_name, autofill, script=None, design=True):
+def create_form_for_method(method, autofill, script=None, design=True):
+    """
+    Create forms for each method or signature
+    :param method: dict(docstring, signature)
+    :param autofill:bool if autofill is enabled
+    :param script:Script object
+    :param design: if design is enabled
+    """
+
     class DynamicForm(FlaskForm):
         pass
 
@@ -238,40 +234,125 @@ def create_form_for_method(method, method_name, autofill, script=None, design=Tr
     return DynamicForm
 
 
-# Create forms for each method in DummySDLDeck
-def create_add_form(attr, attr_name, autofill, script=None, design=True):
-    dynamic_form = create_form_for_method(attr, attr_name, autofill, script, design)
+def create_add_form(attr, attr_name, autofill: bool, script=None, design: bool = True):
+    """
+    Create forms for each method or signature
+    :param attr: dict(docstring, signature)
+    :param attr_name: method name
+    :param autofill:bool if autofill is enabled
+    :param script:Script object
+    :param design: if design is enabled. Design allows string input for parameter names ("#param") for all fields
+    """
+    signature = attr.get('signature', {})
+    docstring = attr.get('docstring', "")
+    dynamic_form = create_form_for_method(signature, autofill, script, design)
     if design:
         return_value = StringField(label='Save value as', render_kw={"placeholder": "Optional"})
         setattr(dynamic_form, 'return', return_value)
-    hidden_method_name = HiddenField(name=f'hidden_name', render_kw={"value": f'{attr_name}'})
+    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
 
 
-def create_form_from_module(sdl_module, autofill: bool, script=None, design=True):
-    # sdl_deck = DummySDLDeck(DummyPump("COM1"), DummyBalance("COM2"))
+def create_form_from_module(sdl_module, autofill: bool = False, script=None, design: bool = False):
+    """
+    Create forms for each method, used for control routes
+    :param sdl_module: method module
+    :param autofill:bool if autofill is enabled
+    :param script:Script object
+    :param design: if design is enabled
+    """
     method_forms = {}
     for attr_name in dir(sdl_module):
-        attr = getattr(sdl_module, attr_name)
-        if inspect.ismethod(attr) and not attr_name.startswith('_'):
+        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()
     return method_forms
 
 
 def create_form_from_pseudo(pseudo: dict, autofill: bool, script=None, design=True):
-    '''{'dose_liquid': < Signature(amount_in_ml: float, rate_ml_per_minute: float) >}'''
+    """
+    Create forms for pseudo method, used for design routes
+    :param pseudo:{'dose_liquid': {
+                        "docstring": "some docstring",
+                        "signature": Signature(amount_in_ml: float, rate_ml_per_minute: float) }
+                    }
+    :param autofill:bool if autofill is enabled
+    :param script:Script object
+    :param design: if design is enabled
+    """
     method_forms = {}
     for attr_name, signature in pseudo.items():
+        # signature = info.get('signature', {})
         form_class = create_add_form(signature, attr_name, autofill, script, design)
         method_forms[attr_name] = form_class()
     return method_forms
 
 
-def create_builtin_form(logic_type, autofill, script):
+def create_form_from_action(action: dict, script=None, design=True):
+    '''
+    Create forms for single action, used for design routes
+    :param action: {'action': 'dose_solid', 'arg_types': {'amount_in_mg': 'float', 'bring_in': 'bool'},
+                    'args': {'amount_in_mg': 5.0, 'bring_in': False}, 'id': 9,
+                    'instrument': 'deck.sdl', 'return': '', 'uuid': 266929188668995}
+    :param script:Script object
+    :param design: if design is enabled
+
+    '''
+
+    arg_types = action.get("arg_types", {})
+    args = action.get("args", {})
+    save_as = action.get("return")
+
+    class DynamicForm(FlaskForm):
+        pass
+
+    annotation_mapping = {
+        "int": (VariableOrIntField if design else IntegerField, 'Enter integer value'),
+        "float": (VariableOrFloatField if design else FloatField, 'Enter numeric value'),
+        "str": (VariableOrStringField if design else StringField, 'Enter text'),
+        "bool": (VariableOrBoolField if design else BooleanField, 'Empty for false')
+    }
+
+    for name, param_type in arg_types.items():
+        formatted_param_name = format_name(name)
+        value = args.get(name, "")
+        if type(value) is dict:
+            value = next(iter(value))
+        field_kwargs = {
+            "label": formatted_param_name,
+            "default": f'{value}',
+            "validators": [InputRequired()],
+            **({"script": script})
+        }
+        param_type = param_type if type(param_type) is str else f"{param_type}"
+        field_class, placeholder_text = annotation_mapping.get(
+            param_type,
+            (VariableOrStringField if design else StringField, f'Enter {param_type} value')
+        )
+        render_kwargs = {"placeholder": placeholder_text}
+
+        # Create the field with additional rendering kwargs for placeholder text
+        field = field_class(**field_kwargs, render_kw=render_kwargs)
+        setattr(DynamicForm, name, field)
+
+    if design:
+        return_value = StringField(label='Save value as', default=f"{save_as}", render_kw={"placeholder": "Optional"})
+        setattr(DynamicForm, 'return', return_value)
+    return DynamicForm()
+
+
+def create_builtin_form(logic_type, script):
+    """
+    Create a builtin form {if, while, variable, repeat, wait}
+    """
     class BuiltinFunctionForm(FlaskForm):
         pass
+
     placeholder_text = {
         'wait': 'Enter second',
         'repeat': 'Enter an integer'
@@ -296,33 +377,63 @@ def create_builtin_form(logic_type, autofill, script):
         variable_field = StringField(label=f'variable', validators=[InputRequired()],
                                      description="Your variable name cannot include space",
                                      render_kw=render_kwargs)
+        type_field = SelectField(
+            'Select Input Type',
+            choices=[('int', 'Integer'), ('float', 'Float'), ('str', 'String')],
+            default='str'  # Optional default value
+        )
         setattr(BuiltinFunctionForm, "variable", variable_field)
+        setattr(BuiltinFunctionForm, "type", type_field)
     hidden_field = HiddenField(name=f'builtin_name', render_kw={"value": f'{logic_type}'})
     setattr(BuiltinFunctionForm, "builtin_name", hidden_field)
     return BuiltinFunctionForm()
 
 
-def create_action_button(s: dict):
-    if s['instrument'] in ['if', 'while', 'repeat']:
-        text = f"{s['action']} {s['args']}"
-    elif s['instrument'] == 'variable':
-        text = f"{s['action']} = {s['args']}"
-    else:
-        # regular action button
-        prefix = f"{s['return']} = " if s['return'] else ""
-        action_text = f"{s['instrument'].split('.')[-1] if s['instrument'].startswith('deck') else s['instrument']}.{s['action']}"
-        arg_string = ""
-        if s['args']:
-            if type(s['args']) is dict:
-                arg_string = "(" + ", ".join([f"{k} = {v}" for k, v in s['args'].items()]) + ")"
-            else:
-                arg_string = f"= {s['args']}"
+def create_action_button(script, stype=None):
+    """
+    Creates action buttons for design route (design canvas)
+    :param script: Script object
+    :param stype: script type (script, prep, cleanup)
+    """
+    stype = stype or script.editing_type
+    variables = script.get_variables()
+    return [_action_button(i, variables) for i in script.get_script(stype)]
 
-        text = f"{prefix}{action_text}  {arg_string}"
+
+def _action_button(action: dict, variables: dict):
+    """
+    Creates action button for one action
+    :param action: Action dict
+    :param variables: created variable dict
+    """
     style = {
         "repeat": "background-color: lightsteelblue",
         "if": "background-color: salmon",
         "while": "background-color: salmon",
+    }.get(action['instrument'], "")
 
-    }.get(s['instrument'], "")
-    return dict(label=text, style=style, uuid=s["uuid"], id=s["id"], instrument=s['instrument'])
+    if action['instrument'] in ['if', 'while', 'repeat']:
+        text = f"{action['action']} {action['args'].get('statement', '')}"
+    elif action['instrument'] == 'variable':
+        text = f"{action['action']} = {action['args'].get('statement')}"
+    else:
+        # regular action button
+        prefix = f"{action['return']} = " if action['return'] else ""
+        action_text = f"{action['instrument'].split('.')[-1] if action['instrument'].startswith('deck') else action['instrument']}.{action['action']}"
+        arg_string = ""
+        if action['args']:
+            if type(action['args']) is dict:
+                arg_list = []
+                for k, v in action['args'].items():
+                    if isinstance(v, dict):
+                        value = next(iter(v))  # Extract the first key if it's a dict
+                        # show warning color for variable calling when there is no definition
+                        style = "background-color: khaki" if value not in variables.keys() else ""
+                    else:
+                        value = v  # Keep the original value if not a dict
+                    arg_list.append(f"{k} = {value}")  # Format the key-value pair
+                arg_string = "(" + ", ".join(arg_list) + ")"
+            else:
+                arg_string = f"= {action['args']}"
+        text = f"{prefix}{action_text}  {arg_string}"
+    return dict(label=text, style=style, uuid=action["uuid"], id=action["id"], instrument=action['instrument'])

ivoryos/utils/script_runner.py

@@ -1,3 +1,4 @@
+import ast
 import os
 import csv
 import threading
@@ -17,25 +18,40 @@ class ScriptRunner:
         if globals_dict is None:
             globals_dict = globals()
         self.globals_dict = globals_dict
-
-        self.stop_event = threading.Event()
+        self.pause_event = threading.Event()  # A threading event to manage pause/resume
+        self.pause_event.set()
+        self.stop_pending_event = threading.Event()
+        self.stop_current_event = threading.Event()
         self.is_running = False
         self.lock = threading.Lock()
 
+    def toggle_pause(self):
+        """Toggles between pausing and resuming the script"""
+        if self.pause_event.is_set():
+            self.pause_event.clear()  # Pause the script
+            return "Paused"
+        else:
+            self.pause_event.set()  # Resume the script
+            return "Resumed"
+
     def reset_stop_event(self):
-        self.stop_event.clear()
+        self.stop_pending_event.clear()
+        self.stop_current_event.clear()
 
-    def stop_execution(self):
-        self.stop_event.set()
+    def abort_pending(self):
+        self.stop_pending_event.set()
         # print("Stop pending tasks")
 
+    def stop_execution(self):
+        """Force stop everything, including ongoing tasks."""
+        self.stop_current_event.set()
+        self.abort_pending()
+
     def run_script(self, script, repeat_count=1, run_name=None, logger=None, socketio=None, config=None, bo_args=None,
                    output_path=""):
         global deck
         if deck is None:
             deck = global_config.deck
-        exec_string = script.compile()
-        exec(exec_string)
         time.sleep(1)
         with self.lock:
             if self.is_running:
@@ -50,24 +66,61 @@ class ScriptRunner:
         thread.start()
         return thread
 
+    def execute_function_line_by_line(self, script, section_name, logger, **kwargs):
+        """
+        Executes a function defined in a string line by line.
+
+        :param func_str: The function as a string
+        :param kwargs: Arguments to pass to the function
+        :return: The final result of the function execution
+        """
+        global deck
+        if deck is None:
+            deck = global_config.deck
+        # func_str = script.compile()
+        # Parse function body from string
+        module = ast.parse(script)
+        func_def = next(node for node in module.body if isinstance(node, ast.FunctionDef))
+
+        # Extract function body as source lines
+        lines = [ast.unparse(node) for node in func_def.body if not isinstance(node, ast.Return)]
+        # Prepare execution environment
+        exec_globals = {"deck": deck}  # Add required global objects
+        exec_locals = {}  # Local execution scope
+
+        # Define function arguments manually in exec_locals
+        exec_locals.update(kwargs)
+
+        # Execute each line dynamically
+        for line in lines:
+            if self.stop_current_event.is_set():
+                logger.info(f'Stopping execution during {section_name}')
+                break
+            logger.info(f"Executing: {line}")  # Debugging output
+            exec(line, exec_globals, exec_locals)
+            self.pause_event.wait()
+
+        return exec_locals  # Return the 'results' variable
+
     def _run_with_stop_check(self, script: Script, repeat_count, run_name, logger, socketio, config, bo_args,
                              output_path):
         time.sleep(1)
+        func_str = script.compile()
         self._emit_progress(socketio, 1)
         try:
             # Run "prep" section once
             script_dict = script.script_dict
-            self._run_actions(script_dict.get("prep", []), section_name="prep", run_name=run_name, logger=logger)
+            self._run_actions(script_dict.get("prep", []), func_str.get("prep", ''), section_name="prep", logger=logger)
             output_list = []
             _, arg_type = script.config("script")
             _, return_list = script.config_return()
             # Run "script" section multiple times
             if repeat_count:
-                self._run_repeat_section(repeat_count, arg_type, bo_args, output_list, return_list, run_name, logger, socketio)
+                self._run_repeat_section(repeat_count, arg_type, bo_args, output_list,  func_str.get("script", ''), run_name, return_list, logger, socketio)
             elif config:
-                self._run_config_section(config, arg_type, output_list, return_list, run_name, logger, socketio)
+                self._run_config_section(config, arg_type, output_list, func_str.get("script", ''), run_name, logger, socketio)
             # Run "cleanup" section once
-            self._run_actions(script_dict.get("cleanup", []), section_name="cleanup", run_name=run_name, logger=logger)
+            self._run_actions(script_dict.get("cleanup", []), func_str.get("cleanup", ''), section_name="cleanup", logger=logger)
             # Save results if necessary
             if output_list:
                 self._save_results(run_name, arg_type, return_list, output_list, logger, output_path)
@@ -78,18 +131,14 @@ class ScriptRunner:
                 self.is_running = False  # Reset the running flag when done
             self._emit_progress(socketio, 100)
 
-    def _run_actions(self, actions, section_name="", run_name=None, logger=None):
+    def _run_actions(self, actions, func_str, section_name="", logger=None):
         logger.info(f'Executing {section_name} steps') if actions else logger.info(f'No {section_name} steps')
-        for action in actions:
-            if self.stop_event.is_set():
-                logger.info(f"Stopping execution during {section_name} section.")
-                break
-            logger.info(f'Executing {action.get("action", "")} action')
-            fname = f"{run_name}_{section_name}"
-            function = self.globals_dict[fname]
-            function()
+        if self.stop_pending_event.is_set():
+            logger.info(f"Stopping execution during {section_name} section.")
+            return
+        self.execute_function_line_by_line(func_str, section_name, logger)
 
-    def _run_config_section(self, config, arg_type, output_list, return_list, run_name, logger, socketio):
+    def _run_config_section(self, config, arg_type, output_list, func_str, run_name, logger, socketio):
         compiled = True
         for i in config:
             try:
@@ -101,25 +150,25 @@ class ScriptRunner:
         if compiled:
             for i, kwargs in enumerate(config):
                 kwargs = dict(kwargs)
-                if self.stop_event.is_set():
+                if self.stop_pending_event.is_set():
                     logger.info(f'Stopping execution during {run_name}: {i + 1}/{len(config)}')
                     break
                 logger.info(f'Executing {i + 1} of {len(config)} with kwargs = {kwargs}')
                 progress = (i + 1) * 100 / len(config)
                 self._emit_progress(socketio, progress)
-                fname = f"{run_name}_script"
-                function = self.globals_dict[fname]
-                output = function(**kwargs)
+                # fname = f"{run_name}_script"
+                # function = self.globals_dict[fname]
+                output = self.execute_function_line_by_line(func_str, "script", logger, **kwargs)
                 if output:
-                    kwargs.update(output)
-                    output_list.append(kwargs)
+                    # kwargs.update(output)
+                    output_list.append(output)
 
-    def _run_repeat_section(self, repeat_count, arg_types, bo_args, output_list, return_list, run_name, logger, socketio):
+    def _run_repeat_section(self, repeat_count, arg_types, bo_args, output_list,  func_str, run_name, return_list, logger, socketio):
         if bo_args:
             logger.info('Initializing optimizer...')
             ax_client = utils.ax_initiation(bo_args, arg_types)
         for i in range(int(repeat_count)):
-            if self.stop_event.is_set():
+            if self.stop_pending_event.is_set():
                 logger.info(f'Stopping execution during {run_name}: {i + 1}/{int(repeat_count)}')
                 break
             logger.info(f'Executing {run_name} experiment: {i + 1}/{int(repeat_count)}')
@@ -129,20 +178,20 @@ class ScriptRunner:
                 try:
                     parameters, trial_index = ax_client.get_next_trial()
                     logger.info(f'Output value: {parameters}')
-                    fname = f"{run_name}_script"
-                    function = self.globals_dict[fname]
-                    output = function(**parameters)
-                    # output = eval(f"{run_name}_script(**{parameters})")
-                    _output = output.copy()
+                    # fname = f"{run_name}_script"
+                    # function = self.globals_dict[fname]
+                    output = self.execute_function_line_by_line(func_str, "script", logger, **parameters)
+
+                    _output = {key: value for key, value in output.items() if key in return_list}
                     ax_client.complete_trial(trial_index=trial_index, raw_data=_output)
                     output.update(parameters)
                 except Exception as e:
                     logger.info(f'Optimization error: {e}')
                     break
             else:
-                fname = f"{run_name}_script"
-                function = self.globals_dict[fname]
-                output = function()
+                # fname = f"{run_name}_script"
+                # function = self.globals_dict[fname]
+                output = self.execute_function_line_by_line(func_str, "script", logger)
 
             if output:
                 output_list.append(output)