ivoryos 0.1.5__py3-none-any.whl

ivoryos/utils/form.py

@@ -0,0 +1,316 @@
+from wtforms.fields.core import Field
+from wtforms.utils import UnsetValue
+from wtforms.validators import InputRequired
+from wtforms.widgets.core import TextInput
+
+from flask_wtf import FlaskForm
+from wtforms import StringField, FloatField, HiddenField, BooleanField, IntegerField
+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
+    return None, None
+
+
+class VariableOrStringField(Field):
+    widget = TextInput()
+
+    def __init__(self, label='', validators=None, script=None, **kwargs):
+        super(VariableOrStringField, self).__init__(label, validators, **kwargs)
+        self.script = script
+
+    def process_formdata(self, valuelist):
+        if valuelist:
+            if not self.script.editing_type == "script" and valuelist[0].startswith("#"):
+                raise ValueError(self.gettext("Variable is not supported in prep/cleanup"))
+            self.data = valuelist[0]
+
+    def _value(self):
+        if self.script:
+            variable, value = find_variable(self.data, self.script)
+            if variable:
+                return variable
+
+        return str(self.data) if self.data is not None else ""
+
+
+class VariableOrFloatField(Field):
+    widget = TextInput()
+
+    def __init__(self, label='', validators=None, script=None, **kwargs):
+        super(VariableOrFloatField, self).__init__(label, validators, **kwargs)
+        self.script = script
+
+    def _value(self):
+        if self.script:
+            variable, value = find_variable(self.data, self.script)
+            if variable:
+                return variable
+
+        if self.raw_data:
+            return self.raw_data[0]
+        if self.data is not None:
+            return str(self.data)
+        return ""
+
+    def process_formdata(self, valuelist):
+        if not valuelist:
+            return
+        elif 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]
+            return
+        try:
+            if self.script:
+                try:
+                    variable, value = find_variable(valuelist[0], self.script)
+                    if variable:
+                        float(value)
+                        self.data = str(variable)
+                        return
+                except ValueError:
+                    pass
+
+            self.data = float(valuelist[0])
+        except ValueError as exc:
+            self.data = None
+            raise ValueError(self.gettext("Not a valid float value.")) from exc
+
+
+unset_value = UnsetValue()
+
+
+class VariableOrIntField(Field):
+    widget = TextInput()
+
+    def __init__(self, label='', validators=None, script=None, **kwargs):
+        super(VariableOrIntField, self).__init__(label, validators, **kwargs)
+        self.script = script
+
+    def _value(self):
+        if self.script:
+            variable, value = find_variable(self.data, self.script)
+            if variable:
+                return variable
+
+        if self.raw_data:
+            return self.raw_data[0]
+        if self.data is not None:
+            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)
+            if variable:
+                try:
+                    int(var_value)
+                    self.data = str(variable)
+                    return
+                except ValueError:
+                    pass
+        if 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]
+            return
+        try:
+            self.data = int(valuelist[0])
+        except ValueError as exc:
+            self.data = None
+            raise ValueError(self.gettext("Not a valid integer value.")) from exc
+
+
+class VariableOrBoolField(BooleanField):
+    widget = TextInput()
+
+    def __init__(self, label='', validators=None, script=None, **kwargs):
+        super(VariableOrBoolField, self).__init__(label, validators, **kwargs)
+        self.script = script
+
+    def process_data(self, value):
+
+        if self.script:
+            variable, var_value = find_variable(value, self.script)
+            if variable:
+                try:
+                    bool(var_value)
+                    return variable
+                except ValueError:
+                    return
+
+        self.data = bool(value)
+
+    def process_formdata(self, valuelist):
+        if not valuelist or type(valuelist) is list and valuelist[0] == '':
+            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
+
+    def _value(self):
+
+        if self.script:
+            variable, value = find_variable(self.raw_data, self.script)
+            if variable:
+                return variable
+
+        if self.raw_data:
+            return str(self.raw_data[0])
+        return "y"
+
+
+def format_name(name):
+    """Converts 'example_name' to 'Example Name'."""
+    name = name.split(".")[-1]
+    text = ' '.join(word for word in name.split('_'))
+    return text.capitalize()
+
+
+def create_form_for_method(method, method_name, autofill, script=None, design=True):
+    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')
+    }
+    sig = method if type(method) is inspect.Signature else inspect.signature(method)
+
+    for param in sig.parameters.values():
+        if param.name == 'self':
+            continue
+        formatted_param_name = format_name(param.name)
+        field_kwargs = {
+            "label": formatted_param_name,
+            "default": f'#{param.name}' if autofill else (param.default if param.default is not param.empty else ""),
+            **({"script": script} if (autofill or design) else {})
+        }
+        field_class, placeholder_text = annotation_mapping.get(
+            param.annotation,
+            (VariableOrStringField if design else StringField, f'Enter {param.annotation} 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, param.name, field)
+
+    # setattr(DynamicForm, f'add', fname)
+    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)
+    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}'})
+    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"))
+    method_forms = {}
+    for attr_name in dir(sdl_module):
+        attr = getattr(sdl_module, attr_name)
+        if inspect.ismethod(attr) and not attr_name.startswith('_'):
+            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) >}'''
+    method_forms = {}
+    for attr_name, signature in pseudo.items():
+        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):
+    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
+    field_kwargs = {
+        "label": f'statement',
+        "validators": [InputRequired()] if logic_type in ['wait', "variable"] else [],
+        "description": description_text,
+    }
+    render_kwargs = {"placeholder": placeholder_text}
+    field = field_class(**field_kwargs, render_kw=render_kwargs)
+    setattr(BuiltinFunctionForm, "statement", field)
+    if logic_type == 'variable':
+        variable_field = StringField(label=f'variable', validators=[InputRequired()],
+                                     description="Your variable name cannot include space",
+                                     render_kw=render_kwargs)
+        setattr(BuiltinFunctionForm, "variable", variable_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']}"
+    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']}"
+
+        text = f"{prefix}{action_text}  {arg_string}"
+    return dict(label=text, style=style, uuid=s["uuid"], id=s["id"])

ivoryos/utils/global_config.py

@@ -0,0 +1,68 @@
+# from ivoryos.utils.script_runner import ScriptRunner
+
+
+class GlobalConfig:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(GlobalConfig, cls).__new__(cls, *args, **kwargs)
+            cls._instance._deck = None
+            cls._instance._agent = None
+            cls._instance._defined_variables = {}
+            cls._instance._api_variables = set()
+            cls._instance._deck_variables = {}
+            cls._instance._runner = None
+        return cls._instance
+
+    @property
+    def deck(self):
+        return self._deck
+
+    @deck.setter
+    def deck(self, value):
+        if self._deck is None:
+            self._deck = value
+
+
+    @property
+    def deck_variables(self):
+        return self._deck_variables
+
+    @deck_variables.setter
+    def deck_variables(self, value):
+        self._deck_variables = value
+
+
+    @property
+    def agent(self):
+        return self._agent
+
+    @agent.setter
+    def agent(self, value):
+        if self._agent is None:
+            self._agent = value
+
+    @property
+    def defined_variables(self):
+        return self._defined_variables
+
+    @defined_variables.setter
+    def defined_variables(self, value):
+        self._defined_variables = value
+
+    @property
+    def api_variables(self):
+        return self._api_variables
+
+    @api_variables.setter
+    def api_variables(self, value):
+        self._api_variables = value
+
+    @property
+    def runner(self):
+        return self._runner
+
+    @runner.setter
+    def runner(self, value):
+        self._runner = value

ivoryos/utils/llm_agent.py

@@ -0,0 +1,183 @@
+import inspect
+import json
+import os
+import re
+
+from openai import OpenAI, BaseModel
+
+
+# from dotenv import load_dotenv
+# load_dotenv()
+
+# host = "137.82.65.246"
+# model = "llama3"
+
+# structured output,
+# class Action(BaseModel):
+#     action: str
+#     args: dict
+#     arg_types: dict
+#
+#
+# class ActionPlan(BaseModel):
+#     actions: list[Action]
+#     # final_answer: str
+
+
+class LlmAgent:
+    def __init__(self, model="llama3", output_path=os.curdir, host=None):
+        self.host = host
+        self.base_url = f"http://{self.host}:11434/v1/" if host is not None else ""
+        self.model = model
+        self.output_path = os.path.join(output_path, "llm_output") if output_path is not None else None
+        self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) if host is None else OpenAI(api_key="ollama",
+                                                                                              base_url=self.base_url)
+        if self.output_path is not None:
+            os.makedirs(self.output_path, exist_ok=True)
+
+    @staticmethod
+    def extract_annotations_docstrings(module_sigs):
+        class_str = ""
+
+        for name, value in module_sigs.items():
+            signature = value.get("signature")
+            docstring = value.get("docstring")
+            class_str += f'\tdef {name}{signature}:\n'
+            class_str += f'\t\t"""\n\t\t{docstring}\n\t\t"""' + '\n' if docstring else ''
+        class_str = class_str.replace('self, ', '')
+        class_str = class_str.replace('self', '')
+        name_list = list(module_sigs.keys())
+        # print(class_str)
+        # with open(os.path.join(self.output_path, "docstring_manual.txt"), "w") as f:
+        #     f.write(class_str)
+        return class_str, name_list
+
+    @staticmethod
+    def parse_code_from_msg(msg):
+        msg = msg.strip()
+        # print(msg)
+        # code_blocks = re.findall(r'```(?:json\s)?(.*?)```', msg, re.DOTALL)
+        code_blocks = re.findall(r'\[\s*\{.*?\}\s*\]', msg, re.DOTALL)
+
+        json_blocks = []
+        for block in code_blocks:
+            if not block.startswith('['):
+                start_index = block.find('[')
+                block = block[start_index:]
+            block = re.sub(r'//.*', '', block)
+            block = block.replace('True', 'true').replace('False', 'false')
+            try:
+                # Try to parse the block as JSON
+                json_data = json.loads(block.strip())
+                if isinstance(json_data, list):
+                    json_blocks = json_data
+            except json.JSONDecodeError:
+                continue
+        return json_blocks
+
+    def _generate(self, robot_sigs, prompt):
+        # deck_info, name_list = self.extract_annotations_docstrings(type(robot))
+        deck_info, name_list = self.extract_annotations_docstrings(robot_sigs)
+        full_prompt = '''I have some python functions, for example when calling them I want to write them using JSON, 
+it is necessary to include all args
+for example
+def dose_solid(amount_in_mg:float, bring_in:bool=True): def analyze():
+dose_solid(3)
+analyze()
+I would want to write to
+[
+{
+    "action": "dose_solid",
+    "arg_types": {
+        "amount_in_mg": "float",
+        "bring_in": "bool"
+    },
+    "args": {
+        "amount_in_mg": 3,
+        "bring_in": true
+    }
+},
+{
+    "action": "analyze",
+    "arg_types": {},
+    "args": {}
+}
+]
+''' + f'''
+Now these are my callable functions,
+{deck_info}
+and I want you to find the most appropriate function if I want to do these tasks
+"""{prompt}"""
+,and write a list of dictionary in json accordingly. Please only use these action names {name_list}, 
+can you also help find the default value you can't find the info from my request.
+'''
+        if self.output_path is not None:
+            with open(os.path.join(self.output_path, "prompt.txt"), "w") as f:
+                f.write(full_prompt)
+        messages = [{"role": "user",
+                     "content": full_prompt}, ]
+        # if self.host == "openai":
+        output = self.client.chat.completions.create(
+            messages=messages,
+            model=self.model,
+            # response_format={"type": "json_object"},
+        )
+        msg = output.choices[0].message.content
+        # msg = output.choices[0].message.parsed
+
+        code = self.parse_code_from_msg(msg)
+        code = [action for action in code if action.get('action', '') in name_list]
+        # print('\033[91m', code, '\033[0m')
+        return code
+
+    def generate_code(self, robot_signature, prompt, attempt_allowance: int = 3):
+        attempt = 0
+
+        while attempt < attempt_allowance:
+            _code = self._generate(robot_signature, prompt)
+            attempt += 1
+            if _code:
+                break
+
+        return self.fill_blanks(_code, robot_signature)
+        # return code
+
+    @staticmethod
+    def fill_blanks(actions, robot_signature):
+        for action in actions:
+            action_name = action['action']
+            action_signature = robot_signature.get(action_name).get('signature', {})
+            args = action.get("args", {})
+            arg_types = action.get("arg_types", {})
+            for param in action_signature.parameters.values():
+                if param.name == 'self':
+                    continue
+                if param.name not in args:
+                    args[param.name] = param.default if param.default is not param.empty else ''
+                    arg_types[param.name] = param.annotation.__name__
+            action['args'] = args
+            action['arg_types'] = arg_types
+        return actions
+
+
+if __name__ == "__main__":
+    from pprint import pprint
+    from example.sdl_example.abstract_sdl import deck
+
+    from utils import parse_functions
+
+    deck_sig = parse_functions(deck, doc_string=True)
+    # llm_agent = LlmAgent(host="openai", model="gpt-3.5-turbo")
+    llm_agent = LlmAgent(host="localhost", model="llama3.1")
+    # robot = IrohDeck()
+    # extract_annotations_docstrings(DummySDLDeck)
+    prompt = '''I want to start with dosing 10 mg of current sample, and add 1 mL of toluene 
+    and equilibrate for 10 minute at 40 degrees, then sample 20 ul of sample to analyze with hplc, and save result'''
+    code = llm_agent.generate_code(deck_sig, prompt)
+    pprint(code)
+
+"""
+I want to dose 10mg, 6mg, 4mg, 3mg, 2mg, 1mg to 6 vials
+I want to add 10 mg to vial a3, and 10 ml of liquid, then shake them for 3 minutes
+
+"""