ivoryos 0.1.11__tar.gz → 0.1.13__tar.gz

{ivoryos-0.1.11/ivoryos.egg-info → ivoryos-0.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ivoryos
-Version: 0.1.11
+Version: 0.1.13
 Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
 Home-page: https://gitlab.com/heingroup/ivoryos
 Author: Ivory Zhang

{ivoryos-0.1.11 → ivoryos-0.1.13}/ivoryos/__init__.py

@@ -18,7 +18,6 @@ from ivoryos.version import __version__ as ivoryos_version
 
 global_config = GlobalConfig()
 
-
 url_prefix = os.getenv('URL_PREFIX', "/ivoryos")
 app = Flask(__name__, static_url_path=f'{url_prefix}/static', static_folder='static')
 app.register_blueprint(main, url_prefix=url_prefix)
@@ -27,6 +26,7 @@ app.register_blueprint(design, url_prefix=url_prefix)
 app.register_blueprint(database, url_prefix=url_prefix)
 app.register_blueprint(control, url_prefix=url_prefix)
 
+
 def create_app(config_class=None):
     # url_prefix = os.getenv('URL_PREFIX', "/ivoryos")
     # app = Flask(__name__, static_url_path=f'{url_prefix}/static', static_folder='static')
@@ -59,8 +59,6 @@ def create_app(config_class=None):
         g.logger = logger
         g.socketio = socketio
 
-
-
     @app.route('/')
     def redirect_to_prefix():
         return redirect(url_for('main.index', version=ivoryos_version))  # Assuming 'index' is a route in your blueprint
@@ -93,14 +91,15 @@ def run(module=None, host="0.0.0.0", port=None, debug=None, llm_server=None, mod
     debug = debug if debug is not None else app.config.get('DEBUG', True)
 
     app.config["LOGGERS"] = logger
-    app.config["LOGGERS_PATH"] = logger_output_name or app.config["LOGGERS_PATH"] # default.log
+    app.config["LOGGERS_PATH"] = logger_output_name or app.config["LOGGERS_PATH"]  # default.log
     logger_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["LOGGERS_PATH"])
 
     if module:
         app.config["MODULE"] = module
         app.config["OFF_LINE"] = False
         global_config.deck = sys.modules[module]
-        global_config.deck_snapshot = utils.create_deck_snapshot(global_config.deck, output_path=app.config["DUMMY_DECK"], save=True)
+        global_config.deck_snapshot = utils.create_deck_snapshot(global_config.deck,
+                                                                 output_path=app.config["DUMMY_DECK"], save=True)
         # global_config.runner = ScriptRunner(globals())
     else:
         app.config["OFF_LINE"] = True
@@ -120,3 +119,4 @@ def run(module=None, host="0.0.0.0", port=None, debug=None, llm_server=None, mod
         for log in logger:
             utils.start_logger(socketio, log_filename=logger_path, logger_name=log)
     socketio.run(app, host=host, port=port, debug=debug, use_reloader=False, allow_unsafe_werkzeug=True)
+    # return app

{ivoryos-0.1.11 → ivoryos-0.1.13}/ivoryos/routes/control/control.py

@@ -187,7 +187,7 @@ def backend_control(instrument: str=None):
                 return json_output, 400
         else:
             return "instrument not exist", 400
-    return '', 200
+    return json_output, 200
 
 
 @control.route("/backend_control", methods=['GET'])

{ivoryos-0.1.11 → ivoryos-0.1.13}/ivoryos/routes/design/design.py

@@ -12,7 +12,8 @@ from werkzeug.utils import secure_filename
 
 from ivoryos.utils import utils
 from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils.form import create_builtin_form, create_action_button, format_name, create_form_from_pseudo
+from ivoryos.utils.form import create_builtin_form, create_action_button, format_name, create_form_from_pseudo, \
+    create_form_from_action
 from ivoryos.utils.db_models import Script
 from ivoryos.utils.script_runner import ScriptRunner
 
@@ -105,9 +106,10 @@ def experiment_builder(instrument=None):
     else:
         deck_variables = list(pseudo_deck.keys()) if pseudo_deck else []
         deck_variables.remove("deck_name") if len(deck_variables) > 0 else deck_variables
+    edit_action = session.get("edit_action")
     if instrument:
-        if instrument in ['if', 'while', 'variable', 'wait']:
-            forms = create_builtin_form(instrument)
+        if instrument in ['if', 'while', 'variable', 'wait', 'repeat']:
+            forms = create_builtin_form(instrument, autofill=autofill, script=script)
         else:
             if deck:
                 function_metadata = global_config.deck_snapshot.get(instrument, {})
@@ -116,8 +118,8 @@ def experiment_builder(instrument=None):
             functions = {key: data.get('signature', {}) for key, data in function_metadata.items()}
             forms = create_form_from_pseudo(pseudo=functions, autofill=autofill, script=script)
         if request.method == 'POST' and "hidden_name" in request.form:
-            all_kwargs = request.form.copy()
-            method_name = all_kwargs.pop("hidden_name", None)
+            # all_kwargs = request.form.copy()
+            method_name = request.form.get("hidden_name", None)
             # if method_name is not None:
             form = forms.get(method_name)
             kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
@@ -125,25 +127,18 @@ def experiment_builder(instrument=None):
             if form and form.validate_on_submit():
                 function_name = kwargs.pop("hidden_name")
                 save_data = kwargs.pop('return', '')
-                variable_kwargs = {}
-                variable_kwargs_types = {}
 
-                try:
-                    variable_kwargs, variable_kwargs_types = utils.find_variable_in_script(script, kwargs)
 
-                    for name in variable_kwargs.keys():
-                        del kwargs[name]
-                    primitive_arg_types = utils.get_arg_type(kwargs, functions[function_name])
 
-                except:
-                    primitive_arg_types = utils.get_arg_type(kwargs, functions[function_name])
+                primitive_arg_types = utils.get_arg_type(kwargs, functions[function_name])
 
-                kwargs.update(variable_kwargs)
+                # print(script.get_added_variables(), script.get_output_variables())
                 arg_types = {}
-                arg_types.update(variable_kwargs_types)
+                # arg_types.update(variable_kwargs_types)
                 arg_types.update(primitive_arg_types)
-                all_kwargs.update(variable_kwargs)
-
+                # all_kwargs.update(variable_kwargs)
+                script.eval_list(kwargs, arg_types)
+                kwargs = script.eval_variables(kwargs)
                 action = {"instrument": instrument, "action": function_name,
                           "args": {name: arg for (name, arg) in kwargs.items()},
                           "return": save_data,
@@ -155,9 +150,13 @@ def experiment_builder(instrument=None):
         elif request.method == 'POST' and "builtin_name" in request.form:
             kwargs = {field.name: field.data for field in forms if field.name != 'csrf_token'}
             if forms.validate_on_submit():
+                # print(kwargs)
                 logic_type = kwargs.pop('builtin_name')
                 if 'variable' in kwargs:
-                    script.add_variable(**kwargs)
+                    try:
+                        script.add_variable(**kwargs)
+                    except ValueError:
+                        flash("Invalid variable type")
                 else:
                     script.add_logic_action(logic_type=logic_type, **kwargs)
             else:
@@ -168,8 +167,10 @@ def experiment_builder(instrument=None):
             autofill = not autofill
             forms = create_form_from_pseudo(functions, autofill=autofill, script=script)
             session['autofill'] = autofill
+    elif edit_action:
+        forms = create_form_from_action(edit_action, script=script)
     utils.post_script_file(script)
-    design_buttons = [create_action_button(i) for i in script.currently_editing_script]
+    design_buttons = create_action_button(script)
     return render_template('experiment_builder.html', off_line=off_line, instrument=instrument, history=deck_list,
                            script=script, defined_variables=deck_variables,
                            local_variables=global_config.defined_variables,
@@ -250,10 +251,14 @@ def experiment_run():
     #     module = current_app.config.get('MODULE', '')
     #     deck = sys.modules[module] if module else None
     #     script.deck = os.path.splitext(os.path.basename(deck.__file__))[0]
-    design_buttons = {stype: [create_action_button(i) for i in script.get_script(stype)] for stype in script.stypes}
+    design_buttons = {stype: create_action_button(script, stype) for stype in script.stypes}
     config_preview = []
     config_file_list = [i for i in os.listdir(current_app.config["CSV_FOLDER"]) if not i == ".gitkeep"]
-    exec_string = script.compile(current_app.config['SCRIPT_FOLDER'])
+    try:
+        exec_string = script.compile(current_app.config['SCRIPT_FOLDER'])
+    except ValueError as e:
+        flash(e.__str__())
+        return redirect(url_for("design.experiment_builder"))
     # print(exec_string)
     config_file = request.args.get("filename")
     config = []
@@ -306,6 +311,8 @@ def experiment_run():
                               logger=g.logger, socketio=g.socketio, repeat_count=repeat,
                               output_path=datapath
                               )
+            if utils.check_config_duplicate(config):
+                flash(f"WARNING: Duplicate in config entries.")
         except Exception as e:
             flash(e)
     return render_template('experiment_run.html', script=script.script_dict, filename=filename, dot_py=exec_string,
@@ -490,14 +497,20 @@ def edit_action(uuid: str):
     script = utils.get_script_file()
     action = script.find_by_uuid(uuid)
     session['edit_action'] = action
-    if request.method == "POST":
+
+    if request.method == "POST" and action is not None:
+        forms = create_form_from_action(action, script=script)
         if "back" not in request.form:
-            args = request.form.to_dict()
-            save_as = args.pop('return', '')
-            try:
-                script.update_by_uuid(uuid=uuid, args=args, output=save_as)
-            except Exception as e:
-                flash(e.__str__())
+            kwargs = {field.name: field.data for field in forms if field.name != 'csrf_token'}
+            # print(kwargs)
+            if forms and forms.validate_on_submit():
+                save_as = kwargs.pop('return', '')
+                kwargs = script.eval_variables(kwargs)
+            # try:
+                script.update_by_uuid(uuid=uuid, args=kwargs, output=save_as)
+            # except Exception as e:
+            else:
+                flash(forms.errors)
         session.pop('edit_action')
     return redirect(url_for('design.experiment_builder'))
 

{ivoryos-0.1.11 → ivoryos-0.1.13}/ivoryos/routes/design/templates/design/experiment_builder.html

@@ -30,6 +30,7 @@
 
             {# edit action #}
             {% if session["edit_action"] %}
+{#                {{ session["edit_action"] }}#}
                 {% with action = session["edit_action"] %}
                     <h5> {{ format_name(action['action']) }} </h5>
                     <form role="form" method='POST' name="{{instrument}}" action="{{ url_for('design.edit_action', uuid=session["edit_action"]['uuid']) }}">
@@ -41,16 +42,26 @@
                                     <input class="form-control" type="text" id="arg" name="arg" placeholder="{{ action['arg_types']}}" value="{{ action['args'] }}" aria-labelledby="variableHelpBlock">
                                 </div>
                             {% else %}
-                                {% for arg in action['args'] %}
-                                <div class="input-group mb-3">
-                                    <label class="input-group-text">{{ format_name(arg) }}</label>
-                                    <input class="form-control" type="text" id="{{ arg }}" name="{{ arg }}" placeholder="{{ action['arg_types'][arg] }}" value="{{ action['args'][arg] }}" aria-labelledby="variableHelpBlock">
-                                </div>
+{#                                {% for arg in action['args'] %}#}
+{#                                <div class="input-group mb-3">#}
+{#                                    <label class="input-group-text">{{ format_name(arg) }}</label>#}
+{#                                    <input class="form-control" type="text" id="{{ arg }}" name="{{ arg }}" placeholder="{{ action['arg_types'][arg] }}" value="{{ action['args'][arg] }}" aria-labelledby="variableHelpBlock">#}
+{#                                </div>#}
+{#                                {% endfor %}#}
+{#                                <div class="input-group mb-3">#}
+{#                                    <label class="input-group-text">Save Output?</label>#}
+{#                                    <input class="form-control" type="text" id="return" name="return"  value="{{ action['return'] }}" aria-labelledby="variableHelpBlock">#}
+{#                                </div>#}
+                                {{ forms.hidden_tag() }}
+                                {% for field in forms %}
+                                    {% if field.type not in ['CSRFTokenField'] %}
+                                        <div class="input-group mb-3">
+                                            <label class="input-group-text">{{ field.label.text }}</label>
+                                            {{ field(class="form-control") }}
+                                            <div class="form-text">{{ field.description }} </div>
+                                        </div>
+                                    {% endif %}
                                 {% endfor %}
-                                <div class="input-group mb-3">
-                                    <label class="input-group-text">Save Output?</label>
-                                    <input class="form-control" type="text" id="return" name="return"  value="{{ action['return'] }}" aria-labelledby="variableHelpBlock">
-                                </div>
                             {% endif %}
                         </div>
                         {% endif %}
@@ -72,7 +83,7 @@
 <!--                    <div class="rounded flex-fill" style="height: 30px;background-color: aliceblue">-->
 <!--                        <h6  style=" text-align: center; ">{{ format_name(instrument) }}</h6>-->
 <!--                    </div>-->
-                    {% if instrument in ['if' , 'while' , 'variable' ,'wait'] %}
+                    {% if instrument in ['if' , 'while' , 'variable' ,'wait', 'repeat'] %}
                         {# form for builtin functions #}
                         <form role="form" method='POST' name="{{instrument}}" action="{{url_for('design.experiment_builder',instrument=instrument)}}" >
                             <div class="form-group">
@@ -185,7 +196,7 @@
                         </h5>
                         <div class="accordion-collapse collapse show" id="advanced">
                             <ul class="list-group">
-                                {% for instrument in ['if', 'while', 'variable', 'wait'] %}
+                                {% for instrument in ['if', 'while', 'variable', 'wait', 'repeat'] %}
                                     <form role="form" method='GET' name="device" action="{{url_for('design.experiment_builder',instrument=instrument)}}">
                                         <div class="form-group">
                                             <button class="list-group-item list-group-item-action" aria-current="true" type="submit">{{instrument}}</button>
@@ -302,7 +313,7 @@
                     {% for button in buttons %}
                         <li id="{{ button['id'] }}" style="list-style-type: none;">
                             <a href="{{ url_for('design.edit_action', uuid=button['uuid']) }}" type="button" class="btn btn-light" style="{{ button['style'] }}">{{ button['label'] }}</a>
-                            {% if not button["instrument"] in ["if","while"] %}
+                            {% if not button["instrument"] in ["if","while","repeat"] %}
                                 <a href="{{ url_for('design.duplicate_action', id=button['id']) }}" type="button" class="btn btn-light"><span class="bi bi-copy"></span></a>
                             {% endif %}
                             <a href="{{ url_for('design.delete_action', id=button['id']) }}" type="button" class="btn btn-light"><span class="bi bi-trash"></span></a>
@@ -403,7 +414,7 @@
     </div>
 </div>
 
-    {% if instrument and not instrument in ['if' , 'while' , 'variable' ,'wait'] and use_llm %}
+    {% if instrument and not instrument in ['if' , 'while' , 'variable' ,'wait', 'repeat'] and use_llm %}
         <script>
             const buttonIds = {{ ['generate'] | tojson }};
         </script>

{ivoryos-0.1.11 → ivoryos-0.1.13}/ivoryos/utils/db_models.py

@@ -1,8 +1,11 @@
+import ast
+import builtins
 import json
 import keyword
 import re
 import uuid
 from datetime import datetime
+from typing import Dict
 
 from flask_login import UserMixin
 from flask_sqlalchemy import SQLAlchemy
@@ -29,6 +32,16 @@ class User(db.Model, UserMixin):
         return self.username
 
 
+class Variable:
+    def __init__(self, name: str = None, data_type=str, value=None):
+        self.name = name
+        self.data_type = data_type
+        self.value = value
+
+    def __str__(self):
+        return self.name
+
+
 class Script(db.Model):
     __tablename__ = 'script'
     # id = db.Column(db.Integer, primary_key=True)
@@ -89,52 +102,70 @@ class Script(db.Model):
                     return action
 
     def _convert_type(self, args, arg_types):
+        if arg_types in ["list", "tuple", "set"]:
+            try:
+                args = ast.literal_eval(args)
+                return args
+            except Exception:
+                pass
         if type(arg_types) is not list:
             arg_types = [arg_types]
         for arg_type in arg_types:
             try:
+                # print(arg_type)
                 args = eval(f"{arg_type}('{args}')")
                 return
             except Exception:
+
                 pass
         raise TypeError(f"Input type error: cannot convert '{args}' to {arg_type}.")
 
     def update_by_uuid(self, uuid, args, output):
-        bool_dict = {"True": True, "False": False}
         action = self.find_by_uuid(uuid)
+        if not action:
+            return
+        arg_types = action['arg_types']
         if type(action['args']) is dict:
-            for arg in action['args']:
-                if not args[arg].startswith("#"):
-
-                    if args[arg] in bool_dict.keys():
-                        args[arg] = bool_dict[args[arg]]
-                    elif args[arg] == "None" or args[arg] == "":
-                        args[arg] = None
-                    else:
-                        if arg in action['arg_types']:
-                            arg_types = action['arg_types'][arg]
-                            self._convert_type(args[arg], arg_types)
-                        else:
-                            try:
-                                args[arg] = eval(args[arg])
-                            except Exception:
-                                pass
-        else:
-            args = list(args.values())[0]
-            if not args.startswith("#"):
-                if args in bool_dict.keys():
-                    args = bool_dict[args]
+            # pass
+            self.eval_list(args, arg_types)
 
-                else:
-                    if 'arg_types' in action:
-                        arg_types = action['arg_types']
-                        self._convert_type(args, arg_types)
+        else:
+            pass
+            # """handle"""
+            # args = list(args.values())[0]
+            # if not args.startswith("#"):
+            #     if args in bool_dict.keys():
+            #         args = bool_dict[args]
+            #
+            #     else:
+            #         if 'arg_types' in action:
+            #             arg_types = action['arg_types']
+            #             self._convert_type(args, arg_types)
 
-                    # print(args)
         action['args'] = args
-        # print(action)
         action['return'] = output
 
+    @staticmethod
+    def eval_list(args, arg_types):
+        for arg in args:
+            arg_type = arg_types[arg]
+            if arg_type in ["list", "tuple", "set"]:
+
+                if type(arg) is str and not args[arg].startswith("#"):
+                    # arg_types = arg_types[arg]
+                    # if arg_types in ["list", "tuple", "set"]:
+                    convert_type = getattr(builtins, arg_type)  # Handle unknown types s
+                    try:
+                        output = ast.literal_eval(args[arg])
+                        if type(output) not in [list, tuple, set]:
+                            output = [output]
+                        args[arg] = convert_type(output)
+                        # return args
+                    except ValueError:
+                        _list = ''.join(args[arg]).split(',')
+                        # convert_type = getattr(builtins, arg_types)  # Handle unknown types s
+                        args[arg] = convert_type([s.strip() for s in _list])
+
     @property
     def stypes(self):
         return list(self.script_dict.keys())
@@ -204,15 +235,48 @@ class Script(db.Model):
         self.currently_editing_order.append(str(current_len + 1))
         self.update_time_stamp()
 
-    def add_variable(self, statement, variable):
+    def add_variable(self, statement, variable, type):
+        convert_type = getattr(builtins, type)
+        statement = convert_type(statement)
         current_len = len(self.currently_editing_script)
         uid = uuid.uuid4().fields[-1]
         action_list = [{"id": current_len + 1, "instrument": 'variable', "action": variable,
-                        "args": 'None' if statement == '' else statement, "return": '', "uuid": uid, "arg_types": ''}]
+                        "args": {"statement": 'None' if statement == '' else statement}, "return": '', "uuid": uid,
+                        "arg_types": {"statement": type}}]
         self.currently_editing_script.extend(action_list)
         self.currently_editing_order.extend([str(current_len + i + 1) for i in range(len(action_list))])
         self.update_time_stamp()
 
+    def get_added_variables(self):
+        added_variables: Dict[str, str] = {action["action"]: action["arg_types"]["statement"] for action in
+                                           self.currently_editing_script if action["instrument"] == "variable"}
+
+        return added_variables
+
+    def get_output_variables(self):
+        output_variables: Dict[str, str] = {action["return"]: "function_output" for action in
+                                            self.currently_editing_script if action["return"]}
+
+        return output_variables
+
+    def get_variables(self):
+        output_variables: Dict[str, str] = self.get_output_variables()
+        added_variables = self.get_added_variables()
+        output_variables.update(added_variables)
+
+        return output_variables
+
+    def eval_variables(self, kwargs):
+        output_variables: Dict[str, str] = self.get_variables()
+        # print(output_variables)
+        for key, value in kwargs.items():
+            if type(value) is str and value in output_variables:
+                var_type = output_variables[value]
+                kwargs[key] = {value:var_type}
+
+        return kwargs
+
+
     def add_logic_action(self, logic_type: str, statement):
         current_len = len(self.currently_editing_script)
         uid = uuid.uuid4().fields[-1]
@@ -220,26 +284,33 @@ class Script(db.Model):
             "if":
                 [
                     {"id": current_len + 1, "instrument": 'if', "action": 'if',
-                     "args": 'True' if statement == '' else statement,
-                     "return": '', "uuid": uid, "arg_types": ''},
-                    {"id": current_len + 2, "instrument": 'if', "action": 'else', "args": '', "return": '',
+                     "args": {"statement": 'True' if statement == '' else statement},
+                     "return": '', "uuid": uid, "arg_types": {"statement": ''}},
+                    {"id": current_len + 2, "instrument": 'if', "action": 'else', "args": {}, "return": '',
                      "uuid": uid},
-                    {"id": current_len + 3, "instrument": 'if', "action": 'endif', "args": '', "return": '',
+                    {"id": current_len + 3, "instrument": 'if', "action": 'endif', "args": {}, "return": '',
                      "uuid": uid},
                 ],
             "while":
                 [
                     {"id": current_len + 1, "instrument": 'while', "action": 'while',
-                     "args": 'False' if statement == '' else statement, "return": '', "uuid": uid, "arg_types": ''},
-                    {"id": current_len + 2, "instrument": 'while', "action": 'endwhile', "args": '', "return": '',
+                     "args": {"statement": 'False' if statement == '' else statement}, "return": '', "uuid": uid, "arg_types": {"statement": ''}},
+                    {"id": current_len + 2, "instrument": 'while', "action": 'endwhile', "args": {}, "return": '',
                      "uuid": uid},
                 ],
 
             "wait":
                 [
                     {"id": current_len + 1, "instrument": 'wait', "action": "wait",
-                     "args": '0' if statement == '' else statement,
-                     "return": '', "uuid": uid, "arg_types": "float"},
+                     "args": {"statement": 1 if statement == '' else statement},
+                     "return": '', "uuid": uid, "arg_types": {"statement": "float"}},
+                ],
+            "repeat":
+                [
+                    {"id": current_len + 1, "instrument": 'repeat', "action": "repeat",
+                     "args": {"statement": 1 if statement == '' else statement}, "return": '', "uuid": uid, "arg_types": {"statement": "int"}},
+                    {"id": current_len + 2, "instrument": 'repeat', "action": 'endrepeat',
+                     "args": {}, "return": '', "uuid": uid},
                 ],
         }
         action_list = logic_dict[logic_type]
@@ -259,7 +330,8 @@ class Script(db.Model):
         self.update_time_stamp()
 
     def duplicate_action(self, id: int):
-        action_to_duplicate = next((action for action in self.currently_editing_script if action['id'] == int(id)), None)
+        action_to_duplicate = next((action for action in self.currently_editing_script if action['id'] == int(id)),
+                                   None)
         insert_id = action_to_duplicate.get("id")
         self.add_action(action_to_duplicate)
         # print(self.currently_editing_script)
@@ -366,11 +438,15 @@ class Script(db.Model):
         """
         Generate the function header.
         """
-        configure, _ = self.config(stype)
+        configure, config_type = self.config(stype)
+
+        configure = [param + f":{param_type}" if not param_type == "any" else "" for param, param_type in
+                     config_type.items()]
+
         function_header = f"\n\ndef {run_name}_{stype}("
 
         if stype == "script":
-            function_header += ",".join(configure)
+            function_header += ", ".join(configure)
 
         function_header += "):"
         function_header += self.indent(1) + f"global {run_name}_{stype}"
@@ -389,7 +465,6 @@ class Script(db.Model):
         return_str, return_list = self.config_return()
         if return_list and stype == "script":
             body += self.indent(indent_unit) + return_str
-
         return body
 
     def _process_action(self, indent_unit, action, index, stype):
@@ -397,18 +472,24 @@ class Script(db.Model):
         Process each action within the script dictionary.
         """
         instrument = action['instrument']
+        statement = action['args'].get('statement')
         args = self._process_args(action['args'])
+
         save_data = action['return']
         action_name = action['action']
         next_action = self._get_next_action(stype, index)
+        # print(args)
         if instrument == 'if':
-            return self._process_if(indent_unit, action_name, args, next_action)
+            return self._process_if(indent_unit, action_name, statement, next_action)
         elif instrument == 'while':
-            return self._process_while(indent_unit, action_name, args, next_action)
+            return self._process_while(indent_unit, action_name, statement, next_action)
         elif instrument == 'variable':
-            return self.indent(indent_unit) + f"{action_name} = {args}", indent_unit
+            return self.indent(indent_unit) + f"{action_name} = {statement}", indent_unit
         elif instrument == 'wait':
-            return f"{self.indent(indent_unit)}time.sleep({args})", indent_unit
+            return f"{self.indent(indent_unit)}time.sleep({statement})", indent_unit
+        elif instrument == 'repeat':
+            return self._process_repeat(indent_unit, action_name, statement, next_action)
+
         else:
             return self._process_instrument_action(indent_unit, instrument, action_name, args, save_data)
 
@@ -456,10 +537,25 @@ class Script(db.Model):
             indent_unit -= 1
         return exec_string, indent_unit
 
+    def _process_repeat(self, indent_unit, action, args, next_action):
+        """
+        Process 'while' and 'endwhile' actions.
+        """
+        exec_string = ""
+        if action == 'repeat':
+            exec_string += self.indent(indent_unit) + f"for _ in range({args}):"
+            indent_unit += 1
+            if next_action and next_action['instrument'] == 'repeat':
+                exec_string += self.indent(indent_unit) + "pass"
+        elif action == 'endrepeat':
+            indent_unit -= 1
+        return exec_string, indent_unit
+
     def _process_instrument_action(self, indent_unit, instrument, action, args, save_data):
         """
         Process actions related to instruments.
         """
+
         if isinstance(args, dict):
             args_str = self._process_dict_args(args)
             single_line = f"{instrument}.{action}(**{args_str})"
@@ -481,8 +577,16 @@ class Script(db.Model):
         for arg in args:
             if isinstance(args[arg], str) and args[arg].startswith("#"):
                 args_str = args_str.replace(f"'#{args[arg][1:]}'", args[arg][1:])
-            elif self._is_variable(arg):
-                args_str = args_str.replace(f"'{args[arg]}'", args[arg])
+            elif isinstance(args[arg], dict):
+                print(args[arg])
+                variables = self.get_variables()
+                value = next(iter(args[arg]))
+                if value not in variables:
+                    raise ValueError(f"Variable ({value}) is not defined.")
+                args_str = args_str.replace(f"{args[arg]}", next(iter(args[arg])))
+            # elif self._is_variable(arg):
+            #     print("is variable")
+            #     args_str = args_str.replace(f"'{args[arg]}'", args[arg])
         return args_str
 
     def _get_next_action(self, stype, index):

{ivoryos-0.1.11 → ivoryos-0.1.13}/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
@@ -6,16 +7,22 @@ from flask_wtf import FlaskForm
 from wtforms import StringField, FloatField, HiddenField, BooleanField, IntegerField
 import inspect
 
+from ivoryos.utils.db_models import Variable, Script
+
 
 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"]
+    # variable name: variable type
+    added_variables: dict[str, str] = script.get_added_variables()
+    output_variables: dict[str, str] = script.get_output_variables()
+    # [action for action in script.currently_editing_script if
+    #                                          action["instrument"] == "variable"
+    #                                          # or action["return"] # TODO find returns
+    #                                          ]
+    added_variables.update(output_variables)
+    for variable_name, variable_type in added_variables.items():
+        if variable_name == data:
+            return data, variable_type  # variable_type int float str or "function_output"
         # if added_variable["return"] == data:
         #     return data, None
     return None, None
@@ -36,9 +43,9 @@ 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
+                return Variable(variable, variable_type)
 
         return str(self.data) if self.data is not None else ""
 
@@ -52,9 +59,9 @@ 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
+                return Variable(variable, variable_type)
 
         if self.raw_data:
             return self.raw_data[0]
@@ -73,14 +80,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,9 +107,9 @@ 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
+                return Variable(variable, variable_type)
 
         if self.raw_data:
             return self.raw_data[0]
@@ -109,34 +117,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 +145,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,32 +154,36 @@ 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(variable, variable_type)
 
         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
+                return Variable(variable, variable_type)
 
         if self.raw_data:
             return str(self.raw_data[0])
@@ -269,17 +264,76 @@ def create_form_from_pseudo(pseudo: dict, autofill: bool, script=None, design=Tr
     return method_forms
 
 
-def create_builtin_form(logic_type):
+def create_form_from_action(action: dict, script=None, design=True):
+    '''
+    {'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}
+    '''
+    # print(action)
+
+    arg_types = action.get("arg_types", {})
+    args = action.get("args", {})
+    save_as = action.get("return")
+    action = action.get("action")
+
+    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, autofill, script):
     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 +342,58 @@ 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):
+    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):
+    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']}"
+    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
+
+                        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-0.1.11 → ivoryos-0.1.13}/ivoryos/utils/utils.py

@@ -6,6 +6,7 @@ import os
 import pickle
 import subprocess
 import sys
+from collections import Counter
 from typing import Optional, Dict, Tuple
 
 from flask import session
@@ -83,7 +84,6 @@ def available_pseudo_deck(path):
     """
     load pseudo deck (snapshot) from connection history
     """
-    import os
     return os.listdir(path)
 
 
@@ -131,34 +131,37 @@ 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
+# # moved to script
+# 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):
@@ -424,3 +427,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-0.1.13/ivoryos/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.13"

{ivoryos-0.1.11 → ivoryos-0.1.13/ivoryos.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ivoryos
-Version: 0.1.11
+Version: 0.1.13
 Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
 Home-page: https://gitlab.com/heingroup/ivoryos
 Author: Ivory Zhang

ivoryos-0.1.11/ivoryos/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.11"