ivoryos 0.1.10__py3-none-any.whl → 0.1.18__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,48 +234,141 @@ 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):
+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 = f'Enter numbers' if logic_type == 'wait' else f'Enter statement'
-    description_text = f'Your variable can be numbers, boolean (True or False) or text ("text")' if logic_type == 'variable' else ''
-    field_class = FloatField if logic_type == 'wait' else StringField  # Default to StringField as a fallback
+    placeholder_text = {
+        'wait': 'Enter second',
+        'repeat': 'Enter an integer'
+    }.get(logic_type, 'Enter statement')
+    description_text = {
+        'variable': 'Your variable can be numbers, boolean (True or False) or text ("text")',
+    }.get(logic_type, '')
+    field_class = {
+        'wait': VariableOrFloatField,
+        'repeat': VariableOrIntField
+    }.get(logic_type, VariableOrStringField)  # Default to StringField as a fallback
     field_kwargs = {
         "label": f'statement',
         "validators": [InputRequired()] if logic_type in ['wait', "variable"] else [],
         "description": description_text,
+        "script": script
     }
     render_kwargs = {"placeholder": placeholder_text}
     field = field_class(**field_kwargs, render_kw=render_kwargs)
@@ -288,29 +377,63 @@ def create_builtin_form(logic_type):
         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):
-    style = ""
-    if s['instrument'] in ['if', 'while']:
-        text = f"{s['action']} {s['args']}"
-        style = "background-color: tomato"
-    elif s['instrument'] == 'variable':
-        text = f"{s['action']} = {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)]
+
+
+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'], "")
+
+    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"{s['return']} = " if s['return'] else ""
-        action_text = f"{s['instrument'].split('.')[-1] if s['instrument'].startswith('deck') else s['instrument']}.{s['action']}"
+        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 s['args']:
-            if type(s['args']) is dict:
-                arg_string = "(" + ", ".join([f"{k} = {v}" for k, v in s['args'].items()]) + ")"
+        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"= {s['args']}"
-
+                arg_string = f"= {action['args']}"
         text = f"{prefix}{action_text}  {arg_string}"
-    return dict(label=text, style=style, uuid=s["uuid"], id=s["id"], instrument=s['instrument'])
+    return dict(label=text, style=style, uuid=action["uuid"], id=action["id"], instrument=action['instrument'])

ivoryos/utils/script_runner.py

