ivoryos 0.1.12__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,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

@@ -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

ivoryos/utils/utils.py

@@ -7,7 +7,6 @@ import pickle
 import subprocess
 import sys
 from collections import Counter
-from typing import Optional, Dict, Tuple
 
 from flask import session
 from flask_socketio import SocketIO
@@ -84,7 +83,6 @@ def available_pseudo_deck(path):
     """
     load pseudo deck (snapshot) from connection history
     """
-    import os
     return os.listdir(path)
 
 
@@ -103,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
@@ -132,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}")')
@@ -201,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():
@@ -338,8 +308,10 @@ def ax_initiation(data, arg_types):
 
 
 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)

ivoryos/version.py

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

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

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: ivoryos
-Version: 0.1.12
+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. 
+
+

{ivoryos-0.1.12.dist-info → ivoryos-0.1.18.dist-info}/RECORD

@@ -1,6 +1,6 @@
-ivoryos/__init__.py,sha256=pKaEGt1aqh4U0ofAVm2jdhyoyrR1jYlEO-Qi2T7Sfp4,4743
+ivoryos/__init__.py,sha256=F3KenDZX1zqei3PZ3tx1U77yXsbeytgMMhVJyJMkmJ0,6071
 ivoryos/config.py,sha256=3FPBYTIBhQTKDvsEoR8ZeTmg65D-CSFEdGmOuIL4pSI,1311
-ivoryos/version.py,sha256=LcIlFjHZFfiF9Rd4UHoakmombOFkxIYk00I181frGBM,23
+ivoryos/version.py,sha256=6BiuMUkhwQp6bzUZSF8np8F1NwCltEtK0sPBF__tepU,23
 ivoryos/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/auth/auth.py,sha256=7CdXjGAr1B_xsmwweakTWOoROgsOJf0MNTzlMP_5Nus,3240
@@ -8,21 +8,20 @@ ivoryos/routes/auth/templates/auth/login.html,sha256=WSRrKbdM_oobqSXFRTo-j9UlOgp
 ivoryos/routes/auth/templates/auth/signup.html,sha256=b5LTXtpfTSkSS7X8u1ldwQbbgEFTk6UNMAediA5BwBY,1465
 ivoryos/routes/control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/control/control.py,sha256=MmrcKrkjSKS589XhDdvPc7kWO0ApCNVZCtrgfzTAAN8,14163
-ivoryos/routes/control/templates/control/controllers.html,sha256=QdZAieEA4ODC-3KlsgHmFO35q8KXjm0KT43ZNpcBgEs,4084
+ivoryos/routes/control/templates/control/controllers.html,sha256=iIp0h6WA68gQj9OsoiB7dU1BqH8CGomTueR73F4C8eY,4274
 ivoryos/routes/control/templates/control/controllers_home.html,sha256=xFnBXTWMlyi2naMSsCEqFlX-Z1HJJDDtzITPvq-3nng,2733
 ivoryos/routes/control/templates/control/controllers_new.html,sha256=uOQo9kYmwX2jk3KZDkMUF_ylfNUIs_oIWb_kk_MMVDM,4921
 ivoryos/routes/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/database/database.py,sha256=IOrdtdsZ28bV7R1ZQfcwAeS5JDCkX-QYsP9i8BseD38,5684
 ivoryos/routes/database/templates/database/experiment_database.html,sha256=ABchwHYDovzwECc7UD4Mh8C_9JUl0YZpAAF9sFjNCs0,3434
 ivoryos/routes/design/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivoryos/routes/design/design.py,sha256=ZAUh-XOMhePCmY7q-hfru-4X6fDR3aKKyktrD2NC6M4,20876
-ivoryos/routes/design/templates/design/experiment_builder.html,sha256=lF8fDMHtwQjVznbCL4klV3o1p0tkqMptPY5IXR7WSuE,27327
+ivoryos/routes/design/design.py,sha256=489QCfjcCZuL7HKAvZVrxIL1wK4IhE0zUef_mmbNuMs,21003
+ivoryos/routes/design/templates/design/experiment_builder.html,sha256=-C84nHcK1grC8b_B5Lgbg6StJcP8x1oj2XAjRPj1oU0,28239
 ivoryos/routes/design/templates/design/experiment_run.html,sha256=JxYEbJqeJH8vZaSVI25EtNYmI_W5GSFdc02Y8y3kZGc,22543
 ivoryos/routes/main/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/main/main.py,sha256=yuVJzXAob1kc1dfflkTBIZQ0tdf6kChfuq-uQlN1e9Q,957
 ivoryos/routes/main/templates/main/help.html,sha256=IOktMEsOPk0SCiMBXZ4mpffClERAyX8W82fel71M3M0,9370