@@ -80,14 +80,17 @@ class ScriptRunner:
 
     def _run_actions(self, actions, section_name="", run_name=None, 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_event.is_set():
+            logger.info(f"Stopping execution during {section_name} section.")
+            return
+            # 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()
 
     def _run_config_section(self, config, arg_type, output_list, return_list, run_name, logger, socketio):
         compiled = True
@@ -133,7 +136,8 @@ class ScriptRunner:
                     function = self.globals_dict[fname]
                     output = function(**parameters)
                     # output = eval(f"{run_name}_script(**{parameters})")
-                    ax_client.complete_trial(trial_index=trial_index, raw_data=output)
+                    _output = output.copy()
+                    ax_client.complete_trial(trial_index=trial_index, raw_data=_output)
                     output.update(parameters)
                 except Exception as e:
                     logger.info(f'Optimization error: {e}')

ivoryos/utils/utils.py

@@ -6,7 +6,7 @@ import os
 import pickle
 import subprocess
 import sys
-from typing import Optional, Dict, Tuple
+from collections import Counter
 
 from flask import session
 from flask_socketio import SocketIO
@@ -83,7 +83,6 @@ def available_pseudo_deck(path):
     """
     load pseudo deck (snapshot) from connection history
     """
-    import os
     return os.listdir(path)
 
 
@@ -102,20 +101,9 @@ def _inspect_class(class_object=None, debug=False):
         if not function.startswith(under_score) and not function.isupper():
             try:
                 annotation = inspect.signature(method)
-                # if doc_string:
                 docstring = inspect.getdoc(method)
                 functions[function] = dict(signature=annotation, docstring=docstring)
 
-                # handle getter setters todo
-                # if callable(att):
-                #     functions[function] = inspect.signature(att)
-                # else:
-                #     att = getattr(class_object.__class__, function)
-                #     if isinstance(att, property) and att.fset is not None:
-                #         setter = att.fset.__annotations__
-                #         setter.pop('return', None)
-                #         if setter:
-                #             functions[function] = setter
             except Exception:
                 pass
     return functions
@@ -131,36 +119,22 @@ def _get_type_from_parameters(arg, parameters):
     if annotation is not inspect._empty:
         # print(p[arg].annotation)
         if annotation.__module__ == 'typing':
-            if hasattr(annotation, '_name') and annotation._name in ["Optional", "Union"]:
-                # print(p[arg].annotation.__args__)
-                arg_type = [i.__name__ for i in annotation.__args__]
-            elif hasattr(annotation, '__origin__'):
-                arg_type = annotation.__origin__.__name__
-            else:
-                # TODO
-                pass
+
+            if hasattr(annotation, '__origin__'):
+                origin = annotation.__origin__
+                if hasattr(origin, '_name') and origin._name in ["Optional", "Union"]:
+                    arg_type = [i.__name__ for i in annotation.__args__]
+                elif hasattr(origin, '__name__'):
+                    arg_type = origin.__name__
+                # todo other types
+        elif annotation.__module__ == 'types':
+            arg_type = [i.__name__ for i in annotation.__args__]
+
         else:
             arg_type = annotation.__name__
     return arg_type
 
 
-def find_variable_in_script(script: Script, args: Dict[str, str]) -> Optional[Tuple[Dict[str, str], Dict[str, str]]]:
-    # TODO: need to search for if the variable exists
-    added_variables: list[Dict[str, str]] = [action for action in script.currently_editing_script if
-                                             action["instrument"] == "variable"]
-
-    possible_variable_arguments = {}
-    possible_variable_types = {}
-
-    for arg_name, arg_val in args.items():
-        for added_variable in added_variables:
-            if added_variable["action"] == arg_val:
-                possible_variable_arguments[arg_name] = added_variable["action"]
-                possible_variable_types[arg_name] = "variable"
-
-    return possible_variable_arguments, possible_variable_types
-
-
 def _convert_by_str(args, arg_types):
     """
     Converts a value to type through eval(f'{type}("{args}")')
@@ -200,9 +174,6 @@ def convert_config_type(args, arg_types, is_class: bool = False):
     """
     Converts an argument from str to an arg type
     """
-    bool_dict = {"True": True, "False": False}
-    # print(args, arg_types)
-    # print(globals())
     if args:
         for arg in args:
             if arg not in arg_types.keys():
@@ -317,8 +288,9 @@ def ax_wrapper(data: dict, arg_types:list):
                 is_min = True if value == "minimize" else False
 
                 threshold = None if f"{obj_name}_threshold" not in data else data[f"{obj_name}_threshold"]
-                properties = ObjectiveProperties(minimize=is_min, threshold=threshold)
+                properties = ObjectiveProperties(minimize=is_min)
                 objectives[obj_name] = properties
+
     return parameter, objectives
 
 
@@ -331,13 +303,15 @@ def ax_initiation(data, arg_types):
     parameter, objectives = ax_wrapper(data, arg_types)
     from ax.service.ax_client import AxClient
     ax_client = AxClient()
-    ax_client.create_experiment(parameter, objectives)
+    ax_client.create_experiment(parameter, objectives=objectives)
     return ax_client
 
 
 def get_arg_type(args, parameters):
+    """get argument type from signature"""
     arg_types = {}
     # print(args, parameters)
+    parameters = parameters.get("signature")
     if args:
         for arg in args:
             arg_types[arg] = _get_type_from_parameters(arg, parameters)
@@ -423,3 +397,13 @@ def load_deck(pkl_name: str):
         return pseudo_deck
     except FileNotFoundError:
         return None
+
+
+def check_config_duplicate(config):
+    """
+    Checks if the config entry has any duplicate
+    :param config: [{"arg": 1}, {"arg": 1}, {"arg": 1}]
+    :return: [True, False]
+    """
+    hashable_data = [tuple(sorted(d.items())) for d in config]
+    return any(count > 1 for count in Counter(hashable_data).values())

ivoryos/version.py

@@ -1 +1 @@
-__version__ = "0.1.10"
+__version__ = "0.1.18"

{ivoryos-0.1.10.dist-info → ivoryos-0.1.18.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: ivoryos
-Version: 0.1.10
+Version: 0.1.18
 Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
 Home-page: https://gitlab.com/heingroup/ivoryos
 Author: Ivory Zhang
 Author-email: ivoryzhang@chem.ubc.ca
 License: MIT
+Platform: UNKNOWN
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: bcrypt
@@ -168,3 +169,5 @@ https://youtu.be/dFfJv9I2-1g
 Ivory Zhang, Lucy Hao
 
 Authors acknowledge all former and current Hein Lab members for their valuable suggestions. 
+
+