-ivoryos/routes/main/templates/main/home.html,sha256=D3DtJSpWtkMRZEsLOtLr0yJVD4qNYAWPytPeZuRP4yQ,3234
-ivoryos/static/.DS_Store,sha256=skh9ta8MJo1eOfvLDKqqVRNKQXFH2Wfse7ybGMLytNs,6148
+ivoryos/routes/main/templates/main/home.html,sha256=ujM0YC0yrHhCfkuprNnZZZd8XEEguS_6NjrY5ktfctg,3356
 ivoryos/static/favicon.ico,sha256=RhlrPtfITOkzC9BjP1UB1V5L9Oyp6NwNtWeMcGOnpyc,15406
 ivoryos/static/logo.webp,sha256=lXgfQR-4mHTH83k7VV9iB54-oC2ipe6uZvbwdOnLETc,14974
 ivoryos/static/style.css,sha256=cbQ8T8h42smwuyF5qQ_pNhlptDXGcuyK2u4sUppqnyI,3717
@@ -32,16 +31,16 @@ ivoryos/static/js/overlay.js,sha256=dPxop19es0E0ZUSY3d_4exIk7CJuQEnlW5uTt5fZfzI,
 ivoryos/static/js/socket_handler.js,sha256=O7r33couafOE9QCvUK9mP0kJRiBFw2K-Qk1cjtMI5Vg,1415
 ivoryos/static/js/sortable_card.js,sha256=ifmlGe3yy0U_KzMphV4ClRhK2DLOvkELYMlq1vECuac,807
 ivoryos/static/js/sortable_design.js,sha256=1lI1I8FbL66tv6n-SX2FkbHNDYo36xVo2qDBKVLmxnQ,1120
-ivoryos/templates/base.html,sha256=OR04eHEgmq4Wj0en3z6J2l-CdcJjZryRBjLsWyKdnCo,7800
+ivoryos/templates/base.html,sha256=8HDi7I74ugcCAV4c3ha4C__-7xopt4ZsC0OQ2E_AsQ8,8313
 ivoryos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivoryos/utils/db_models.py,sha256=XoReukuWiroDX4OTfyd9dHRpGIN2woWL017P7N-VZ0U,20918
-ivoryos/utils/form.py,sha256=zpEFUyx9nMZkkTYVL0DIT3kEWd1DQsDGSBu4UysXf4s,12338
+ivoryos/utils/db_models.py,sha256=Y0KymXvb5uHwXwDrtUpc9DNxCBH9pHCmU39Hf4Hwlv4,24835
+ivoryos/utils/form.py,sha256=1h6eytHz1tv5_CIc_C6KGYn5JEPYniIOxo49yzM37o0,17149
 ivoryos/utils/global_config.py,sha256=Ojcz6xKATSbMLnTT0kiKqSnu_bNqCMyIAnZyHaKxJns,1589
 ivoryos/utils/llm_agent.py,sha256=DTf-AF56vy1Em1fUKagl5NURKittmNoxTKIw1PlyC2o,6413
-ivoryos/utils/script_runner.py,sha256=sFAUGCcfsA8DEPgw7koqEAr9fnxxYNRuiOC3L3yOwwc,7079
-ivoryos/utils/utils.py,sha256=5pNF5QJMXmImxDR0IRqaMzIy9n0fD_M1SUY1v9koEc8,15368
-ivoryos-0.1.12.dist-info/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
-ivoryos-0.1.12.dist-info/METADATA,sha256=-aWjCWBd57wVqDBrPxwJdUPW3picfwV-I47vgpo0xX8,6335
-ivoryos-0.1.12.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-ivoryos-0.1.12.dist-info/top_level.txt,sha256=FRIWWdiEvRKqw-XfF_UK3XV0CrnNb6EmVbEgjaVazRM,8
-ivoryos-0.1.12.dist-info/RECORD,,
+ivoryos/utils/script_runner.py,sha256=DImUy5jfv64lrF8CnQf0HGJjnesi7D8uqh4a939ihEQ,7231
+ivoryos/utils/utils.py,sha256=nQbGSR_FmlZyBb9lwKy3ws4FDAWWfDyu96hZg2DVIeI,14081
+ivoryos-0.1.18.dist-info/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
+ivoryos-0.1.18.dist-info/METADATA,sha256=ldWGQwTTe0M5hF4qi-kWrB0NJUCFvHjRL7F0cOwxq4g,6355
+ivoryos-0.1.18.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+ivoryos-0.1.18.dist-info/top_level.txt,sha256=FRIWWdiEvRKqw-XfF_UK3XV0CrnNb6EmVbEgjaVazRM,8
+ivoryos-0.1.18.dist-info/RECORD,,

{ivoryos-0.1.12.dist-info → ivoryos-0.1.18.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any