add websocket warning

demo_code_plugin/plugin.py

@@ -1,6 +1,3 @@
-import eventlet
-eventlet.monkey_patch()
-
 from flask import render_template, Blueprint, current_app
 import os
 

demo_code_plugin/templates/example.html

@@ -79,6 +79,14 @@
             For authentication, user passwords are securely hashed using <code>bcrypt</code> before being stored.
             Use this demo to explore IvoryOS features!
         </p>
+        <div id="progress-warning" style="border: 1px solid #f5c2c7; background-color: #f8d7da; color: #842029; padding: 1rem; border-radius: 0.5rem; margin: 1rem 0; font-size: 0.95rem;">
+            ⚠️ <strong>Note:</strong> Real-time progress tracking via <code>SocketIO</code> is currently <strong>not working</strong> on Hugging Face Spaces.
+            <br>
+            This is due to limited WebSocket support in the Hugging Face hosting environment.
+            <br>
+            Workflow will still work, results can be tracked via the <strong>Data</strong> tab.
+            <br>
+        </div>
         <h2>Source Code</h2>
         <pre><code class="language-python">{{ code|e }}</code></pre>
     </div>

ivoryos/__init__.py

@@ -1,210 +0,0 @@
-import os
-import sys
-from typing import Union
-import eventlet
-eventlet.monkey_patch()
-
-from flask import Flask, redirect, url_for, g, Blueprint
-
-from ivoryos.config import Config, get_config
-from ivoryos.routes.auth.auth import auth, login_manager
-from ivoryos.routes.control.control import control
-from ivoryos.routes.database.database import database
-from ivoryos.routes.design.design import design, socketio
-from ivoryos.routes.main.main import main
-# from ivoryos.routes.monitor.monitor import monitor
-from ivoryos.utils import utils
-from ivoryos.utils.db_models import db, User
-from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils.script_runner import ScriptRunner
-from ivoryos.version import __version__ as ivoryos_version
-from importlib.metadata import entry_points
-
-global_config = GlobalConfig()
-from sqlalchemy import event
-from sqlalchemy.engine import Engine
-import sqlite3
-
-
-@event.listens_for(Engine, "connect")
-def enforce_sqlite_foreign_keys(dbapi_connection, connection_record):
-    if isinstance(dbapi_connection, sqlite3.Connection):
-        cursor = dbapi_connection.cursor()
-        cursor.execute("PRAGMA foreign_keys=ON")
-        cursor.close()
-
-
-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)
-app.register_blueprint(auth, url_prefix=url_prefix)
-app.register_blueprint(control, url_prefix=url_prefix)
-app.register_blueprint(design, url_prefix=url_prefix)
-app.register_blueprint(database, url_prefix=url_prefix)
-
-@login_manager.user_loader
-def load_user(user_id):
-    """
-    This function is called by Flask-Login on every request to get the
-    current user object from the user ID stored in the session.
-    """
-    # The correct implementation is to fetch the user from the database.
-    return db.session.get(User, user_id)
-
-
-def create_app(config_class=None):
-    """
-    create app, init database
-    """
-    app.config.from_object(config_class or 'config.get_config()')
-    os.makedirs(app.config["OUTPUT_FOLDER"], exist_ok=True)
-    # Initialize extensions
-    socketio.init_app(app, cookie=None, logger=True, engineio_logger=True)
-    login_manager.init_app(app)
-    login_manager.login_view = "auth.login"
-    db.init_app(app)
-
-    # Create database tables
-    with app.app_context():
-        db.create_all()
-
-    # Additional setup
-    utils.create_gui_dir(app.config['OUTPUT_FOLDER'])
-
-    # logger_list = app.config["LOGGERS"]
-    logger_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["LOGGERS_PATH"])
-    logger = utils.start_logger(socketio, 'gui_logger', logger_path)
-
-    @app.before_request
-    def before_request():
-        """
-        Called before
-
-        """
-        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
-
-    return app
-
-
-def run(module=None, host="0.0.0.0", port=None, debug=None, llm_server=None, model=None,
-        config: Config = None,
-        logger: Union[str, list] = None,
-        logger_output_name: str = None,
-        enable_design: bool = True,
-        blueprint_plugins: Union[list, Blueprint] = [],
-        exclude_names: list = [],
-        ):
-    """
-    Start ivoryOS app server.
-
-    :param module: module name, __name__ for current module
-    :param host: host address, defaults to 0.0.0.0
-    :param port: port, defaults to None, and will use 8000
-    :param debug: debug mode, defaults to None (True)
-    :param llm_server: llm server, defaults to None.
-    :param model: llm model, defaults to None. If None, app will run without text-to-code feature
-    :param config: config class, defaults to None
-    :param logger: logger name of list of logger names, defaults to None
-    :param logger_output_name: log file save name of logger, defaults to None, and will use "default.log"
-    :param enable_design: enable design canvas, database and workflow execution
-    :param blueprint_plugins: Union[list[Blueprint], Blueprint] custom Blueprint pages
-    :param exclude_names: list[str] module names to exclude from parsing
-    """
-    app = create_app(config_class=config or get_config())  # Create app instance using factory function
-
-    # plugins = load_installed_plugins(app, socketio)
-    plugins = []
-    if blueprint_plugins:
-        config_plugins = load_plugins(blueprint_plugins, app, socketio)
-        plugins.extend(config_plugins)
-
-    def inject_nav_config():
-        """Make NAV_CONFIG available globally to all templates."""
-        return dict(
-            enable_design=enable_design,
-            plugins=plugins,
-        )
-
-    app.context_processor(inject_nav_config)
-    port = port or int(os.environ.get("PORT", 8000))
-    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
-    logger_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["LOGGERS_PATH"])
-    dummy_deck_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["DUMMY_DECK"])
-
-    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=dummy_deck_path,
-                                                                 save=True,
-                                                                 exclude_names=exclude_names
-                                                                 )
-    else:
-        app.config["OFF_LINE"] = True
-    if model:
-        app.config["ENABLE_LLM"] = True
-        app.config["LLM_MODEL"] = model
-        app.config["LLM_SERVER"] = llm_server
-        utils.install_and_import('openai')
-        from ivoryos.utils.llm_agent import LlmAgent
-        global_config.agent = LlmAgent(host=llm_server, model=model,
-                                       output_path=app.config["OUTPUT_FOLDER"] if module is not None else None)
-    else:
-        app.config["ENABLE_LLM"] = False
-    if logger and type(logger) is str:
-        utils.start_logger(socketio, log_filename=logger_path, logger_name=logger)
-    elif type(logger) is list:
-        for log in logger:
-            utils.start_logger(socketio, log_filename=logger_path, logger_name=log)
-
-    # in case Python 3.12 or higher doesn't log URL
-    if sys.version_info >= (3, 12):
-        ip = utils.get_ip_address()
-        print(f"Server running at http://localhost:{port}")
-        if not ip == "127.0.0.1":
-            print(f"Server running at http://{ip}:{port}")
-    socketio.run(app, host=host, port=port, debug=debug, use_reloader=False, allow_unsafe_werkzeug=True)
-    # return app
-
-
-def load_installed_plugins(app, socketio):
-    """
-    Dynamically load installed plugins and attach Flask-SocketIO.
-    """
-    plugin_names = []
-    for entry_point in entry_points().get("ivoryos.plugins", []):
-        plugin = entry_point.load()
-
-        # If the plugin has an `init_socketio()` function, pass socketio
-        if hasattr(plugin, 'init_socketio'):
-            plugin.init_socketio(socketio)
-
-        plugin_names.append(entry_point.name)
-        app.register_blueprint(getattr(plugin, entry_point.name), url_prefix=f"{url_prefix}/{entry_point.name}")
-
-    return plugin_names
-
-
-def load_plugins(blueprints: Union[list, Blueprint], app, socketio):
-    """
-    Dynamically load installed plugins and attach Flask-SocketIO.
-    """
-    plugin_names = []
-    if not isinstance(blueprints, list):
-        blueprints = [blueprints]
-    for blueprint in blueprints:
-        # If the plugin has an `init_socketio()` function, pass socketio
-        if hasattr(blueprint, 'init_socketio'):
-            blueprint.init_socketio(socketio)
-        plugin_names.append(blueprint.name)
-        app.register_blueprint(blueprint, url_prefix=f"{url_prefix}/{blueprint.name}")
-    return plugin_names

ivoryos/config.py

@@ -1,66 +0,0 @@
-import os
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-
-class Config:
-    SECRET_KEY = os.getenv('SECRET_KEY', 'default_secret_key')
-    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', None)
-
-    OUTPUT_FOLDER = os.path.join(os.path.abspath(os.curdir), 'ivoryos_data')
-    CSV_FOLDER = os.path.join(OUTPUT_FOLDER, 'config_csv/')
-    SCRIPT_FOLDER = os.path.join(OUTPUT_FOLDER, 'scripts/')
-    DATA_FOLDER = os.path.join(OUTPUT_FOLDER, 'results/')
-    DUMMY_DECK = os.path.join(OUTPUT_FOLDER, 'pseudo_deck/')
-    LLM_OUTPUT = os.path.join(OUTPUT_FOLDER, 'llm_output/')
-    DECK_HISTORY = os.path.join(OUTPUT_FOLDER, 'deck_history.txt')
-    LOGGERS_PATH = "default.log"
-
-    SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.join(OUTPUT_FOLDER, 'ivoryos.db')}"
-    SQLALCHEMY_TRACK_MODIFICATIONS = False
-
-    ENABLE_LLM = True if OPENAI_API_KEY else False
-    OFF_LINE = True
-
-
-class DevelopmentConfig(Config):
-    DEBUG = True
-
-
-class ProductionConfig(Config):
-    DEBUG = False
-
-
-class TestingConfig(Config):
-    DEBUG = True
-    TESTING = True
-    SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'  # Use an in-memory SQLite database for tests
-    WTF_CSRF_ENABLED = False  # Disable CSRF for testing forms
-
-
-
-class DemoConfig(Config):
-    DEBUG = False
-    SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
-    OUTPUT_FOLDER = os.path.join(os.path.abspath(os.curdir), '/tmp/ivoryos_data')
-    CSV_FOLDER = os.path.join(OUTPUT_FOLDER, 'config_csv/')
-    SCRIPT_FOLDER = os.path.join(OUTPUT_FOLDER, 'scripts/')
-    DATA_FOLDER = os.path.join(OUTPUT_FOLDER, 'results/')
-    DUMMY_DECK = os.path.join(OUTPUT_FOLDER, 'pseudo_deck/')
-    LLM_OUTPUT = os.path.join(OUTPUT_FOLDER, 'llm_output/')
-    DECK_HISTORY = os.path.join(OUTPUT_FOLDER, 'deck_history.txt')
-    # session and cookies
-    SESSION_COOKIE_SECURE = True
-    SESSION_COOKIE_SAMESITE = "None"
-    SESSION_COOKIE_HTTPONLY = True
-
-def get_config(env='dev'):
-    if env == 'production':
-        return ProductionConfig()
-    elif env == 'testing':
-        return TestingConfig()
-    elif env == 'demo':
-        return DemoConfig()
-    return DevelopmentConfig()

ivoryos/routes/auth/auth.py

@@ -1,97 +0,0 @@
-from flask import Blueprint, redirect, url_for, flash, request, render_template, session
-from flask_login import login_required, login_user, logout_user, LoginManager
-import bcrypt
-
-from ivoryos.utils.db_models import Script, User, db
-from ivoryos.utils.utils import post_script_file
-login_manager = LoginManager()
-
-auth = Blueprint('auth', __name__, template_folder='templates/auth')
-
-
-@auth.route('/auth/login', methods=['GET', 'POST'])
-def login():
-    """
-    .. :quickref: User; login user
-
-    .. http:get:: /login
-
-    load user login form.
-
-    .. http:post:: /login
-
-    :form username: username
-    :form password: password
-    :status 302: and then redirects to homepage
-    :status 401: incorrect password, redirects to :http:get:`/ivoryos/login`
-    """
-    if request.method == 'POST':
-        username = request.form.get('username')
-        password = request.form.get('password')
-
-        # session.query(User, User.name).all()
-        user = db.session.query(User).filter(User.username == username).first()
-        input_password = password.encode('utf-8')
-        # if user and bcrypt.checkpw(input_password, user.hashPassword.encode('utf-8')):
-        if user and bcrypt.checkpw(input_password, user.hashPassword):
-            # password.encode("utf-8")
-            # user = User(username, password.encode("utf-8"))
-            login_user(user)
-            session['user'] = username
-            script_file = Script(author=username)
-            session["script"] = script_file.as_dict()
-            session['hidden_functions'], session['card_order'], session['prompt'] = {}, {}, {}
-            session['autofill'] = False
-            post_script_file(script_file)
-            return redirect(url_for('main.index'))
-        else:
-            flash("Incorrect username or password")
-            return redirect(url_for('auth.login')), 401
-    return render_template('login.html')
-
-
-@auth.route('/auth/signup', methods=['GET', 'POST'])
-def signup():
-    """
-    .. :quickref: User; signup for a new account
-
-    .. http:get:: /signup
-
-    load user sighup
-
-    .. http:post:: /signup
-
-    :form username: username
-    :form password: password
-    :status 302: and then redirects to :http:get:`/ivoryos/login`
-    :status 409: when user already exists, redirects to :http:get:`/ivoryos/signup`
-    """
-    if request.method == 'POST':
-        username = request.form.get('username')
-        password = request.form.get('password')
-
-        # Query the database to see if the user already exists.
-        existing_user = User.query.filter_by(username=username).first()
-
-        if existing_user:
-            flash("User already exists :(", "error")
-            return render_template('signup.html'), 409
-        hashed = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
-        user = User(username, hashed)
-        db.session.add(user)
-        db.session.commit()
-        return redirect(url_for('auth.login'))
-    return render_template('signup.html')
-
-
-@auth.route("/auth/logout")
-@login_required
-def logout():
-    """
-    .. :quickref: User; logout the user
-
-    logout the current user, clear session info, and redirect to the login page.
-    """
-    logout_user()
-    session.clear()
-    return redirect(url_for('auth.login'))

ivoryos/routes/auth/templates/auth/login.html

@@ -1,25 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Login{% endblock %}
-
-
-{% block body %}
-    <div class= "login">
-        <div class="bg-white rounded shadow-sm flex-fill">
-            <div class="p-4" style="align-items: center">
-                <h5>Log in</h5>
-                <form role="form" method='POST' name="login" action="{{ url_for('auth.login') }}">
-                    <div class="input-group mb-3">
-                        <label class="input-group-text" for="username">Username</label>
-                        <input class="form-control" type="text" id="username" name="username">
-                    </div>
-                    <div class="input-group mb-3">
-                        <label class="input-group-text" for="password">Password</label>
-                        <input class="form-control" type="password" id="password" name="password">
-                    </div>
-                    <button type="submit" class="btn btn-secondary" name="login" style="width: 100%;">login</button>
-                </form>
-                <p class="message">Not registered? <a href="{{ url_for('auth.signup') }}">Create a new account</a>
-            </div>
-        </div>
-    </div>
-{% endblock %}

ivoryos/routes/auth/templates/auth/signup.html

@@ -1,32 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Signup{% endblock %}
-
-
-{% block body %}
-<div class= "login">
-    <div class="bg-white rounded shadow-sm flex-fill">
-        <div class="p-4" style="align: center">
-            <h5>Create a new account</h5>
-            <form role="form" method='POST' name="signup" action="{{ url_for('auth.signup') }}">
-
-                <div class="input-group mb-3">
-                    <label class="input-group-text" for="username">Username</label>
-                    <input class="form-control" type="text" id="username" name="username" required>
-                </div>
-                <div class="input-group mb-3">
-                    <label class="input-group-text" for="password">Password</label>
-                    <input class="form-control" type="password" id="password" name="password" required>
-                </div>
-{#                <div class="input-group mb-3">#}
-{#                    <label class="input-group-text" for="confirm_password">Confirm Password</label>#}
-{#                    <input class="form-control" type="confirm_password" id="confirm_password" name="confirm_password">#}
-{#                </div>#}
-
-                <button type="submit" class="btn btn-secondary" name="login" style="width: 100%;">Sign up</button>
-            </form>
-            <p class="message" >Already registered? <a href="{{ url_for('auth.login') }}">Sign In</a></p>
-        </div>
-    </div>
-</div>
-
-{% endblock %}

ivoryos/routes/control/control.py

@@ -1,429 +0,0 @@
-import os
-
-from flask import Blueprint, redirect, url_for, flash, request, render_template, session, current_app, jsonify, \
-    send_file
-from flask_login import login_required
-
-from ivoryos.utils.client_proxy import export_to_python, create_function
-from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils import utils
-from ivoryos.utils.form import create_form_from_module, format_name
-from ivoryos.utils.task_runner import TaskRunner
-
-global_config = GlobalConfig()
-runner = TaskRunner()
-
-control = Blueprint('control', __name__, template_folder='templates/control')
-
-
-@control.route("/control/home/deck", strict_slashes=False)
-@login_required
-def deck_controllers():
-    """
-    .. :quickref: Direct Control; controls home interface
-
-    deck control home interface for listing all deck instruments
-
-    .. http:get:: /control/home/deck
-    """
-    deck_variables = global_config.deck_snapshot.keys()
-    deck_list = utils.import_history(os.path.join(current_app.config["OUTPUT_FOLDER"], 'deck_history.txt'))
-    return render_template('controllers_home.html', defined_variables=deck_variables, deck=True, history=deck_list)
-
-
-@control.route("/control/new/", strict_slashes=False)
-@control.route("/control/new/<instrument>", methods=['GET', 'POST'])
-@login_required
-def new_controller(instrument=None):
-    """
-    .. :quickref: Direct Control; connect to a new device
-
-    interface for connecting a new <instrument>
-
-    .. http:get:: /control/new/
-
-    :param instrument: instrument name
-    :type instrument: str
-
-    .. http:post:: /control/new/
-
-    :form device_name: module instance name (e.g. my_instance = MyClass())
-    :form kwargs: dynamic module initialization kwargs fields
-
-    """
-    device = None
-    args = None
-    if instrument:
-
-        device = find_instrument_by_name(instrument)
-        args = utils.inspect.signature(device.__init__)
-
-        if request.method == 'POST':
-            device_name = request.form.get("device_name", "")
-            if device_name and device_name in globals():
-                flash("Device name is defined. Try another name, or leave it as blank to auto-configure")
-                return render_template('controllers_new.html', instrument=instrument,
-                                       api_variables=global_config.api_variables,
-                                       device=device, args=args, defined_variables=global_config.defined_variables)
-            if device_name == "":
-                device_name = device.__name__.lower() + "_"
-                num = 1
-                while device_name + str(num) in global_config.defined_variables:
-                    num += 1
-                device_name = device_name + str(num)
-            kwargs = request.form.to_dict()
-            kwargs.pop("device_name")
-            for i in kwargs:
-                if kwargs[i] in global_config.defined_variables:
-                    kwargs[i] = global_config.defined_variables[kwargs[i]]
-            try:
-                utils.convert_config_type(kwargs, device.__init__.__annotations__, is_class=True)
-            except Exception as e:
-                flash(e)
-            try:
-                global_config.defined_variables[device_name] = device(**kwargs)
-                # global_config.defined_variables.add(device_name)
-                return redirect(url_for('control.controllers_home'))
-            except Exception as e:
-                flash(e)
-    return render_template('controllers_new.html', instrument=instrument, api_variables=global_config.api_variables,
-                           device=device, args=args, defined_variables=global_config.defined_variables)
-
-
-@control.route("/control/home/temp", strict_slashes=False)
-@login_required
-def controllers_home():
-    """
-    .. :quickref: Direct Control; temp control home interface
-
-    temporarily connected devices home interface for listing all instruments
-
-    .. http:get:: /control/home/temp
-
-    """
-    # defined_variables = parse_deck(deck)
-    defined_variables = global_config.defined_variables.keys()
-    return render_template('controllers_home.html', defined_variables=defined_variables)
-
-
-@control.route("/control/<instrument>/methods", methods=['GET', 'POST'])
-@login_required
-def controllers(instrument: str):
-    """
-    .. :quickref: Direct Control; control interface
-
-    control interface for selected <instrument>
-
-    .. http:get:: /control/<instrument>/methods
-
-    :param instrument: instrument name
-    :type instrument: str
-
-    .. http:post:: /control/<instrument>/methods
-
-    :form hidden_name: function name (hidden field)
-    :form kwargs: dynamic kwargs field
-
-    """
-    inst_object = find_instrument_by_name(instrument)
-    _forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
-    functions = list(_forms.keys())
-
-    order = get_session_by_instrument('card_order', instrument)
-    hidden_functions = get_session_by_instrument('hide_function', instrument)
-
-    for function in functions:
-        if function not in hidden_functions and function not in order:
-            order.append(function)
-    post_session_by_instrument('card_order', instrument, order)
-    forms = {name: _forms[name] for name in order if name in _forms}
-    if request.method == 'POST':
-        all_kwargs = request.form.copy()
-        method_name = all_kwargs.pop("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'}
-        function_executable = getattr(inst_object, method_name)
-        if form and form.validate_on_submit():
-            try:
-                kwargs.pop("hidden_name")
-                output = runner.run_single_step(instrument, method_name, kwargs, wait=True,
-                                                current_app=current_app._get_current_object())
-                # output = function_executable(**kwargs)
-                flash(f"\nRun Success! Output value: {output}.")
-            except Exception as e:
-                flash(e.__str__())
-        else:
-            flash(form.errors)
-    return render_template('controllers.html', instrument=instrument, forms=forms, format_name=format_name)
-
-@control.route("/control/download", strict_slashes=False)
-@login_required
-def download_proxy():
-    """
-    .. :quickref: Direct Control; download proxy interface
-
-    download proxy interface
-
-    .. http:get:: /control/download
-    """
-    snapshot = global_config.deck_snapshot.copy()
-    class_definitions = {}
-    # Iterate through each instrument in the snapshot
-    for instrument_key, instrument_data in snapshot.items():
-        # Iterate through each function associated with the current instrument
-        for function_key, function_data in instrument_data.items():
-            # Convert the function signature to a string representation
-            function_data['signature'] = str(function_data['signature'])
-        class_name = instrument_key.split('.')[-1]  # Extracting the class name from the path
-        class_definitions[class_name.capitalize()] = create_function(request.url_root, class_name, instrument_data)
-    # Export the generated class definitions to a .py script
-    export_to_python(class_definitions, current_app.config["OUTPUT_FOLDER"])
-    filepath = os.path.join(current_app.config["OUTPUT_FOLDER"], "generated_proxy.py")
-    return send_file(os.path.abspath(filepath), as_attachment=True)
-
-@control.route("/api/control/", strict_slashes=False, methods=['GET'])
-@control.route("/api/control/<instrument>", methods=['POST'])
-def backend_control(instrument: str=None):
-    """
-    .. :quickref: Backend Control; backend control
-
-    backend control through http requests
-
-    .. http:get:: /api/control/
-
-    :param instrument: instrument name
-    :type instrument: str
-
-    .. http:post:: /api/control/
-
-    """
-    if instrument:
-        inst_object = find_instrument_by_name(instrument)
-        forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
-
-    if request.method == 'POST':
-        method_name = request.form.get("hidden_name", None)
-        form = forms.get(method_name, None)
-        if form:
-            kwargs = {field.name: field.data for field in form if field.name not in ['csrf_token', 'hidden_name']}
-            wait = request.form.get("hidden_wait", "true") == "true"
-            output = runner.run_single_step(component=instrument, method=method_name, kwargs=kwargs, wait=wait,
-                                            current_app=current_app._get_current_object())
-            return jsonify(output), 200
-
-    snapshot = global_config.deck_snapshot.copy()
-    # Iterate through each instrument in the snapshot
-    for instrument_key, instrument_data in snapshot.items():
-        # Iterate through each function associated with the current instrument
-        for function_key, function_data in instrument_data.items():
-            # Convert the function signature to a string representation
-            function_data['signature'] = str(function_data['signature'])
-    return jsonify(snapshot), 200
-
-# @control.route("/api/control", strict_slashes=False, methods=['GET'])
-# def backend_client():
-#     """
-#     .. :quickref: Backend Control; get snapshot
-#
-#     backend control through http requests
-#
-#     .. http:get:: /api/control/summary
-#     """
-#     # Create a snapshot of the current deck configuration
-#     snapshot = global_config.deck_snapshot.copy()
-#
-#     # Iterate through each instrument in the snapshot
-#     for instrument_key, instrument_data in snapshot.items():
-#         # Iterate through each function associated with the current instrument
-#         for function_key, function_data in instrument_data.items():
-#             # Convert the function signature to a string representation
-#             function_data['signature'] = str(function_data['signature'])
-#     return jsonify(snapshot), 200
-
-
-@control.route("/control/import/module", methods=['POST'])
-def import_api():
-    """
-    .. :quickref: Advanced Features; Manually import API module(s)
-
-    importing other Python modules
-
-    .. http:post:: /control/import/module
-
-    :form filepath: API (Python class) module filepath
-
-    import the module and redirect to :http:get:`/ivoryos/control/new/`
-
-    """
-    filepath = request.form.get('filepath')
-    # filepath.replace('\\', '/')
-    name = os.path.split(filepath)[-1].split('.')[0]
-    try:
-        spec = utils.importlib.util.spec_from_file_location(name, filepath)
-        module = utils.importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-        classes = utils.inspect.getmembers(module, utils.inspect.isclass)
-        if len(classes) == 0:
-            flash("Invalid import: no class found in the path")
-            return redirect(url_for("control.controllers_home"))
-        for i in classes:
-            globals()[i[0]] = i[1]
-            global_config.api_variables.add(i[0])
-    # should handle path error and file type error
-    except Exception as e:
-        flash(e.__str__())
-    return redirect(url_for("control.new_controller"))
-
-
-# @control.route("/disconnect", methods=["GET"])
-# @control.route("/disconnect/<device_name>", methods=["GET"])
-# def disconnect(device_name=None):
-#     """TODO handle disconnect device"""
-#     if device_name:
-#         try:
-#             exec(device_name + ".disconnect()")
-#         except Exception:
-#             pass
-#         global_config.defined_variables.remove(device_name)
-#         globals().pop(device_name)
-#         return redirect(url_for('control.controllers_home'))
-#
-#     deck_variables = ["deck." + var for var in set(dir(deck))
-#                       if not (var.startswith("_") or var[0].isupper() or var.startswith("repackage"))
-#                       and not type(eval("deck." + var)).__module__ == 'builtins']
-#     for i in deck_variables:
-#         try:
-#             exec(i + ".disconnect()")
-#         except Exception:
-#             pass
-#     globals()["deck"] = None
-#     return redirect(url_for('control.deck_controllers'))
-
-
-@control.route("/control/import/deck", methods=['POST'])
-def import_deck():
-    """
-    .. :quickref: Advanced Features; Manually import a deck
-
-    .. http:post:: /control/import_deck
-
-    :form filepath: deck module filepath
-
-    import the module and redirect to the previous page
-
-    """
-    script = utils.get_script_file()
-    filepath = request.form.get('filepath')
-    session['dismiss'] = request.form.get('dismiss')
-    update = request.form.get('update')
-    back = request.referrer
-    if session['dismiss']:
-        return redirect(back)
-    name = os.path.split(filepath)[-1].split('.')[0]
-    try:
-        module = utils.import_module_by_filepath(filepath=filepath, name=name)
-        utils.save_to_history(filepath, current_app.config["DECK_HISTORY"])
-        module_sigs = utils.create_deck_snapshot(module, save=update, output_path=current_app.config["DUMMY_DECK"])
-        if not len(module_sigs) > 0:
-            flash("Invalid hardware deck, connect instruments in deck script", "error")
-            return redirect(url_for("control.deck_controllers"))
-        global_config.deck = module
-        global_config.deck_snapshot = module_sigs
-
-        if script.deck is None:
-            script.deck = module.__name__
-    # file path error exception
-    except Exception as e:
-        flash(e.__str__())
-    return redirect(back)
-
-
-@control.route('/control/<instrument>/save-order', methods=['POST'])
-def save_order(instrument: str):
-    """
-    .. :quickref: Control Customization; Save functions' order
-
-    .. http:post:: /control/save-order
-
-    save function drag and drop order for the given <instrument>
-
-    """
-    # Save the new order for the specified group to session
-    data = request.json
-    post_session_by_instrument('card_order', instrument, data['order'])
-    return '', 204
-
-
-@control.route('/control/<instrument>/<function>/hide')
-def hide_function(instrument, function):
-    """
-    .. :quickref: Control Customization; Hide function
-
-    .. http:get:: //control/<instrument>/<function>/hide
-
-    Hide the given <instrument> and <function>
-
-    """
-    back = request.referrer
-    functions = get_session_by_instrument("hidden_functions", instrument)
-    order = get_session_by_instrument("card_order", instrument)
-    if function not in functions:
-        functions.append(function)
-        order.remove(function)
-    post_session_by_instrument('hidden_functions', instrument, functions)
-    post_session_by_instrument('card_order', instrument, order)
-    return redirect(back)
-
-
-@control.route('/control/<instrument>/<function>/unhide')
-def remove_hidden(instrument: str, function: str):
-    """
-    .. :quickref: Control Customization; Remove a hidden function
-
-    .. http:get:: /control/<instrument>/<function>/unhide
-
-    Un-hide the given <instrument> and <function>
-
-    """
-    back = request.referrer
-    functions = get_session_by_instrument("hidden_functions", instrument)
-    order = get_session_by_instrument("card_order", instrument)
-    if function in functions:
-        functions.remove(function)
-        order.append(function)
-    post_session_by_instrument('hidden_functions', instrument, functions)
-    post_session_by_instrument('card_order', instrument, order)
-    return redirect(back)
-
-
-def get_session_by_instrument(session_name, instrument):
-    """get data from session by instrument"""
-    session_object = session.get(session_name, {})
-    functions = session_object.get(instrument, [])
-    return functions
-
-
-def post_session_by_instrument(session_name, instrument, data):
-    """
-    save new data to session by instrument
-    :param session_name: "card_order" or "hidden_functions"
-    :param instrument: function name of class object
-    :param data: order list or hidden function list
-    """
-    session_object = session.get(session_name, {})
-    session_object[instrument] = data
-    session[session_name] = session_object
-
-
-def find_instrument_by_name(name: str):
-    """
-    find instrument class object by instance name
-    """
-    if name.startswith("deck"):
-        name = name.replace("deck.", "")
-        return getattr(global_config.deck, name)
-    elif name in global_config.defined_variables:
-        return global_config.defined_variables[name]
-    elif name in globals():
-        return globals()[name]

ivoryos/routes/control/templates/control/controllers.html

@@ -1,78 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Controller for {{instrument}}{% endblock %}
-{% block body %}
-    <div id="overlay" class="overlay">
-        <div>
-            <h3 id="overlay-text"></h3>
-            <div class="spinner-border" role="status"></div>
-        </div>
-    </div>
-    <h1>{{instrument}} controller</h1>
-    {% set hidden = session.get('hidden_functions', {}) %}
-    <div class="grid-container" id="sortable-grid">
-        {% for function, form in forms.items() %}
-
-            {% set hidden_instrument = hidden.get(instrument, []) %}
-            {% if function not in hidden_instrument %}
-                <div class="card" id="{{function}}">
-                    <div class="bg-white rounded shadow-sm flex-fill">
-                        <i class="bi bi-info-circle ms-2" data-bs-toggle="tooltip" data-bs-placement="top" title='{{ form.hidden_name.description or "Docstring is not available" }}' ></i>
-                        <a style="float: right" aria-label="Close" href="{{ url_for('control.hide_function', instrument=instrument, function=function) }}"><i class="bi bi-eye-slash-fill"></i></a>
-                        <div class="form-control" style="border: none">
-                            <form role="form" method='POST' name="{{function}}" id="{{function}}">
-                                <div class="form-group">
-                                    {{ form.hidden_tag() }}
-                                    {% for field in form %}
-                                        {% if field.type not in ['CSRFTokenField', 'HiddenField'] %}
-                                            <div class="input-group mb-3">
-                                                <label class="input-group-text">{{ field.label.text }}</label>
-                                                {% if field.type == "SubmitField" %}
-                                                    {{ field(class="btn btn-dark") }}
-                                                {% elif field.type == "BooleanField" %}
-                                                    {{ field(class="form-check-input") }}
-                                                {% else %}
-                                                    {{ field(class="form-control") }}
-                                                {% endif %}
-                                            </div>
-                                        {% endif %}
-                                    {% endfor %}
-                                </div>
-                                <div class="input-group mb-3">
-                                    <button type="submit" name="{{ function }}" id="{{ function }}" class="form-control" style="background-color: #a5cece;">{{format_name(function)}} </button>
-
-                                </div>
-
-                            </form>
-                        </div>
-                    </div>
-                </div>
-            {% endif %}
-        {% endfor %}
-    </div>
-    <div class="accordion accordion-flush" id="accordionActions" >
-        <div class="accordion-item">
-            <h4 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#hidden">
-                    Hidden functions
-                </button>
-            </h4>
-        </div>
-        <div id="hidden" class="accordion-collapse collapse" data-bs-parent="#accordionActions">
-            <div class="accordion-body">
-                {% set hidden_instrument = hidden.get(instrument, []) %}
-                {% for function in hidden_instrument %}
-                    <div>
-                        {{ function }} <a href="{{ url_for('control.remove_hidden', instrument=instrument, function=function) }}"><i class="bi bi-eye-fill"></i></a>
-                    </div>
-                {% endfor %}
-            </div>
-        </div>
-    </div>
-
-    <script>
-        const saveOrderUrl = `{{ url_for('control.save_order', instrument=instrument) }}`;
-        const buttonIds = {{ session['card_order'][instrument] | tojson }};
-    </script>
-    <script src="{{ url_for('static', filename='js/sortable_card.js') }}"></script>
-    <script src="{{ url_for('static', filename='js/overlay.js') }}"></script>
-{% endblock %}

ivoryos/routes/control/templates/control/controllers_home.html

@@ -1,55 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Devices{% endblock %}
-{% block body %}
-    <div class="row">
-    {% if defined_variables %}
-        {% for instrument in defined_variables %}
-            <div class="col-xl-3 col-lg-4 col-md-6 mb-4 ">
-                <div class="bg-white rounded shadow-sm position-relative">
-                    {% if deck %}
-{#                        <a href="{{ url_for('control.disconnect', instrument=instrument) }}" class="stretched-link controller-card" style="float: right;color: red; position: relative;">Disconnect <i class="bi bi-x-square"></i></a>#}
-                        <div class="p-4 controller-card">
-                            <h5 class=""><a href="{{ url_for('control.controllers', instrument=instrument) }}" class="text-dark stretched-link">{{instrument.split(".")[1]}}</a></h5>
-                        </div>
-                    {% else %}
-                        <div class="p-4 controller-card">
-                            <h5 class=""><a href="{{ url_for('control.controllers', instrument=instrument) }}" class="text-dark stretched-link">{{instrument}}</a></h5>
-                        </div>
-                    {% endif %}
-                </div>
-            </div>
-        {% endfor %}
-        <div class="d-flex mb-3">
-            <a href="{{ url_for('control.download_proxy', filetype='proxy') }}" class="btn btn-outline-primary">
-                <i class="bi bi-download"></i> Download remote control script
-            </a>
-        </div>
-        {% if not deck %}
-            <div class="col-xl-3 col-lg-4 col-md-6 mb-4 ">
-                <div class="bg-white rounded shadow-sm position-relative">
-                    <div class="p-4 controller-card" >
-                        {% if deck %}
-{#                            todo disconnect for imported deck #}
-{#                            <h5> <a href="{{ url_for("disconnect") }}" class="stretched-link" style="color: orangered">Disconnect deck</a></h5>#}
-                        {% else %}
-                            <h5><a href="{{ url_for('control.new_controller') }}" style="color: orange" class="stretched-link">New connection</a></h5>
-                        {% endif %}
-                    </div>
-                </div>
-            </div>
-        {% endif %}
-    {% else %}
-        <div class="col-xl-3 col-lg-4 col-md-6 mb-4 ">
-            <div class="bg-white rounded shadow-sm position-relative">
-                <div class="p-4 controller-card" >
-                    {% if deck %}
-                        <h5><a data-bs-toggle="modal" href="#importModal" class="stretched-link"><i class="bi bi-folder-plus"></i> Import deck </a></h5>
-                    {% else %}
-                        <h5><a href="{{ url_for('control.new_controller') }}" style="color: orange" class="stretched-link">New connection</a></h5>
-                    {% endif %}
-                </div>
-            </div>
-        </div>
-    {% endif %}
-    </div>
-{% endblock %}

ivoryos/routes/control/templates/control/controllers_new.html

@@ -1,89 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | New devices{% endblock %}
-
-{% block body %}
-    <div class="row">
-        <div class="col-xl-4 col-lg-4 col-md-6 mb-4 ">
-            <h5>Available Python API</h5>
-            <hr>
-            {% for instrument in api_variables %}
-                <div class="bg-white rounded shadow-sm position-relative">
-                    <h5 class="p-3 controller-card">
-                        <a href="{{ url_for('control.new_controller', instrument=instrument) }}" class="text-dark stretched-link">{{instrument}}</a>
-                    </h5>
-                </div>
-            {% endfor %}
-            <div class="bg-white rounded shadow-sm position-relative">
-                <h5 class="p-3 controller-card">
-                    <a data-bs-toggle="modal" href="#importAPI" class="stretched-link"><i class="bi bi-folder-plus"></i> Import API</a>
-                </h5>
-            </div>
-        </div>
-        <div class="col-xl-5 col-lg-5 col-md-6 mb-4 ">
-            {% if device %}
-                <h5>Connecting</h5><hr>
-                <form role="form" method='POST' name="init" action="{{ url_for('control.new_controller', instrument=instrument) }}">
-                    <div class="form-group">
-                        <div class="input-group mb-3">
-                            <span class="input-group-text" >Name this device</span>
-                            <input class="form-control" type="text" id="device_name" name="device_name" aria-labelledby="nameHelpBlock" placeholder="e.g. {{device.__name__}}_1" >
-                            <div id="nameHelpBlock" class="form-text">
-                                Name your instrument, avoid names that are defined on the right
-                            </div>
-                        </div>
-                        {% for arg in device.__init__.__annotations__ %}
-                            {% if not arg == "return" %}
-                                <div class="input-group mb-3">
-                                    <span class="input-group-text" >{{arg}}</span>
-                                    <input class="form-control"  type="text" id="{{arg}}" name="{{arg}}"
-                                           placeholder="{{device.__init__.__annotations__[arg].__name__}}"
-                                           value="{{args.parameters[arg].default if not args.parameters[arg].default.__name__ == '_empty' else ''}}">
-                                    {% if device.__init__.__annotations__[arg].__module__ is not in ["builtins", "typing"] %}
-                                        <a role="button" href="{{ url_for('control.new_controller', instrument=device.__init__.__annotations__[arg].__name__) }}" class="btn btn-secondary">initialize {{device.__init__.__annotations__[arg].__name__}} first</a>
-                                    {% endif %}
-                                </div>
-                            {% endif %}
-                        {% endfor %}
-                        <button type="submit" class="btn btn-dark">Connect</button>
-                    </div>
-                </form>
-            {% endif %}
-        </div>
-        <div class="col-xl-3 col-lg-3 col-md-6 mb-4">
-            <h5>Defined Instruments</h5><hr>
-            {% if defined_variables %}
-                <ul class="list-group">
-                    {% for instrument in defined_variables %}
-                        <li class="list-group-item">{{instrument}}</li>
-                    {% endfor %}
-                </ul>
-            {% endif %}
-        </div>
-    </div>
-
-
-    <div class="modal fade" id="importAPI" tabindex="-1" aria-labelledby="importModal" aria-hidden="true" >
-        <div class="modal-dialog">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h1 class="modal-title fs-5" id="importModal">Import API by file path</h1>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-                </div>
-                <form method="POST" action="{{ url_for('control.import_api') }}" enctype="multipart/form-data">
-                    <div class="modal-body">
-                        <h5>input manually</h5>
-                        <div class="input-group mb-3">
-                            <label class="input-group-text" for="filepath">File Path:</label>
-                            <input type="text" class="form-control" name="filepath" id="filepath">
-                        </div>
-                        <div class="modal-footer">
-                            <button type="button" class="btn btn-secondary" data-bs-dismiss="modal"> Close </button>
-                            <button type="submit"  class="btn btn-primary"> Save </button>
-                        </div>
-                    </div>
-                </form>
-            </div>
-        </div>
-    </div>
-
-{% endblock %}

ivoryos/routes/database/database.py

@@ -1,306 +0,0 @@
-from flask import Blueprint, redirect, url_for, flash, request, render_template, session, current_app, jsonify
-from flask_login import login_required
-
-from ivoryos.utils.db_models import Script, db, WorkflowRun, WorkflowStep
-from ivoryos.utils.utils import get_script_file, post_script_file
-
-database = Blueprint('database', __name__, template_folder='templates/database')
-
-
-
-@database.route("/database/scripts/edit/<script_name>")
-@login_required
-def edit_workflow(script_name:str):
-    """
-    .. :quickref: Database; load workflow script to canvas
-
-    load the selected workflow to the design canvas
-
-    .. http:get:: /database/scripts/edit/<script_name>
-
-    :param script_name: script name
-    :type script_name: str
-    :status 302: redirect to :http:get:`/ivoryos/design/script/`
-    """
-    row = Script.query.get(script_name)
-    script = Script(**row.as_dict())
-    post_script_file(script)
-    pseudo_name = session.get("pseudo_deck", "")
-    off_line = current_app.config["OFF_LINE"]
-    if off_line and pseudo_name and not script.deck == pseudo_name:
-        flash(f"Choose the deck with name {script.deck}")
-    if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-        return jsonify({
-            "script": script.as_dict(),
-            "python_script": script.compile(),
-        })
-    return redirect(url_for('design.experiment_builder'))
-
-
-@database.route("/database/scripts/delete/<script_name>")
-@login_required
-def delete_workflow(script_name: str):
-    """
-    .. :quickref: Database; delete workflow
-
-    delete workflow from database
-
-    .. http:get:: /database/scripts/delete/<script_name>
-
-    :param script_name: workflow name
-    :type script_name: str
-    :status 302: redirect to :http:get:`/ivoryos/database/scripts/`
-
-    """
-    Script.query.filter(Script.name == script_name).delete()
-    db.session.commit()
-    return redirect(url_for('database.load_from_database'))
-
-
-@database.route("/database/scripts/save")
-@login_required
-def publish():
-    """
-    .. :quickref: Database; save workflow to database
-
-    save workflow to database
-
-    .. http:get:: /database/scripts/save
-
-    :status 302: redirect to :http:get:`/ivoryos/experiment/build/`
-    """
-    script = get_script_file()
-    if not script.name or not script.deck:
-        flash("Deck cannot be empty, try to re-submit deck configuration on the left panel")
-    row = Script.query.get(script.name)
-    if row and row.status == "finalized":
-        flash("This is a protected script, use save as to rename.")
-    elif row and not session['user'] == row.author:
-        flash("You are not the author, use save as to rename.")
-    else:
-        db.session.merge(script)
-        db.session.commit()
-        flash("Saved!")
-    return redirect(url_for('design.experiment_builder'))
-
-
-@database.route("/database/scripts/finalize")
-@login_required
-def finalize():
-    """
-    .. :quickref: Database; finalize the workflow
-
-    [protected workflow] prevent saving edited workflow to the same workflow name
-
-    .. http:get:: /finalize
-
-    :status 302: redirect to :http:get:`/ivoryos/experiment/build/`
-
-    """
-    script = get_script_file()
-    script.finalize()
-    if script.name:
-        db.session.merge(script)
-        db.session.commit()
-    post_script_file(script)
-    return redirect(url_for('design.experiment_builder'))
-
-
-@database.route("/database/scripts/", strict_slashes=False)
-@database.route("/database/scripts/<deck_name>")
-@login_required
-def load_from_database(deck_name=None):
-    """
-    .. :quickref: Database; database page
-
-    backend control through http requests
-
-    .. http:get:: /database/scripts/<deck_name>
-
-    :param deck_name: filter for deck name
-    :type deck_name: str
-
-    """
-    session.pop('edit_action', None)  # reset cache
-    query = Script.query
-    search_term = request.args.get("keyword", None)
-    if search_term:
-        query = query.filter(Script.name.like(f'%{search_term}%'))
-    if deck_name is None:
-        temp = Script.query.with_entities(Script.deck).distinct().all()
-        deck_list = [i[0] for i in temp]
-    else:
-        query = query.filter(Script.deck == deck_name)
-        deck_list = ["ALL"]
-    page = request.args.get('page', default=1, type=int)
-    per_page = 10
-
-    scripts = query.paginate(page=page, per_page=per_page, error_out=False)
-    if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-        scripts = query.all()
-        script_names = [script.name for script in scripts]
-        return jsonify({
-            "workflows": script_names,
-        })
-    else:
-        # return HTML
-        return render_template("scripts_database.html", scripts=scripts, deck_list=deck_list, deck_name=deck_name)
-
-
-@database.route("/database/scripts/rename", methods=['POST'])
-@login_required
-def edit_run_name():
-    """
-    .. :quickref: Database; edit workflow name
-
-    edit the name of the current workflow, won't save to the database
-
-    .. http:post:: database/scripts/rename
-
-    : form run_name: new workflow name
-    :status 302: redirect to :http:get:`/ivoryos/experiment/build/`
-
-    """
-    if request.method == "POST":
-        run_name = request.form.get("run_name")
-        exist_script = Script.query.get(run_name)
-        if not exist_script:
-            script = get_script_file()
-            script.save_as(run_name)
-            post_script_file(script)
-        else:
-            flash("Script name is already exist in database")
-        return redirect(url_for("design.experiment_builder"))
-
-
-@database.route("/database/scripts/save_as", methods=['POST'])
-@login_required
-def save_as():
-    """
-    .. :quickref: Database; save the run name as
-
-    save the current workflow script as
-
-    .. http:post:: /database/scripts/save_as
-
-    : form run_name: new workflow name
-    :status 302: redirect to :http:get:`/ivoryos/experiment/build/`
-
-    """
-    if request.method == "POST":
-        run_name = request.form.get("run_name")
-        register_workflow = request.form.get("register_workflow")
-        exist_script = Script.query.get(run_name)
-        if not exist_script:
-            script = get_script_file()
-            script.save_as(run_name)
-            script.registered = register_workflow == "on"
-            script.author = session.get('user')
-            post_script_file(script)
-            publish()
-        else:
-            flash("Script name is already exist in database")
-        return redirect(url_for("design.experiment_builder"))
-
-
-# -----------------------------------------------------------
-# ------------------  Workflow logs   -----------------------
-# -----------------------------------------------------------
-@database.route('/database/workflows/')
-def list_workflows():
-    """
-    .. :quickref: Database; list all workflow logs
-
-    list all workflow logs
-
-    .. http:get:: /database/workflows/
-
-    """
-    query = WorkflowRun.query.order_by(WorkflowRun.id.desc())
-    search_term = request.args.get("keyword", None)
-    if search_term:
-        query = query.filter(WorkflowRun.name.like(f'%{search_term}%'))
-    page = request.args.get('page', default=1, type=int)
-    per_page = 10
-
-    workflows = query.paginate(page=page, per_page=per_page, error_out=False)
-    if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-        workflows = query.all()
-        workflow_data = {w.id:{"workflow_name":w.name, "start_time":w.start_time} for w in workflows}
-        return jsonify({
-            "workflow_data": workflow_data,
-        })
-    else:
-        return render_template('workflow_database.html', workflows=workflows)
-
-
-@database.route("/database/workflows/<int:workflow_id>")
-def get_workflow_steps(workflow_id:int):
-    """
-    .. :quickref: Database; list all workflow logs
-
-    list all workflow logs
-
-    .. http:get:: /database/workflows/<int:workflow_id>
-
-    """
-    workflow = db.session.get(WorkflowRun, workflow_id)
-    steps = WorkflowStep.query.filter_by(workflow_id=workflow_id).order_by(WorkflowStep.start_time).all()
-
-    # Use full objects for template rendering
-    grouped = {
-        "prep": [],
-        "script": {},
-        "cleanup": [],
-    }
-
-    # Use dicts for JSON response
-    grouped_json = {
-        "prep": [],
-        "script": {},
-        "cleanup": [],
-    }
-
-    for step in steps:
-        step_dict = step.as_dict()
-
-        if step.phase == "prep":
-            grouped["prep"].append(step)
-            grouped_json["prep"].append(step_dict)
-
-        elif step.phase == "script":
-            grouped["script"].setdefault(step.repeat_index, []).append(step)
-            grouped_json["script"].setdefault(step.repeat_index, []).append(step_dict)
-
-        elif step.phase == "cleanup" or step.method_name == "stop":
-            grouped["cleanup"].append(step)
-            grouped_json["cleanup"].append(step_dict)
-
-    if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-        return jsonify({
-            "workflow_info": workflow.as_dict(),
-            "steps": grouped_json,
-        })
-    else:
-        return render_template("workflow_view.html", workflow=workflow, grouped=grouped)
-
-
-@database.route("/database/workflows/delete/<int:workflow_id>")
-@login_required
-def delete_workflow_data(workflow_id: int):
-    """
-    .. :quickref: Database; delete experiment data from database
-
-    delete workflow data from database
-
-    .. http:get:: /database/workflows/delete/<int:workflow_id>
-
-    :param workflow_id: workflow id
-    :type workflow_id: int
-    :status 302: redirect to :http:get:`/ivoryos/database/workflows/`
-
-    """
-    run = WorkflowRun.query.get(workflow_id)
-    db.session.delete(run)
-    db.session.commit()
-    return redirect(url_for('database.list_workflows'))

ivoryos/routes/database/templates/database/scripts_database.html

@@ -1,83 +0,0 @@
-{% extends 'base.html' %}
-
-{% block title %}IvoryOS | Design Database{% endblock %}
-{% block body %}
-    <div class="database-filter">
-        {% for deck_name in deck_list %}
-            {% if deck_name == "ALL" %}<a class="btn btn-secondary" href="{{url_for('database.load_from_database')}}">Back</a>
-            {% else %}<a class="btn btn-secondary" href="{{url_for('database.load_from_database',deck_name=deck_name)}}">{{deck_name}}</a>
-            {% endif %}
-        {% endfor %}
-
-        <form id="search" style="display: inline-block;float: right;" action="{{url_for('database.load_from_database',deck_name=deck_name)}}" method="GET">
-            <div class="input-group">
-                <div class="form-outline">
-                    <input type="search" name="keyword" id="keyword" class="form-control" placeholder="Search workflows...">
-                </div>
-                <button type="submit" class="btn btn-primary">
-                    <i class="bi bi-search"></i>
-                </button>
-            </div>
-        </form>
-    </div>
-
-    <table class="table table-hover" id="workflowLibrary">
-        <thead>
-            <tr>
-                <th scope="col">Workflow name</th>
-                <th scope="col">Deck </th>
-                <th scope="col">Editing</th>
-                <th scope="col">Time created</th>
-                <th scope="col">Last modified</th>
-                <th scope="col">Author</th>
-{#                <th scope="col">Registered</th>#}
-                <th scope="col"></th>
-            </tr>
-        </thead>
-        <tbody>
-            {% for script in scripts %}
-                <tr>
-                    <td><a href="{{ url_for('database.edit_workflow', script_name=script.name) }}">{{ script.name }}</a></td>
-                    <td>{{ script.deck }}</td>
-                    <td>{{ script.status }}</td>
-                    <td>{{ script.time_created }}</td>
-                    <td>{{ script.last_modified }}</td>
-                    <td>{{ script.author }}</td>
-{#                    <td>{{ workflow.registered }}</td>#}
-                    <td>
-                        {#not workflow.status == "finalized" or#}
-                        {% if session['user'] == 'admin' or session['user'] == script.author %}
-                            <a href="{{ url_for('database.delete_workflow', script_name=script.name) }}">delete</a>
-                        {% else %}
-                            <a class="disabled-link">delete</a>
-                        {% endif %}
-                    <td>
-                </tr>
-            {% endfor %}
-        </tbody>
-    </table>
-
-    {#    paging#}
-    <div class="pagination justify-content-center">
-        <div class="page-item {{ 'disabled' if not scripts.has_prev else '' }}">
-            <a class="page-link" href="{{ url_for('database.load_from_database', page=scripts.prev_num) }}">Previous</a>
-        </div>
-
-        {% for num in scripts.iter_pages() %}
-            {% if num %}
-                <div class="page-item {{ 'active' if num == scripts.page else '' }}">
-                    <a class="page-link" href="{{ url_for('database.load_from_database', page=num) }}">{{ num }}</a>
-                </div>
-            {% else %}
-                <div class="page-item disabled">
-                    <span class="page-link">…</span>
-                </div>
-            {% endif %}
-        {% endfor %}
-
-        <div class="page-item {{ 'disabled' if not scripts.has_next else '' }}">
-            <a class="page-link" href="{{ url_for('database.load_from_database', page=scripts.next_num) }}">Next</a>
-        </div>
-    </div>
-
-{% endblock %}

ivoryos/routes/database/templates/database/step_card.html

@@ -1,7 +0,0 @@
-<div class="card mb-2 {{ 'border-danger text-danger bg-light' if step.run_error else 'border-secondary' }}">
-  <div class="card-body p-2">
-    <strong>{{ step.method_name }}</strong>
-    <small>Start: {{ step.start_time }}</small>
-    <small>End: {{ step.end_time }}</small>
-  </div>
-</div>

ivoryos/routes/database/templates/database/workflow_database.html

@@ -1,103 +0,0 @@
-{% extends 'base.html' %}
-
-{% block title %}IvoryOS | Design Database{% endblock %}
-{% block body %}
-    <div class="div">
-        <form id="search" style="display: inline-block;float: right;" action="{{url_for('database.list_workflows',deck_name=deck_name)}}" method="GET">
-            <div class="input-group">
-                <div class="form-outline">
-                    <input type="search" name="keyword" id="keyword" class="form-control" placeholder="Search workflows...">
-                </div>
-                <button type="submit" class="btn btn-primary">
-                    <i class="bi bi-search"></i>
-                </button>
-            </div>
-        </form>
-    </div>
-
-    <table class="table table-hover" id="workflowResultLibrary">
-        <thead>
-            <tr>
-                <th scope="col">Workflow name</th>
-                <th scope="col">Workflow ID</th>
-                <th scope="col">Start time</th>
-                <th scope="col">End time</th>
-                <th scope="col">Data</th>
-            </tr>
-        </thead>
-        <tbody>
-            {% for workflow in workflows %}
-                <tr>
-                    <td><a href="{{ url_for('database.get_workflow_steps', workflow_id=workflow.id) }}">{{ workflow.name }}</a></td>
-                    <td>{{ workflow.id }}</td>
-                    <td>{{ workflow.start_time.strftime("%Y-%m-%d %H:%M:%S") if workflow.start_time else '' }}</td>
-                    <td>{{ workflow.end_time.strftime("%Y-%m-%d %H:%M:%S") if workflow.end_time else '' }}</td>
-
-                    <td>
-                        {% if workflow.data_path %}
-                          <a href="{{ url_for('design.download_results', filename=workflow.data_path) }}">{{ workflow.data_path }}</a>
-                        {% endif %}
-                    </td>
-                    <td>
-                        {% if session['user'] == 'admin' or session['user'] == workflow.author %}
-                            <a href="{{ url_for('database.delete_workflow_data', workflow_id=workflow.id) }}">delete</a>
-                        {% else %}
-                            <a class="disabled-link">delete</a>
-                        {% endif %}
-                    </td>
-                </tr>
-            {% endfor %}
-        </tbody>
-    </table>
-
-    {#    paging#}
-    <div class="pagination justify-content-center">
-        <div class="page-item {{ 'disabled' if not workflows.has_prev else '' }}">
-            <a class="page-link" href="{{ url_for('database.list_workflows', page=workflows.prev_num) }}">Previous</a>
-        </div>
-
-        {% for num in workflows.iter_pages() %}
-            {% if num %}
-                <div class="page-item {{ 'active' if num == workflows.page else '' }}">
-                    <a class="page-link" href="{{ url_for('database.list_workflows', page=num) }}">{{ num }}</a>
-                </div>
-            {% else %}
-                <div class="page-item disabled">
-                    <span class="page-link">…</span>
-                </div>
-            {% endif %}
-        {% endfor %}
-
-        <div class="page-item {{ 'disabled' if not workflows.has_next else '' }}">
-            <a class="page-link" href="{{ url_for('database.list_workflows', page=workflows.next_num) }}">Next</a>
-        </div>
-    </div>
-
-    <div id="steps-container"></div>
-
-    <script>
-        function showSteps(workflowId) {
-            fetch(`/workflow_steps/${workflowId}`)
-                .then(response => response.json())
-                .then(data => {
-                    const container = document.getElementById('steps-container');
-                    container.innerHTML = '';  // Clear previous content
-                    const stepsList = document.createElement('ul');
-
-                    data.steps.forEach(step => {
-                        const li = document.createElement('li');
-                        li.innerHTML = `
-                            <strong>Step: </strong> ${step.method_name} <br>
-                            <strong>Start Time:</strong> ${step.start_time} <br>
-                            <strong>End Time:</strong> ${step.end_time} <br>
-                            <strong>Human Intervention:</strong> ${step.run_error ? 'Yes' : 'No'}
-                        `;
-                        stepsList.appendChild(li);
-                    });
-
-                    container.appendChild(stepsList);
-                });
-        }
-    </script>
-
-{% endblock %}

ivoryos/routes/database/templates/database/workflow_view.html

@@ -1,130 +0,0 @@
-{% extends 'base.html' %}
-
-{% block title %}IvoryOS | Experiment Results{% endblock %}
-
-{% block body %}
-<style>
-  .vis-time-axis .vis-text.vis-minor,
-  .vis-time-axis .vis-text.vis-major {
-    color: #666;
-  }
-  .vis-item.stop {
-    background-color: red;
-    color: white;
-    border: none;
-    font-weight: bold;
-  }
-</style>
-
-<div id="timeline"></div>
-
-<script src="https://unpkg.com/vis-timeline@latest/standalone/umd/vis-timeline-graph2d.min.js"></script>
-<link href="https://unpkg.com/vis-timeline@latest/styles/vis-timeline-graph2d.min.css" rel="stylesheet"/>
-
-<h1>Experiment Step View</h1>
-
-<div id="visualization"></div>
-
-<script type="text/javascript">
-  var container = document.getElementById('visualization');
-
-  const items = [
-    {% if grouped.prep %}
-      {
-        id: 'prep',
-        content: 'Prep Phase',
-        start: '{{ grouped.prep[0].start_time }}',
-        end: '{{ grouped.prep[-1].end_time }}',
-        className: 'prep',
-        group: 'prep'
-      },
-    {% endif %}
-
-    {% for repeat_index, step_list in grouped.script.items()|sort %}
-      {
-        id: 'iter{{ repeat_index }}',
-        content: 'Iteration {{ repeat_index }}',
-        start: '{{ step_list[0].start_time }}',
-        end: '{{ step_list[-1].end_time }}',
-        className: 'script',
-        group: 'iter{{ repeat_index }}'
-      },
-      {% for step in step_list %}
-        {% if step.method_name == "stop" %}
-          {
-            id: 'stop-{{ step.id }}',
-            content: '🛑 Stop',
-            start: '{{ step.start_time }}',
-            type: 'point',
-            className: 'stop',
-            group: 'iter{{ repeat_index }}'
-          },
-        {% endif %}
-      {% endfor %}
-    {% endfor %}
-
-    {% if grouped.cleanup %}
-      {
-        id: 'cleanup',
-        content: 'Cleanup Phase',
-        start: '{{ grouped.cleanup[0].start_time }}',
-        end: '{{ grouped.cleanup[-1].end_time }}',
-        className: 'cleanup',
-        group: 'cleanup'
-
-      },
-    {% endif %}
-  ];
-
-  const groups = [
-      {% if grouped.prep %}{ id: 'prep', content: 'Prep' },{% endif %}
-      {% for repeat_index in grouped.script.keys()|sort %}{ id: 'iter{{ repeat_index }}', content: 'Iteration {{ repeat_index }}' },{% endfor %}
-      {% if grouped.cleanup %}{ id: 'cleanup', content: 'Cleanup' },{% endif %}
-  ];
-
-  var options = {
-      clickToUse: true,
-      stack: false,  // important to keep point within group row
-      horizontalScroll: true,
-      zoomKey: 'ctrlKey'
-  };
-
-  // Initialize your timeline with the sorted groups
-  const timeline = new vis.Timeline(container, items, groups, options);
-
-  timeline.on('select', function (props) {
-    const id = props.items[0];
-    if (id && id.startsWith('iter')) {
-      const card = document.getElementById('card-' + id);
-      if (card) {
-        const yOffset = -80;
-        const y = card.getBoundingClientRect().top + window.pageYOffset + yOffset;
-        window.scrollTo({ top: y, behavior: 'smooth' });
-      }
-    }
-  });
-</script>
-
-<h2>Workflow: {{ workflow.name }}</h2>
-
-{% if grouped.prep %}
-  <h4 class="mt-4">Prep Phase</h4>
-  {% for step in grouped.prep %}
-    {% include "step_card.html" %}
-  {% endfor %}
-{% endif %}
-
-{% for repeat_index, step_list in grouped.script.items()|sort %}
-  <h4 class="mt-4" id="card-iter{{ repeat_index }}">Iteration {{ repeat_index }}</h4>
-  {% for step in step_list %}
-    {% include "step_card.html" %}
-  {% endfor %}
-{% endfor %}
-
-{% if grouped.cleanup %}
-  <h4 class="mt-4">Cleanup Phase</h4>
-  {% for step in grouped.cleanup %}
-    {% include "step_card.html" %}
-  {% endfor %}
-{% endif %}
-{% endblock %}

ivoryos/routes/design/design.py

@@ -1,792 +0,0 @@
-import csv
-import json
-import os
-import pickle
-import sys
-import time
-import eventlet
-eventlet.monkey_patch()
-
-from flask import Blueprint, redirect, url_for, flash, jsonify, send_file, request, render_template, session, \
-    current_app, g
-from flask_login import login_required
-from flask_socketio import SocketIO
-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, \
-    create_form_from_action, create_all_builtin_forms
-from ivoryos.utils.db_models import Script, WorkflowRun, SingleStep, WorkflowStep
-from ivoryos.utils.script_runner import ScriptRunner
-# from ivoryos.utils.utils import load_workflows
-
-
-socketio = SocketIO(
-    async_mode="eventlet",
-    cors_allowed_origins="*"
-)
-design = Blueprint('design', __name__, template_folder='templates/design')
-
-global_config = GlobalConfig()
-runner = ScriptRunner()
-
-def abort_pending():
-    runner.abort_pending()
-    socketio.emit('log', {'message': "aborted pending iterations"})
-
-def abort_current():
-    runner.stop_execution()
-    socketio.emit('log', {'message': "stopped next task"})
-
-def pause():
-    runner.retry = False
-    msg = runner.toggle_pause()
-    socketio.emit('log', {'message': msg})
-    return msg
-
-def retry():
-    runner.retry = True
-    msg = runner.toggle_pause()
-    socketio.emit('log', {'message': msg})
-
-
-# ---- Socket.IO Event Handlers ----
-
-@socketio.on('abort_pending')
-def handle_abort_pending():
-    abort_pending()
-
-@socketio.on('abort_current')
-def handle_abort_current():
-    abort_current()
-
-@socketio.on('pause')
-def handle_pause():
-    pause()
-
-@socketio.on('retry')
-def handle_retry():
-    retry()
-
-
-@socketio.on('connect')
-def handle_abort_action():
-    # Fetch log messages from local file
-    filename = os.path.join(current_app.config["OUTPUT_FOLDER"], current_app.config["LOGGERS_PATH"])
-    with open(filename, 'r') as log_file:
-        log_history = log_file.readlines()
-    for message in log_history[-10:]:
-        socketio.emit('log', {'message': message})
-
-
-@design.route("/design/script/", methods=['GET', 'POST'])
-@design.route("/design/script/<instrument>/", methods=['GET', 'POST'])
-@login_required
-def experiment_builder(instrument=None):
-    """
-    .. :quickref: Workflow Design; Build experiment workflow
-
-    **Experiment Builder**
-
-    This route allows users to build and edit experiment workflows. Users can interact with available instruments,
-    define variables, and manage experiment scripts.
-
-    .. http:get:: /design/script
-
-    Load the experiment builder interface.
-
-    :param instrument: The specific instrument for which to load functions and forms.
-    :type instrument: str
-    :status 200: Experiment builder loaded successfully.
-
-    .. http:post:: /design/script
-
-    Submit form data to add or modify actions in the experiment script.
-
-    **Adding action to canvas**
-
-    :form return: (optional) The name of the function or method to add to the script.
-    :form dynamic: depend on the selected instrument and its metadata.
-
-    :status 200: Action added or modified successfully.
-    :status 400: Validation errors in submitted form data.
-    :status 302: Toggles autofill or redirects to refresh the page.
-
-    **Toggle auto parameter name fill**:
-
-    :status 200: autofill toggled successfully
-
-    """
-    deck = global_config.deck
-    script = utils.get_script_file()
-    # load_workflows(script)
-    # registered_workflows = global_config.registered_workflows
-
-    if deck and script.deck is None:
-        script.deck = os.path.splitext(os.path.basename(deck.__file__))[
-            0] if deck.__name__ == "__main__" else deck.__name__
-    # script.sort_actions()
-
-    pseudo_deck_name = session.get('pseudo_deck', '')
-    pseudo_deck_path = os.path.join(current_app.config["DUMMY_DECK"], pseudo_deck_name)
-    off_line = current_app.config["OFF_LINE"]
-    enable_llm = current_app.config["ENABLE_LLM"]
-    autofill = session.get('autofill')
-
-    # autofill is not allowed for prep and cleanup
-    autofill = autofill if script.editing_type == "script" else False
-    forms = None
-    pseudo_deck = utils.load_deck(pseudo_deck_path) if off_line and pseudo_deck_name else None
-    if off_line and pseudo_deck is None:
-        flash("Choose available deck below.")
-
-    deck_list = utils.available_pseudo_deck(current_app.config["DUMMY_DECK"])
-
-    functions = {}
-    if deck:
-        deck_variables = list(global_config.deck_snapshot.keys())
-        # deck_variables.insert(0, "registered_workflows")
-        deck_variables.insert(0, "flow_control")
-
-    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_info = session.get("edit_action")
-    if edit_action_info:
-        forms = create_form_from_action(edit_action_info, script=script)
-    elif instrument:
-        # if instrument in ['if', 'while', 'variable', 'wait', 'repeat']:
-        #     forms = create_builtin_form(instrument, script=script)
-        if instrument == 'flow_control':
-            forms = create_all_builtin_forms(script=script)
-        # elif instrument == 'registered_workflows':
-        #     functions = utils._inspect_class(registered_workflows)
-        #     # forms = create_workflow_forms(script=script)
-        #     forms = create_form_from_pseudo(pseudo=functions, autofill=autofill, script=script)
-        elif instrument in global_config.defined_variables.keys():
-            _object = global_config.defined_variables.get(instrument)
-            functions = utils._inspect_class(_object)
-            forms = create_form_from_pseudo(pseudo=functions, autofill=autofill, script=script)
-        else:
-            if deck:
-                functions = global_config.deck_snapshot.get(instrument, {})
-            elif pseudo_deck:
-                functions = pseudo_deck.get(instrument, {})
-            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 = request.form.get("hidden_name", None)
-            # if method_name is not None:
-            form = forms.get(method_name)
-            insert_position = request.form.get("drop_target_id", None)
-            kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
-            if form and form.validate_on_submit():
-                function_name = kwargs.pop("hidden_name")
-                save_data = kwargs.pop('return', '')
-
-                primitive_arg_types = utils.get_arg_type(kwargs, functions[function_name])
-
-                script.eval_list(kwargs, primitive_arg_types)
-                kwargs = script.validate_variables(kwargs)
-                action = {"instrument": instrument, "action": function_name,
-                          "args": kwargs,
-                          "return": save_data,
-                          'arg_types': primitive_arg_types}
-                script.add_action(action=action, insert_position=insert_position)
-            else:
-                flash(form.errors)
-
-        elif request.method == 'POST' and "builtin_name" in request.form:
-            function_name = request.form.get("builtin_name")
-            form = forms.get(function_name)
-            kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
-            insert_position = request.form.get("drop_target_id", None)
-
-            if form.validate_on_submit():
-                # print(kwargs)
-                logic_type = kwargs.pop('builtin_name')
-                if 'variable' in kwargs:
-                    try:
-                        script.add_variable(insert_position=insert_position, **kwargs)
-                    except ValueError:
-                        flash("Invalid variable type")
-                else:
-                    script.add_logic_action(logic_type=logic_type, insert_position=insert_position, **kwargs)
-            else:
-                flash(form.errors)
-        elif request.method == 'POST' and "workflow_name" in request.form:
-            workflow_name = request.form.get("workflow_name")
-            form = forms.get(workflow_name)
-            kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
-            insert_position = request.form.get("drop_target_id", None)
-
-            if form.validate_on_submit():
-                # workflow_name = kwargs.pop('workflow_name')
-                save_data = kwargs.pop('return', '')
-
-                primitive_arg_types = utils.get_arg_type(kwargs, functions[workflow_name])
-
-                script.eval_list(kwargs, primitive_arg_types)
-                kwargs = script.validate_variables(kwargs)
-                action = {"instrument": instrument, "action": workflow_name,
-                          "args": kwargs,
-                          "return": save_data,
-                          'arg_types': primitive_arg_types}
-                script.add_action(action=action, insert_position=insert_position)
-                script.add_workflow(**kwargs, insert_position=insert_position)
-            else:
-                flash(form.errors)
-
-        # toggle autofill, autofill doesn't apply to control flow ops
-        elif request.method == 'POST' and "autofill" in request.form:
-            autofill = not autofill
-            session['autofill'] = autofill
-            if not instrument == 'flow_control':
-                forms = create_form_from_pseudo(functions, autofill=autofill, script=script)
-
-    utils.post_script_file(script)
-
-    exec_string = script.python_script if script.python_script else script.compile(current_app.config['SCRIPT_FOLDER'])
-    session['python_code'] = exec_string
-
-    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,
-                           forms=forms, buttons=design_buttons, format_name=format_name,
-                           use_llm=enable_llm)
-
-
-@design.route("/design/generate_code", methods=['POST'])
-@login_required
-def generate_code():
-    """
-    .. :quickref: Text to Code; Generate code from user input and update the design canvas.
-
-    .. http:post:: /design/generate_code
-
-    :form prompt: user's prompt
-    :status 200: and then redirects to :http:get:`/experiment/build`
-    :status 400: failed to initialize the AI agent redirects to :http:get:`/design/script`
-
-    """
-    agent = global_config.agent
-    enable_llm = current_app.config["ENABLE_LLM"]
-    instrument = request.form.get("instrument")
-
-    if request.method == 'POST' and "clear" in request.form:
-        session['prompt'][instrument] = ''
-    if request.method == 'POST' and "gen" in request.form:
-        prompt = request.form.get("prompt")
-        session['prompt'][instrument] = prompt
-        # sdl_module = utils.parse_functions(find_instrument_by_name(f'deck.{instrument}'), doc_string=True)
-        sdl_module = global_config.deck_snapshot.get(instrument, {})
-        empty_script = Script(author=session.get('user'))
-        if enable_llm and agent is None:
-            try:
-                model = current_app.config["LLM_MODEL"]
-                server = current_app.config["LLM_SERVER"]
-                module = current_app.config["MODULE"]
-                from ivoryos.utils.llm_agent import LlmAgent
-                agent = LlmAgent(host=server, model=model, output_path=os.path.dirname(os.path.abspath(module)))
-            except Exception as e:
-                flash(e.__str__())
-                return redirect(url_for("design.experiment_builder", instrument=instrument, use_llm=True)), 400
-        action_list = agent.generate_code(sdl_module, prompt)
-        for action in action_list:
-            action['instrument'] = instrument
-            action['return'] = ''
-            if "args" not in action:
-                action['args'] = {}
-            if "arg_types" not in action:
-                action['arg_types'] = {}
-            empty_script.add_action(action)
-        utils.post_script_file(empty_script)
-    return redirect(url_for("design.experiment_builder", instrument=instrument, use_llm=True))
-
-
-@design.route("/design/campaign", methods=['GET', 'POST'])
-@login_required
-def experiment_run():
-    """
-    .. :quickref: Workflow Execution; Execute/iterate the workflow
-
-    .. http:get:: /design/campaign
-
-    Compile the workflow and load the experiment execution interface.
-
-    .. http:post:: /design/campaign
-
-    Start workflow execution
-
-    """
-    deck = global_config.deck
-    script = utils.get_script_file()
-
-    # script.sort_actions() # handled in update list
-    off_line = current_app.config["OFF_LINE"]
-    deck_list = utils.import_history(os.path.join(current_app.config["OUTPUT_FOLDER"], 'deck_history.txt'))
-    # if not off_line and deck is None:
-    #     # print("loading deck")
-    #     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(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"]
-    try:
-        # todo
-        exec_string = script.python_script if script.python_script else script.compile(current_app.config['SCRIPT_FOLDER'])
-        # exec_string = script.compile(current_app.config['SCRIPT_FOLDER'])
-        # print(exec_string)
-    except Exception as e:
-        flash(e.__str__())
-        # handle api request
-        if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-            return jsonify({"error": e.__str__()})
-        else:
-            return redirect(url_for("design.experiment_builder"))
-
-    config_file = request.args.get("filename")
-    config = []
-    if config_file:
-        session['config_file'] = config_file
-    filename = session.get("config_file")
-    if filename:
-        # config_preview = list(csv.DictReader(open(os.path.join(current_app.config['CSV_FOLDER'], filename))))
-        config = list(csv.DictReader(open(os.path.join(current_app.config['CSV_FOLDER'], filename))))
-        config_preview = config[1:]
-        arg_type = config.pop(0)  # first entry is types
-    try:
-        for key, func_str in exec_string.items():
-            exec(func_str)
-        line_collection = script.convert_to_lines(exec_string)
-
-    except Exception:
-        flash(f"Please check {key} syntax!!")
-        return redirect(url_for("design.experiment_builder"))
-    # runner.globals_dict.update(globals())
-    run_name = script.name if script.name else "untitled"
-
-    dismiss = session.get("dismiss", None)
-    script = utils.get_script_file()
-    no_deck_warning = False
-
-    _, return_list = script.config_return()
-    config_list, config_type_list = script.config("script")
-    # config = script.config("script")
-    data_list = os.listdir(current_app.config['DATA_FOLDER'])
-    data_list.remove(".gitkeep") if ".gitkeep" in data_list else data_list
-    if deck is None:
-        no_deck_warning = True
-        flash(f"No deck is found, import {script.deck}")
-    elif script.deck:
-        is_deck_match = script.deck == deck.__name__ or script.deck == \
-                        os.path.splitext(os.path.basename(deck.__file__))[0]
-        if not is_deck_match:
-            flash(f"This script is not compatible with current deck, import {script.deck}")
-    if request.method == "POST":
-        bo_args = None
-        compiled = False
-        if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-            payload_json = request.get_json()
-            compiled = True
-            if "kwargs" in payload_json:
-                config = payload_json["kwargs"]
-            elif "parameters" in payload_json:
-                bo_args = payload_json
-            repeat = payload_json.pop("repeat", None)
-        else:
-            if "bo" in request.form:
-                bo_args = request.form.to_dict()
-            if "online-config" in request.form:
-                config = utils.web_config_entry_wrapper(request.form.to_dict(), config_list)
-            repeat = request.form.get('repeat', None)
-
-        try:
-            datapath = current_app.config["DATA_FOLDER"]
-            run_name = script.validate_function_name(run_name)
-            runner.run_script(script=script, run_name=run_name, config=config, bo_args=bo_args,
-                              logger=g.logger, socketio=g.socketio, repeat_count=repeat,
-                              output_path=datapath, compiled=compiled,
-                              current_app=current_app._get_current_object()
-                              )
-            if utils.check_config_duplicate(config):
-                flash(f"WARNING: Duplicate in config entries.")
-        except Exception as e:
-            if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-                return jsonify({"error": e.__str__()})
-            else:
-                flash(e)
-    if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
-        # wait to get a workflow ID
-        while not global_config.runner_status:
-            time.sleep(1)
-        return jsonify({"status": "task started", "task_id": global_config.runner_status.get("id")})
-    else:
-        return render_template('experiment_run.html', script=script.script_dict, filename=filename,
-                           dot_py=exec_string, line_collection=line_collection,
-                           return_list=return_list, config_list=config_list, config_file_list=config_file_list,
-                           config_preview=config_preview, data_list=data_list, config_type_list=config_type_list,
-                           no_deck_warning=no_deck_warning, dismiss=dismiss, design_buttons=design_buttons,
-                           history=deck_list, pause_status=runner.pause_status())
-
-
-@design.route("/design/script/toggle/<stype>")
-@login_required
-def toggle_script_type(stype=None):
-    """
-    .. :quickref: Workflow Design; toggle the experimental phase for design canvas.
-
-    .. http:get:: /design/script/toggle/<stype>
-
-    :status 200: and then redirects to :http:get:`/design/script`
-
-    """
-    script = utils.get_script_file()
-    script.editing_type = stype
-    utils.post_script_file(script)
-    return redirect(url_for('design.experiment_builder'))
-
-
-@design.route("/updateList", methods=['POST'])
-@login_required
-def update_list():
-    order = request.form['order']
-    script = utils.get_script_file()
-    script.currently_editing_order = order.split(",", len(script.currently_editing_script))
-    script.sort_actions()
-    exec_string = script.compile(current_app.config['SCRIPT_FOLDER'])
-    utils.post_script_file(script)
-    session['python_code'] = exec_string
-
-    return jsonify({'success': True})
-
-
-@design.route("/toggle_show_code", methods=["POST"])
-def toggle_show_code():
-    session["show_code"] = not session.get("show_code", False)
-    return redirect(request.referrer or url_for("design.experiment_builder"))
-
-
-# --------------------handle all the import/export and download/upload--------------------------
-@design.route("/design/clear")
-@login_required
-def clear():
-    """
-    .. :quickref: Workflow Design; clear the design canvas.
-
-    .. http:get:: /design/clear
-
-    :form prompt: user's prompt
-    :status 200: clear canvas and then redirects to :http:get:`/design/script`
-    """
-    deck = global_config.deck
-    pseudo_name = session.get("pseudo_deck", "")
-    if deck:
-        deck_name = os.path.splitext(os.path.basename(deck.__file__))[
-            0] if deck.__name__ == "__main__" else deck.__name__
-    elif pseudo_name:
-        deck_name = pseudo_name
-    else:
-        deck_name = ''
-    script = Script(deck=deck_name, author=session.get('username'))
-    utils.post_script_file(script)
-    return redirect(url_for("design.experiment_builder"))
-
-
-@design.route("/design/import/pseudo", methods=['POST'])
-@login_required
-def import_pseudo():
-    """
-    .. :quickref: Workflow Design; Import pseudo deck from deck history
-
-    .. http:post:: /design/import/pseudo
-
-    :form pkl_name: pseudo deck name
-    :status 302: load pseudo deck and then redirects to :http:get:`/design/script`
-    """
-    pkl_name = request.form.get('pkl_name')
-    script = utils.get_script_file()
-    session['pseudo_deck'] = pkl_name
-
-    if script.deck is None or script.isEmpty():
-        script.deck = pkl_name.split('.')[0]
-        utils.post_script_file(script)
-    elif script.deck and not script.deck == pkl_name.split('.')[0]:
-        flash(f"Choose the deck with name {script.deck}")
-    return redirect(url_for("design.experiment_builder"))
-
-
-@design.route('/design/uploads', methods=['POST'])
-@login_required
-def upload():
-    """
-    .. :quickref: Workflow Execution; upload a workflow config file (.CSV)
-
-    .. http:post:: /design/uploads
-
-    :form file: workflow CSV config file
-    :status 302: save csv file and then redirects to :http:get:`/design/campaign`
-    """
-    if request.method == "POST":
-        f = request.files['file']
-        if 'file' not in request.files:
-            flash('No file part')
-        if f.filename.split('.')[-1] == "csv":
-            filename = secure_filename(f.filename)
-            f.save(os.path.join(current_app.config['CSV_FOLDER'], filename))
-            session['config_file'] = filename
-            return redirect(url_for("design.experiment_run"))
-        else:
-            flash("Config file is in csv format")
-            return redirect(url_for("design.experiment_run"))
-
-
-@design.route('/design/workflow/download/<filename>')
-@login_required
-def download_results(filename):
-    """
-    .. :quickref: Workflow Design; download a workflow data file
-
-    .. http:get:: /design/workflow/download/<filename>
-
-    """
-    filepath = os.path.join(current_app.config["DATA_FOLDER"], filename)
-    return send_file(os.path.abspath(filepath), as_attachment=True)
-
-
-@design.route('/design/load_json', methods=['POST'])
-@login_required
-def load_json():
-    """
-    .. :quickref: Workflow Design Ext; upload a workflow design file (.JSON)
-
-    .. http:post:: /load_json
-
-    :form file: workflow design JSON file
-    :status 302: load pseudo deck and then redirects to :http:get:`/design/script`
-    """
-    if request.method == "POST":
-        f = request.files['file']
-        if 'file' not in request.files:
-            flash('No file part')
-        if f.filename.endswith("json"):
-            script_dict = json.load(f)
-            utils.post_script_file(script_dict, is_dict=True)
-        else:
-            flash("Script file need to be JSON file")
-    return redirect(url_for("design.experiment_builder"))
-
-
-@design.route('/design/script/download/<filetype>')
-@login_required
-def download(filetype):
-    """
-    .. :quickref: Workflow Design Ext; download a workflow design file
-
-    .. http:get:: /design/script/download/<filetype>
-
-    """
-    script = utils.get_script_file()
-    run_name = script.name if script.name else "untitled"
-    if filetype == "configure":
-        filepath = os.path.join(current_app.config['SCRIPT_FOLDER'], f"{run_name}_config.csv")
-        with open(filepath, 'w', newline='') as f:
-            writer = csv.writer(f)
-            cfg, cfg_types = script.config("script")
-            writer.writerow(cfg)
-            writer.writerow(list(cfg_types.values()))
-    elif filetype == "script":
-        script.sort_actions()
-        json_object = json.dumps(script.as_dict())
-        filepath = os.path.join(current_app.config['SCRIPT_FOLDER'], f"{run_name}.json")
-        with open(filepath, "w") as outfile:
-            outfile.write(json_object)
-    elif filetype == "python":
-        filepath = os.path.join(current_app.config["SCRIPT_FOLDER"], f"{run_name}.py")
-    else:
-        return "Unsupported file type", 400
-    return send_file(os.path.abspath(filepath), as_attachment=True)
-
-
-@design.route("/design/step/edit/<uuid>", methods=['GET', 'POST'])
-@login_required
-def edit_action(uuid: str):
-    """
-    .. :quickref: Workflow Design; edit parameters of an action step on canvas
-
-    .. http:get:: /design/step/edit/<uuid>
-
-    Load parameter form of an action step
-
-    .. http:post:: /design/step/edit/<uuid>
-
-    :param uuid: The step's uuid
-    :type uuid: str
-
-    :form dynamic form: workflow step dynamic inputs
-    :status 302: save changes and then redirects to :http:get:`/design/script`
-    """
-    script = utils.get_script_file()
-    action = script.find_by_uuid(uuid)
-    session['edit_action'] = action
-
-    if request.method == "POST" and action is not None:
-        forms = create_form_from_action(action, script=script)
-        if "back" not in request.form:
-            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.validate_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'))
-
-
-@design.route("/design/step/delete/<id>")
-@login_required
-def delete_action(id: int):
-    """
-    .. :quickref: Workflow Design; delete an action step on canvas
-
-    .. http:get:: /design/step/delete/<id>
-
-    :param id: The step number id
-    :type id: int
-
-    :status 302: save changes and then redirects to :http:get:`/design/script`
-    """
-    back = request.referrer
-    script = utils.get_script_file()
-    script.delete_action(id)
-    utils.post_script_file(script)
-    return redirect(back)
-
-
-@design.route("/design/step/duplicate/<id>")
-@login_required
-def duplicate_action(id: int):
-    """
-    .. :quickref: Workflow Design; duplicate an action step on canvas
-
-    .. http:get:: /design/step/duplicate/<id>
-
-    :param id: The step number id
-    :type id: int
-
-    :status 302: save changes and then redirects to :http:get:`/design/script`
-    """
-    back = request.referrer
-    script = utils.get_script_file()
-    script.duplicate_action(id)
-    utils.post_script_file(script)
-    return redirect(back)
-
-
-# ---- HTTP API Endpoints ----
-
-@design.route("/api/runner/status", methods=["GET"])
-def runner_status():
-    """
-    .. :quickref: Workflow Design; get the execution status
-
-    .. http:get:: /api/runner/status
-
-    :status 200: status
-    """
-    runner_busy = global_config.runner_lock.locked()
-    status = {"busy": runner_busy}
-    task_status = global_config.runner_status
-    current_step = {}
-    # print(task_status)
-    if task_status is not None:
-        task_type = task_status["type"]
-        task_id = task_status["id"]
-        if task_type == "task":
-            step = SingleStep.query.get(task_id)
-            current_step = step.as_dict()
-        if task_type == "workflow":
-            workflow = WorkflowRun.query.get(task_id)
-            if workflow is not None:
-                latest_step = WorkflowStep.query.filter_by(workflow_id=workflow.id).order_by(WorkflowStep.start_time.desc()).first()
-                if latest_step is not None:
-                    current_step = latest_step.as_dict()
-                status["workflow_status"] = {"workflow_info": workflow.as_dict(), "runner_status": runner.get_status()}
-    status["current_task"] = current_step
-    return jsonify(status), 200
-
-
-
-@design.route("/api/runner/abort_pending", methods=["POST"])
-def api_abort_pending():
-    """
-    .. :quickref: Workflow Design; abort pending action(s) during execution
-
-    .. http:get:: /api/runner/abort_pending
-
-    :status 200: {"status": "ok"}
-    """
-    abort_pending()
-    return jsonify({"status": "ok"}), 200
-
-@design.route("/api/runner/abort_current", methods=["POST"])
-def api_abort_current():
-    """
-    .. :quickref: Workflow Design; abort right after current action during execution
-
-    .. http:get:: /api/runner/abort_current
-
-    :status 200: {"status": "ok"}
-    """
-    abort_current()
-    return jsonify({"status": "ok"}), 200
-
-@design.route("/api/runner/pause", methods=["POST"])
-def api_pause():
-    """
-    .. :quickref: Workflow Design; pause during execution
-
-    .. http:get:: /api/runner/pause
-
-    :status 200: {"status": "ok"}
-    """
-    msg = pause()
-    return jsonify({"status": "ok", "pause_status": msg}), 200
-
-@design.route("/api/runner/retry", methods=["POST"])
-def api_retry():
-    """
-    .. :quickref: Workflow Design; retry when error occur during execution
-
-    .. http:get:: /api/runner/retry
-
-    :status 200: {"status": "ok"}
-    """
-    retry()
-    return jsonify({"status": "ok, retrying failed step"}), 200
-
-
-@design.route("/api/design/submit", methods=["POST"])
-def submit_script():
-    """
-    .. :quickref: Workflow Design; submit script
-
-    .. http:get:: /api/design/submit
-
-    :status 200: {"status": "ok"}
-    """
-    deck = global_config.deck
-    deck_name = os.path.splitext(os.path.basename(deck.__file__))[0] if deck.__name__ == "__main__" else deck.__name__
-    script = Script(author=session.get('user'), deck=deck_name)
-    script_collection = request.get_json()
-    script.python_script = script_collection
-    # todo check script format
-    utils.post_script_file(script)
-    return jsonify({"status": "ok"}), 200

ivoryos/routes/design/templates/design/experiment_builder.html

@@ -1,521 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Design{% endblock %}
-
-{% block body %}
-    {# overlay block for text-to-code gen #}
-    <style>
-    .code-overlay {
-        position: absolute;
-        top: 0;
-        right: -50%;
-        height: 100%;
-        width: 50%;
-        z-index: 100;
-        background: #f8f9fa;
-        box-shadow: -2px 0 6px rgba(0, 0, 0, 0.1);
-        transition: right 0.3s ease;
-        overflow-y: auto;
-    }
-    .code-overlay.show {
-        right: 0;
-    }
-</style>
-    <div id="overlay" class="overlay">
-        <div>
-            <h3 id="overlay-text">Generating design, please wait...</h3>
-            <div class="spinner-border" role="status"></div>
-        </div>
-    </div>
-
-    <div class="row">
-        <div class="col-md-3 scroll-column" >
-
-            {# select deck if this is online#}
-            {% if off_line %}
-                <form id="select-deck" method="POST" action="{{ url_for('design.import_pseudo') }}" enctype="multipart/form-data">
-                    <div class="input-group mb-3">
-{#                        <label for="pkl_name" class="form-label">Choose/Change deck:</label>#}
-                        <select class="form-select" name="pkl_name" id="pkl_name" required onchange="document.getElementById('select-deck').submit();">
-                            <option {{ '' if 'pseudo_deck' in session else 'selected' }} disabled hidden style="overflow-wrap: break-word;" name="pkl_name" id="pkl_name" value=""> -- choose deck --</option>
-                            {% for connection in history %}
-                                <option {{ 'selected' if session['pseudo_deck']==connection else '' }} style="overflow-wrap: break-word;" name="pkl_name" id="pkl_name" value="{{connection}}">{{connection.split('.')[0]}}</option>
-                            {% endfor %}
-                        </select>
-                    </div>
-                </form>
-                <hr>
-            {% endif %}
-
-            {# edit action #}
-            {% if 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']) }}">
-                        {% if not action['args'] == None %}
-                        <div class="form-group">
-                            {% if not action['args'].__class__.__name__ == 'dict' %}
-                                <div class="input-group mb-3">
-                                    <label class="input-group-text">{{ action['action'] }}</label>
-                                    <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>#}
-{#                                {% 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 %}
-                            {% endif %}
-                        </div>
-                        {% endif %}
-                        <button class="btn btn-primary" type="submit">Save</button>
-                        <button class="btn btn-primary" type="submit" name="back" id="back" value="back">Back</button>
-                    </form>
-                {% endwith %}
-
-
-            {% elif instrument %}
-                <div>
-                    <div class="d-flex justify-content-between align-items-center " style="margin-bottom: 1vh;margin-top: 1vh;">
-                        <a class="btn btn-primary" role="button" type="button" href="{{url_for('design.experiment_builder')}}"><i class="bi bi-arrow-return-left"></i></a>
-                        {{ format_name(instrument) }}
-                    </div>
-
-                    {% if script.editing_type == "script" %}
-                        {# Auto Fill Toggle #}
-                        <div class="d-flex justify-content-between align-items-center " style="margin-bottom: 1vh;margin-top: 1vh;">
-                            <div></div>
-                            <form role="form" method='POST' name="autoFill" id="autoFill">
-                                <div class="form-check form-switch">
-                                    <input type="hidden" id="autofill" name="autofill" value="temp_value">
-                                    <input class="form-check-input" type="checkbox" id="autoFillCheck" name="autoFillCheck" onchange="document.getElementById('autoFill').submit();"
-                                           value="temp_value"
-                                            {{ "checked" if session["autofill"] else "" }}>
-                                    <label class="form-check-label" for="autoFillCheck">Auto fill</label>
-                                </div>
-                                <button type="submit" class="btn btn-default" style="display: none;">Auto fill </button>
-                            </form>
-                        </div>
-                    {% endif %}
-
-                        {# according for instrument #}
-                        <div class="accordion accordion-flush" id="accordionActions" >
-                            {% if use_llm and not instrument == "flow_control" %}
-                                <div class="accordion-item text-to-code">
-                                <h2 class="accordion-header">
-                                    <button class="accordion-button text-to-code" type="button" data-bs-toggle="collapse" data-bs-target="#text-to-code" aria-expanded="false" aria-controls="collapseExample">
-                                        Text-to-Code
-                                    </button>
-                                </h2>
-                                <div id="text-to-code" class="accordion-collapse collapse show" data-bs-parent="#accordionActions">
-                                    <div class="accordion-body">
-                                        <form role="form" method='POST' name="generate" id="generate" action="{{url_for('design.generate_code')}}">
-                                            <input type="hidden" id="instrument" name="instrument" value="{{instrument}}">
-                                            <textarea class="form-control" id="prompt" name="prompt" rows="6" aria-describedby="promptHelpBlock">{{ session['prompt'][instrument] if instrument in session['prompt'] else '' }}</textarea>
-                                            <div id="promptHelpBlock" class="form-text">
-                                                This will overwrite current design.
-                                            </div>
-<!--                                               <button type="submit" class="btn btn-dark" id="clear" name="clear" onclick="submitForm('generate')">Clear</button>-->
-                                            <button type="submit" class="btn btn-dark" id="gen" name="gen">Generate</button>
-                                        </form>
-                                    </div>
-                                </div>
-                            </div>
-                            {% endif %}
-
-                            {% for name, form in forms.items() %}
-                                <div class="accordion-item design-control" draggable="true">
-                                    <h2 class="accordion-header">
-                                        <button class="accordion-button collapsed draggable-action"
-                                                type="button" data-bs-toggle="collapse"
-                                                data-bs-target="#{{name}}" aria-expanded="false"
-                                                aria-controls="collapseExample"
-                                                 data-action="{{ name }}">
-                                            {{ format_name(name) }}
-                                        </button>
-                                    </h2>
-                                    <div id="{{name}}" class="accordion-collapse collapse" data-bs-parent="#accordionActions">
-                                        <div class="accordion-body">
-                                            <form role="form" method='POST' name="add" id="add-{{name}}">
-                                                <div class="form-group">
-                                                    {{ form.hidden_tag() }}
-                                                    {% for field in form %}
-                                                        {% if field.type not in ['CSRFTokenField', 'HiddenField'] %}
-                                                            <div class="input-group mb-3">
-                                                                <label class="input-group-text">{{ field.label.text }}</label>
-                                                                {% if field.type == "SubmitField" %}
-                                                                    {{ field(class="btn btn-dark") }}
-                                                                {% elif field.type == "BooleanField" %}
-                                                                    {{ field(class="form-check-input") }}
-                                                                {% elif field.type == "FlexibleEnumField" %}
-                                                                   <input type="text" id="{{ field.id }}" name="{{ field.name }}" value="{{ field.data }}"
-                                                                      list="{{ field.id }}_options" placeholder="{{ field.render_kw.placeholder if field.render_kw and field.render_kw.placeholder }}"
-                                                                      class="form-control">
-                                                                   <datalist id="{{ field.id }}_options">
-                                                                      {% for key in field.choices %}
-                                                                         <option value="{{ key }}">{{ key }}</option>
-                                                                      {% endfor %}
-                                                                   </datalist>
-
-                                                                {% else %}
-                                                                    {{ field(class="form-control") }}
-                                                                {% endif %}
-                                                            </div>
-                                                        {% endif %}
-                                                    {% endfor %}
-                                                </div>
-                                                <button type="submit" class="btn btn-dark">Add</button>
-                                                {% if 'hidden_name' in form %}
-                                                    <i class="bi bi-info-circle ms-2" data-bs-toggle="tooltip" data-bs-placement="top"
-                                                       title='{{ form.hidden_name.description or "Docstring is not available" }}'>
-                                                    </i>
-                                                {% else %}
-                                                    <!-- handle info tooltip for flow control / workflows -->
-                                                {% endif %}
-
-                                            </form>
-                                        </div>
-                                    </div>
-                                </div>
-                            {% endfor %}
-                        </div>
-                </div>
-
-
-            {# according for all actions #}
-            {% else %}
-                <div style="margin-bottom: 4vh;"></div>
-                <div class="accordion accordion-flush">
-
-                    <div class="accordion-item design-control">
-                        <h5 class="accordion-header">
-                            <button class="accordion-button" data-bs-toggle="collapse" data-bs-target="#deck" role="button" aria-expanded="false" aria-controls="collapseExample">
-                                Operations
-                            </button>
-                        </h5>
-                        <div class="accordion-collapse collapse show" id="deck">
-                            <ul class="list-group">
-                                {% for instrument in defined_variables %}
-                                    <form role="form" method='GET' name="{{instrument}}" action="{{url_for('design.experiment_builder',instrument=instrument)}}">
-                                        <div>
-                                            <button class="list-group-item list-group-item-action" type="submit">{{format_name(instrument)}}</button>
-                                        </div>
-                                    </form>
-                                {% endfor %}
-                            </ul>
-                        </div>
-                    </div>
-
-                    {% if local_variables %}
-                        <div class="accordion-item  design-control">
-                            <h5 class="accordion-header">
-                                <button class="accordion-button" data-bs-toggle="collapse" data-bs-target="#local" role="button" aria-expanded="false" aria-controls="collapseExample">
-                                    Local Operations
-                                </button>
-                            </h5>
-                            <div class="accordion-collapse collapse show" id="local">
-                                <ul class="list-group">
-                                    {% for instrument in local_variables %}
-                                        <form role="form" method='GET' name="{{instrument}}" action="{{url_for('design.experiment_builder',instrument=instrument)}}">
-                                            <div>
-                                                <button class="list-group-item list-group-item-action" type="submit"  name="device" value="{{instrument}}" >{{instrument}}</button>
-                                            </div>
-                                        </form>
-                                    {% endfor%}
-                                </ul>
-                            </div>
-                        </div>
-                    {% endif %}
-                </div>
-            {% endif %}
-        </div>
-
-        {# canvas #}
-        <div class="col-md-9 scroll-column">
-            <div class="d-flex align-items-center ">
-{#                file dropdown menu    #}
-                <ul class="nav nav-tabs">
-                    <li class="nav-item dropdown">
-                        <a class="nav-link dropdown-toggle" type="button" data-bs-toggle="dropdown" aria-expanded="false">File tools <i class="bi bi-tools"></i></a>
-                        <ul class="dropdown-menu">
-                            <button class="dropdown-item" type="button" data-bs-toggle="modal" data-bs-target="#newScriptModal">New</button>
-                            <button class="dropdown-item" type="button" data-bs-toggle="modal" data-bs-target="#jsonModal">Import (.json <i class="bi bi-filetype-json"></i>)</button>
-                            <button class="dropdown-item" type="button" data-bs-toggle="modal" data-bs-target="#renameModal">Rename</button>
-                            <a role="button" class="dropdown-item {{'disabled' if not script.name or script.status == 'finalized'}}" type="button" href="{{url_for('database.publish')}}">Save</a></li>
-                            <button class="dropdown-item" type="button" data-bs-toggle="modal" data-bs-target="#saveasModal">Save as</button>
-                            {% if not script.status == 'finalized' %}
-                                <a role="button" class="dropdown-item" type="button" href="{{url_for('database.finalize')}}">Disable editing</a>
-                            {% endif %}
-                            <a  class="dropdown-item" role="button" type="button" href="{{url_for('design.download', filetype='script')}}">Export (.json <i class="bi bi-filetype-json"></i>)</a>
-                        </ul>
-                    </li>
-
-                    <li class="nav-item"><a class="nav-link" aria-current="page" data-bs-toggle="collapse" href="#info">Info</a></li>
-                    <li class="nav-item"><a class="{{'nav-link active' if script.editing_type=='prep' else 'nav-link'}}" aria-current="page" href="{{url_for('design.toggle_script_type', stype='prep') }}">Prep</a></li>
-                    <li class="nav-item"><a class="{{'nav-link active' if script.editing_type=='script' else 'nav-link'}}" aria-current="page" href="{{url_for('design.toggle_script_type', stype='script') }}">Experiment</a></li>
-                    <li class="nav-item"><a class="{{'nav-link active' if script.editing_type=='cleanup' else 'nav-link'}}" aria-current="page" href="{{url_for('design.toggle_script_type', stype='cleanup') }}">Clean up</a></li>
-                </ul>
-                <form method="POST" action="{{ url_for('design.toggle_show_code') }}" class="ms-3">
-                    <div class="form-check form-switch">
-                        <input class="form-check-input" type="checkbox" id="showPythonCodeSwitch" name="show_code"
-                               onchange="this.form.submit()" {% if session.get('show_code') %}checked{% endif %}>
-                        <label class="form-check-label" for="showPythonCodeSwitch">Show Python Code</label>
-                    </div>
-                </form>
-
-                <div class="form-check form-switch ms-auto">
-                    <input class="form-check-input" type="checkbox" id="toggleLineNumbers" onchange="toggleLineNumbers()">
-                    <label class="form-check-label" for="toggleLineNumbers">Show Line Numbers</label>
-                </div>
-
-            </div>
-            <div class="canvas-wrapper position-relative">
-                <div class="canvas" droppable="true">
-                    <div class="collapse" id="info">
-                        <table class="table script-table">
-                            <tbody>
-                                <tr><th scope="row">Deck Name</th><td>{{script.deck}}</td></tr>
-                                <tr><th scope="row">Script Name</th><td>{{ script.name }}</td></tr>
-                                <tr>
-                                    <th scope="row">Editing status <a role="button" data-bs-toggle="popover" data-bs-title="How to use:" data-bs-content="You can choose to disable editing, so the script is finalized and cannot be edited. Use save as to rename the script"><i class="bi bi-info-circle"></i></a></th>
-                                    <td>{{script.status}}</td>
-                                </tr>
-                                <tr>
-                                    <th scope="row">Output Values <a role="button" data-bs-toggle="popover" data-bs-title="How to use:" data-bs-content="This will be your output data. If the return data is not a value, it will save as None is the result file"><i class="bi bi-info-circle"></i></a></th>
-                                    <td>
-                                        {% for i in script.config_return()[1] %}
-                                            <input type="checkbox">{{i}}
-                                        {% endfor %}
-                                    </td>
-                                </tr>
-                                <tr>
-                                    <th scope="row">Config Variables <a role="button" data-bs-toggle="popover" data-bs-title="How to use:" data-bs-content="This shows variables you want to configure later using .csv file"><i class="bi bi-info-circle"></i></a></th>
-                                    <td>
-                                        <ul>
-                                            {% for i in script.config("script")[0] %}
-                                                <li>{{i}}</li>
-                                            {% endfor %}
-                                        </ul>
-                                    </td>
-                                </tr>
-                            </tbody>
-                        </table>
-                    </div>
-
-                    <div class="list-group" id="list" style="margin-top: 20px">
-                        <ul class="reorder">
-                        {% for button in buttons %}
-                            <li id="{{ button['id'] }}" style="list-style-type: none;">
-                                <span class="line-number d-none">{{ button['id'] }}.</span>
-                                <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","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>
-                            </li>
-                        {% endfor %}
-                        </ul>
-
-                        <!-- Python Code Overlay -->
-                        <!-- Right side: Python code (conditionally shown) -->
-                        <!-- Python Code Slide-Over Panel -->
-                        {% if session.get('show_code') %}
-                        <div id="pythonCodeOverlay" class="code-overlay bg-light border-start show">
-                            <div class="overlay-header d-flex justify-content-between align-items-center px-3 py-2 border-bottom">
-                                <strong>Python Code</strong>
-                                <button class="btn btn-sm btn-outline-secondary" onclick="toggleCodeOverlay(false)">
-                                    <i class="bi bi-x-lg"></i>
-                                </button>
-                            </div>
-                            <div class="overlay-content p-3">
-                                {% for stype, script in session['python_code'].items() %}
-                                    <pre><code class="language-python">{{ script }}</code></pre>
-                                {% endfor %}
-                                <a href="{{ url_for('design.download', filetype='python') }}">Download <i class="bi bi-download"></i></a>
-                            </div>
-                        </div>
-                        {% endif %}
-                    </div>
-                </div>
-            <div>
-                <a class="btn btn-dark {{ 'disabled' if not script.name or script.status == "finalized" else ''}}" href="{{url_for('database.publish')}}">Quick Save</a>
-                <a class="btn btn-dark " href="{{ url_for('design.experiment_run') }}">Compile and Run</a>
-            </div>
-        </div>
-    </div>
-
-{# modals #}
-<div class="modal fade" id="newScriptModal" tabindex="-1" aria-labelledby="newScriptModalLabel" aria-hidden="true">
-    <div class="modal-dialog">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h1 class="modal-title fs-5" id="newScriptModalLabel">Save your current editing!</h1>
-                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-            </div>
-            <div class="modal-body">
-                The current editing won't be saved. Are you sure you want to proceed?
-            </div>
-            <div class="modal-footer">
-                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal"> Continue editing </button>
-                <a role="button" class="btn btn-primary" href="{{url_for('design.clear')}}"> Already saved, clear all </a>
-            </div>
-        </div>
-    </div>
-</div>
-<div class="modal fade" id="saveasModal" tabindex="-1" aria-labelledby="saveasModal" aria-hidden="true" >
-    <div class="modal-dialog">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h1 class="modal-title fs-5" id="saveasModal">Save your script as </h1>
-                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-            </div>
-            <form method="POST" name="run_name" action="{{ url_for('database.save_as') }}">
-                <div class="modal-body">
-                    <div class="input-group mb-3">
-                        <label class="input-group-text" for="run_name">Run Name</label>
-                        <input class="form-control" type="text" name="run_name" id="run_name" placeholder="{{script['name']}}" required="required">
-                    </div>
-                    <div class="form-check form-switch">
-                        <input class="form-check-input" type="checkbox" name="register_workflow" id="register_workflow">
-                        <label class="input-group-label" for="register_workflow">Register this workflow</label>
-                    </div>
-                </div>
-                <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal"> Close </button>
-                    <button type="submit"  class="btn btn-primary"> Save </button>
-                </div>
-            </form>
-        </div>
-    </div>
-</div>
-<div class="modal fade" id="renameModal" tabindex="-1" aria-labelledby="renameModal" aria-hidden="true" >
-    <div class="modal-dialog">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h1 class="modal-title fs-5" id="renameModal">Rename your script</h1>
-                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-            </div>
-            <form method="POST" name="run_name" action="{{ url_for('database.edit_run_name') }}">
-                <div class="modal-body">
-                    <div class="input-group mb-3">
-                        <label class="input-group-text" for="run_name">Run Name</label>
-                        <input class="form-control" type="text" name="run_name" id="run_name" placeholder="{{script['name']}}" required="required">
-                    </div>
-                </div>
-                <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal"> Close </button>
-                    <button type="submit"  class="btn btn-primary"> Save </button>
-                </div>
-            </form>
-        </div>
-    </div>
-</div>
-<div class="modal fade" id="jsonModal" tabindex="-1" aria-labelledby="jsonModal" aria-hidden="true" >
-    <div class="modal-dialog">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h1 class="modal-title fs-5" id="jsonModal">Import from JSON</h1>
-                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-            </div>
-            <form method="POST" action="{{ url_for('design.load_json') }}" enctype="multipart/form-data">
-                <div class="modal-body">
-                    <div class="input-group mb-3">
-                        <input class="form-control" type="file" name="file" required="required">
-                    </div>
-                </div>
-                <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal"> Close </button>
-                    <button type="submit" class="btn btn-primary"> Upload </button>
-                </div>
-            </form>
-        </div>
-    </div>
-</div>
-<!-- Bootstrap Modal -->
-<div class="modal fade" id="dropModal" tabindex="-1" aria-labelledby="dropModalLabel" aria-hidden="true">
-    <div class="modal-dialog">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h5 class="modal-title" id="dropModalLabel">Configure Action</h5>
-                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-            </div>
-            <div class="modal-body">
-                <p>Drop Position ID: <strong id="modalDropTarget"></strong></p>
-
-                <!-- Form will be dynamically inserted here -->
-                <div id="modalFormFields"></div>
-            </div>
-            <div class="modal-footer">
-                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
-            </div>
-        </div>
-    </div>
-</div>
-
-
-{% if instrument and use_llm %}
-    <script>
-        const buttonIds = {{ ['generate'] | tojson }};
-    </script>
-    <script src="{{ url_for('static', filename='js/overlay.js') }}"></script>
-{% endif %}
-
-<script>
-    const updateListUrl = "{{ url_for('design.update_list') }}";
-
-    // Toggle visibility of line numbers
-    function toggleLineNumbers(save = true) {
-        const show = document.getElementById('toggleLineNumbers').checked;
-        document.querySelectorAll('.line-number').forEach(el => {
-            el.classList.toggle('d-none', !show);
-        });
-
-        if (save) {
-            localStorage.setItem('showLineNumbers', show ? 'true' : 'false');
-        }
-    }
-
-    function toggleCodeOverlay() {
-        const overlay = document.getElementById("pythonCodeOverlay");
-        const toggleBtn = document.getElementById("codeToggleBtn");
-        overlay.classList.toggle("show");
-
-        // Change arrow icon
-        const icon = toggleBtn.querySelector("i");
-        icon.classList.toggle("bi-chevron-left");
-        icon.classList.toggle("bi-chevron-right");
-    }
-
-    // Restore state on page load
-    document.addEventListener('DOMContentLoaded', () => {
-        const savedState = localStorage.getItem('showLineNumbers');
-        const checkbox = document.getElementById('toggleLineNumbers');
-
-        if (savedState === 'true') {
-            checkbox.checked = true;
-        }
-
-        toggleLineNumbers(false);  // don't overwrite localStorage on load
-
-        checkbox.addEventListener('change', () => toggleLineNumbers());
-    });
-</script>
-
-
-<script src="{{ url_for('static', filename='js/sortable_design.js') }}"></script>
-
-{% endblock %}

ivoryos/routes/design/templates/design/experiment_run.html

@@ -1,558 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Design execution{% endblock %}
-
-{% block body %}
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.4.1/socket.io.js"></script>
-
-
-    {% if no_deck_warning and not dismiss %}
-{#      auto pop import when there is no deck#}
-        <script type="text/javascript">
-            function OpenBootstrapPopup() {
-                $("#importModal").modal('show');
-            }
-            window.onload = function () {
-                OpenBootstrapPopup();
-            };
-        </script>
-    {% endif %}
-
-    <div class="row">
-        {% if script['script'] or script['prep'] or script['cleanup'] %}
-            <div class="col-lg-6 col-sm-12" id="run-panel"  style="{{ 'display: none;'  if pause_status else '' }}">
-                <ul class="nav nav-tabs" id="myTabs" role="tablist">
-                    <li class="nav-item" role="presentation">
-                        <a class="nav-link {{ 'disabled' if config_list else '' }} {{ 'active' if not config_list else '' }}" id="tab1-tab" data-bs-toggle="tab" href="#tab1" role="tab" aria-controls="tab1" aria-selected="false">Repeat</a>
-                    </li>
-                    <li class="nav-item" role="presentation">
-                        <a class="nav-link {{ 'disabled' if not config_list else '' }} {{ 'active' if config_list else '' }}" id="tab4-tab" data-bs-toggle="tab" href="#tab4" role="tab" aria-controls="tab4" aria-selected="false">Configuration</a>
-                    </li>
-                    <li class="nav-item" role="presentation">
-                        <a class="nav-link {{ 'disabled' if not config_list or not return_list else '' }}" id="tab3-tab" data-bs-toggle="tab" href="#tab3" role="tab" aria-controls="tab3" aria-selected="false">Bayesian Optimization</a>
-                    </li>
-                </ul>
-                <div class="tab-content" id="myTabsContent">
-                    <div class="tab-pane fade {{ 'show active' if not config_list else '' }}" id="tab1" role="tabpanel" aria-labelledby="tab1-tab">
-                        <p><h5>Control panel:</h5></p>
-                        <form role="form" method='POST' name="run" action="{{url_for('design.experiment_run')}}">
-                            <div class="input-group mb-3">
-                                <label class="input-group-text" for="repeat">Repeat for </label>
-                                <input class="form-control" type="number" id="repeat" name="repeat" min="1" max="1000" value="1">
-                                <label class="input-group-text" for="repeat"> times</label>
-                            </div>
-                            <div class="input-group mb-3">
-                                <button class="form-control" type="submit" class="btn btn-dark">Run</button>
-                            </div>
-                        </form>
-                    </div>
-
-{#TODO#}
-<div class="tab-pane fade {{ 'show active' if config_list else '' }}" id="tab4" role="tabpanel" aria-labelledby="tab4-tab">
-    <!-- File Management Section -->
-    <div class="card mb-4">
-        <div class="card-header d-flex justify-content-between align-items-center">
-            <h6 class="mb-0"><i class="bi bi-file-earmark-text"></i> Configuration File</h6>
-            <small class="text-muted">
-                <a href="{{ url_for('design.download', filetype='configure') }}">
-                    <i class="bi bi-download"></i> Download Empty Template
-                </a>
-            </small>
-        </div>
-        <div class="card-body">
-            <div class="row g-3">
-                <!-- File Selection -->
-                <div class="col-md-6">
-                    <form name="filenameForm" id="filenameForm" method="GET" action="{{ url_for('design.experiment_run') }}" enctype="multipart/form-data">
-                        <div class="input-group">
-                            <label class="input-group-text"><i class="bi bi-folder2-open"></i></label>
-                            <select class="form-select" name="filename" id="filenameSelect" onchange="document.getElementById('filenameForm').submit();">
-                                <option {{ 'selected' if not filename else '' }} value="">-- Select existing file --</option>
-                                {% for config_file in config_file_list %}
-                                    <option {{ 'selected' if filename == config_file else '' }} value="{{ config_file }}">{{ config_file }}</option>
-                                {% endfor %}
-                            </select>
-                        </div>
-                    </form>
-                </div>
-
-                <!-- File Upload -->
-                <div class="col-md-6">
-                    <form method="POST" id="loadFile" name="loadFile" action="{{ url_for('design.upload') }}" enctype="multipart/form-data">
-                        <div class="input-group">
-                            <input class="form-control" name="file" type="file" accept=".csv" required="required" onchange="document.getElementById('loadFile').submit();">
-                        </div>
-                    </form>
-                </div>
-            </div>
-        </div>
-    </div>
-       <!-- Configuration Table -->
-
-
-
-    <div class="card mb-4">
-        <div class="card-header position-relative">
-            <div class="position-absolute top-50 end-0 translate-middle-y me-3">
-                <span id="saveStatus" class="badge bg-success" style="display: none;">
-                    <i class="bi bi-check-circle"></i> Auto-saved
-                </span>
-                <span id="modifiedStatus" class="badge bg-warning" style="display: none;">
-                    <i class="bi bi-pencil"></i> Modified
-                </span>
-            </div>
-        </div>
-        <div class="card-body p-0">
-            <form method="POST" name="online-config" id="online-config" action="{{url_for('design.experiment_run')}}">
-                <div class="table-responsive">
-                    <table id="dataInputTable" class="table table-striped table-hover mb-0">
-                        <thead class="table-dark">
-                        <tr>
-                            <th style="width: 40px;">#</th>
-                            {% for column in config_list %}
-                                <th>{{ column }}</th>
-                            {% endfor %}
-                            <th></th>
-                        </tr>
-                        </thead>
-                        <tbody id="tableBody">
-                        </tbody>
-                    </table>
-                </div>
-            <div class="card-footer">
-            <div class="d-flex justify-content-between align-items-center">
-                <div class="d-flex gap-2">
-                    <button type="button" class="btn btn-success" onclick="addRow()">
-                        <i class="bi bi-plus-circle"></i> Add Row
-                    </button>
-                    <button type="button" class="btn btn-warning" onclick="clearAllRows()">
-                        <i class="bi bi-trash"></i> Clear All
-                    </button>
-                    <button type="button" class="btn btn-info" onclick="resetToFile()" id="resetToFileBtn" style="display: none;">
-                        <i class="bi bi-arrow-clockwise"></i> Reset to File
-                    </button>
-                </div>
-                <button type="submit" name="online-config" class="btn btn-primary btn-lg">
-                    <i class="bi bi-play-circle"></i> Run
-                </button>
-            </div>
-            </div>
-            </form>
-        </div>
-        <!-- Config Preview (if loaded from file) -->
-        {% if config_preview %}
-            <div class="alert alert-info">
-                <small><i class="bi bi-info-circle"></i> {{ config_preview|length }} rows loaded from {{ filename }}</small>
-            </div>
-        {% endif %}
-    </div>
-</div>
-
-                    <div class="tab-pane fade" id="tab3" role="tabpanel" aria-labelledby="tab3-tab">
-                        <form method="POST" name="bo" action="{{ url_for('design.experiment_run') }}">
-                            <div class="container py-2">
-                                <!-- Parameters -->
-                                <h6 class="fw-bold mt-2 mb-1">Parameters</h6>
-                                {% for config in config_list %}
-                                    <div class="row align-items-center mb-2">
-                                        <div class="col-3 col-form-label-sm">
-                                            {{ config }}:
-                                        </div>
-                                        <div class="col-6">
-                                            <select class="form-select form-select-sm" id="{{config}}_type" name="{{config}}_type">
-                                                <option selected value="range">range</option>
-                                                <option value="choice">choice</option>
-                                                <option value="fixed">fixed</option>
-                                            </select>
-                                        </div>
-                                        <div class="col-3">
-                                            <input type="text" class="form-control form-control-sm" id="{{config}}_value" name="{{config}}_value" placeholder="1, 2, 3">
-                                        </div>
-                                    </div>
-                                {% endfor %}
-                                <!-- Objective -->
-                                <h6 class="fw-bold mt-3 mb-1">Objectives</h6>
-                                {% for objective in return_list %}
-                                    <div class="row align-items-center mb-2">
-                                        <div class="col-3 col-form-label-sm">
-                                            {{ objective }}:
-                                        </div>
-                                        <div class="col-6">
-                                            <select class="form-select form-select-sm" id="{{objective}}_min" name="{{objective}}_min">
-                                                <option selected>minimize</option>
-                                                <option>maximize</option>
-                                                <option>none</option>
-                                            </select>
-                                        </div>
-                                    </div>
-                                {% endfor %}
-                                <h6 class="fw-bold mt-3 mb-1">Budget</h6>
-                                <div class="input-group mb-3">
-                                    <label class="input-group-text" for="repeat">Max iteration </label>
-                                    <input class="form-control" type="number" id="repeat" name="repeat" min="1" max="1000" value="25">
-                                </div>
-                                {% if not no_deck_warning%}
-                                    <div class="input-group mb-3">
-                                        <button class="form-control" type="submit" name="bo">Run</button>
-                                    </div>
-                                {% endif %}
-                            </div>
-                        </form>
-                    </div>
-                </div>
-            </div>
-        {% else %}
-            <div class="col-lg-6 col-sm-12" id="placeholder-panel">
-            </div>
-        {% endif %}
-
-        <div class="col-lg-6 col-sm-12" id="code-panel" style="{{ '' if pause_status else 'display: none;'}}">
-            <p>
-                <h5>Progress：</h5>
-                {% if "prep" in line_collection.keys() %}
-                    {% set stype = "prep" %}
-                    <h6>Preparation：</h6>
-                    {% for code in line_collection["prep"] %}
-                        <pre style="margin: 0; padding: 0; line-height: 1;"><code class="python" id="{{ stype }}-{{ loop.index0 }}" >{{code}}</code></pre>
-                    {% endfor %}
-                {% endif %}
-                {% if "script" in line_collection.keys() %}
-                    {% set stype = "script" %}
-                    <h6>Experiment：</h6>
-                    {% for code in line_collection["script"] %}
-                        <pre style="margin: 0; padding: 0; line-height: 1;"><code class="python" id="{{ stype }}-{{ loop.index0 }}" >{{code}}</code></pre>
-                    {% endfor %}
-                {% endif %}
-                {% if "cleanup" in line_collection.keys() %}
-                    {% set stype = "cleanup" %}
-                    <h6>Cleanup：</h6>
-                    {% for code in line_collection["cleanup"] %}
-                        <pre style="margin: 0; padding: 0; line-height: 1;"><code class="python" id="{{ stype }}-{{ loop.index0 }}" >{{code}}</code></pre>
-                    {% endfor %}
-                {% endif %}
-            </p>
-        </div>
-        <div class="col-lg-6 col-sm-12 logging-panel">
-            <p>
-                <div class="p d-flex justify-content-between align-items-center">
-                    <h5>Progress：</h5>
-                    <div class="d-flex gap-2 ms-auto">
-                        <button id="pause-resume" class="btn btn-info text-white" data-bs-toggle="tooltip" title="Pause execution">
-                            {% if pause_status %}
-                                <i class="bi bi-play-circle"></i>
-                            {% else %}
-                                <i class="bi bi-pause-circle"></i>
-                            {% endif %}
-                        </button>
-                        <button id="abort-current" class="btn btn-danger text-white" data-bs-toggle="tooltip" title="Stop execution after current step">
-                            <i class="bi bi-stop-circle"></i>
-                        </button>
-                        <button id="abort-pending" class="btn btn-warning text-white" data-bs-toggle="tooltip" title="Stop execution after current iteration">
-                            <i class="bi bi-hourglass-split"></i>
-                        </button>
-                    </div>
-                </div>
-                <div class="text-muted mt-2">
-                    <small><strong>Note:</strong> The current step cannot be paused or stopped until it completes. </small>
-                </div>
-
-            <div class="progress" role="progressbar" aria-label="Animated striped example" aria-valuenow="10" aria-valuemin="0" aria-valuemax="100">
-                <div id="progress-bar-inner" class="progress-bar progress-bar-striped progress-bar-animated"></div>
-            </div>
-            <p><h5>Log：</h5></p>
-            <div id="logging-panel"></div>
-        </div>
-
-    </div>
-
-
-
-
-
-    <!-- Error Modal -->
-    <div class="modal fade" id="error-modal" tabindex="-1" aria-labelledby="errorModalLabel" aria-hidden="true">
-      <div class="modal-dialog">
-        <div class="modal-content">
-          <div class="modal-header">
-            <h5 class="modal-title" id="errorModalLabel">Error Detected</h5>
-            <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-          </div>
-          <div class="modal-body">
-            <p id="error-message">An error has occurred.</p>
-            <p>Do you want to continue execution or stop?</p>
-          </div>
-          <div class="modal-footer">
-              <button type="button" class="btn btn-primary" id="retry-btn" data-bs-dismiss="modal">Rerun Current Step</button>
-              <button type="button" class="btn btn-success" id="continue-btn" data-bs-dismiss="modal">Continue</button>
-              <button type="button" class="btn btn-danger" id="stop-btn" data-bs-dismiss="modal">Stop Execution</button>
-          </div>
-        </div>
-      </div>
-    </div>
-
-    <script src="{{ url_for('static', filename='js/socket_handler.js') }}"></script>
-    <script>
-        var rowCount = 0;
-        var configColumns = [
-            {% for column in config_list %}
-                '{{ column }}'{{ ',' if not loop.last else '' }}
-            {% endfor %}
-        ];
-        var configTypes = {
-            {% for column, type in config_type_list.items() %}
-                '{{ column }}': '{{ type }}'{{ ',' if not loop.last else '' }}
-            {% endfor %}
-        };
-
-        // State management
-        var originalFileData = null;
-        var isModifiedFromFile = false;
-        var saveTimeout = null;
-        var lastSavedData = null;
-
-        function addRow(data = null, skipSave = false) {
-            rowCount++;
-            var tableBody = document.getElementById("tableBody");
-            var newRow = tableBody.insertRow(-1);
-
-            // Row number cell
-            var rowNumCell = newRow.insertCell(-1);
-            rowNumCell.innerHTML = '<span class="badge bg-secondary">' + rowCount + '</span>';
-
-            // Data cells
-            configColumns.forEach(function(column, index) {
-                var cell = newRow.insertCell(-1);
-                var value = data && data[column] ? data[column] : '';
-                var placeholder = configTypes[column] || 'value';
-                cell.innerHTML = '<input type="text" class="form-control form-control-sm" name="' +
-                    column + '[' + rowCount + ']" value="' + value + '" placeholder="' + placeholder +
-                    '" oninput="onInputChange()" onchange="onInputChange()">';
-            });
-
-            // Action cell
-            var actionCell = newRow.insertCell(-1);
-            actionCell.innerHTML = '<button type="button" class="btn btn-sm btn-outline-danger" onclick="removeRow(this)" title="Remove row">' +
-                '<i class="bi bi-trash"></i></button>';
-
-            if (!skipSave) {
-                markAsModified();
-                debouncedSave();
-            }
-        }
-
-        function removeRow(button) {
-            var row = button.closest('tr');
-            row.remove();
-            updateRowNumbers();
-            markAsModified();
-            debouncedSave();
-        }
-
-        function updateRowNumbers() {
-            var tableBody = document.getElementById("tableBody");
-            var rows = tableBody.getElementsByTagName('tr');
-            for (var i = 0; i < rows.length; i++) {
-                var badge = rows[i].querySelector('.badge');
-                if (badge) {
-                    badge.textContent = i + 1;
-                }
-            }
-        }
-
-        function clearAllRows() {
-            if (confirm('Are you sure you want to clear all rows?')) {
-                var tableBody = document.getElementById("tableBody");
-                tableBody.innerHTML = '';
-                rowCount = 0;
-                markAsModified();
-                clearSavedData();
-                // Add 5 empty rows by default
-                for (let i = 0; i < 5; i++) {
-                    addRow(null, true);
-                }
-                debouncedSave();
-            }
-        }
-
-        function resetToFile() {
-            if (originalFileData && confirm('Reset to original file data? This will lose all manual changes.')) {
-                loadDataFromSource(originalFileData, false);
-                isModifiedFromFile = false;
-                updateStatusIndicators();
-                debouncedSave();
-            }
-        }
-
-        function onInputChange() {
-            markAsModified();
-            debouncedSave();
-        }
-
-        function markAsModified() {
-            if (originalFileData) {
-                isModifiedFromFile = true;
-                updateStatusIndicators();
-            }
-        }
-
-        function updateStatusIndicators() {
-            var modifiedStatus = document.getElementById('modifiedStatus');
-            var resetBtn = document.getElementById('resetToFileBtn');
-
-            if (isModifiedFromFile && originalFileData) {
-                modifiedStatus.style.display = 'inline-block';
-                resetBtn.style.display = 'inline-block';
-            } else {
-                modifiedStatus.style.display = 'none';
-                resetBtn.style.display = 'none';
-            }
-        }
-
-        function showSaveStatus() {
-            var saveStatus = document.getElementById('saveStatus');
-            saveStatus.style.display = 'inline-block';
-            setTimeout(function() {
-                saveStatus.style.display = 'none';
-            }, 2000);
-        }
-
-        function debouncedSave() {
-            clearTimeout(saveTimeout);
-            saveTimeout = setTimeout(function() {
-                saveFormData();
-                showSaveStatus();
-            }, 1000); // Save 1 second after user stops typing
-        }
-
-        function saveFormData() {
-            var formData = getCurrentFormData();
-            try {
-                sessionStorage.setItem('configFormData', JSON.stringify(formData));
-                sessionStorage.setItem('configModified', isModifiedFromFile.toString());
-                lastSavedData = formData;
-            } catch (e) {
-                console.warn('Could not save form data to sessionStorage:', e);
-            }
-        }
-
-        function getCurrentFormData() {
-            var tableBody = document.getElementById("tableBody");
-            var rows = tableBody.getElementsByTagName('tr');
-            var data = [];
-
-            for (var i = 0; i < rows.length; i++) {
-                var inputs = rows[i].getElementsByTagName('input');
-                var rowData = {};
-                var hasData = false;
-
-                for (var j = 0; j < inputs.length; j++) {
-                    var input = inputs[j];
-                    var name = input.name;
-                    if (name) {
-                        var columnName = name.substring(0, name.indexOf('['));
-                        rowData[columnName] = input.value;
-                        if (input.value.trim() !== '') {
-                            hasData = true;
-                        }
-                    }
-                }
-
-                if (hasData) {
-                    data.push(rowData);
-                }
-            }
-
-            return data;
-        }
-
-        function loadSavedData() {
-            try {
-                var savedData = sessionStorage.getItem('configFormData');
-                var savedModified = sessionStorage.getItem('configModified');
-
-                if (savedData) {
-                    var parsedData = JSON.parse(savedData);
-                    isModifiedFromFile = savedModified === 'true';
-                    return parsedData;
-                }
-            } catch (e) {
-                console.warn('Could not load saved form data:', e);
-            }
-            return null;
-        }
-
-        function clearSavedData() {
-            try {
-                sessionStorage.removeItem('configFormData');
-                sessionStorage.removeItem('configModified');
-            } catch (e) {
-                console.warn('Could not clear saved data:', e);
-            }
-        }
-
-        function loadDataFromSource(data, isFromFile = false) {
-            // Clear existing rows
-            var tableBody = document.getElementById("tableBody");
-            tableBody.innerHTML = '';
-            rowCount = 0;
-
-            // Add rows with data
-            data.forEach(function(rowData) {
-                addRow(rowData, true);
-            });
-
-            // Add a few empty rows for additional input
-            for (let i = 0; i < 3; i++) {
-                addRow(null, true);
-            }
-
-            if (isFromFile) {
-                originalFileData = JSON.parse(JSON.stringify(data)); // Deep copy
-                isModifiedFromFile = false;
-                clearSavedData(); // Clear saved data when loading from file
-            }
-
-            updateStatusIndicators();
-        }
-
-        function loadConfigData() {
-            // Check for saved form data first
-            var savedData = loadSavedData();
-
-            {% if config_preview %}
-                var fileData = {{ config_preview | tojson | safe }};
-                originalFileData = JSON.parse(JSON.stringify(fileData)); // Deep copy
-
-                if (savedData && savedData.length > 0) {
-                    // Load saved data if available
-                    loadDataFromSource(savedData, false);
-                    console.log('Loaded saved form data');
-                } else {
-                    // Load from file
-                    loadDataFromSource(fileData, true);
-                    console.log('Loaded file data');
-                }
-            {% else %}
-                if (savedData && savedData.length > 0) {
-                    // Load saved data
-                    loadDataFromSource(savedData, false);
-                    console.log('Loaded saved form data');
-                } else {
-                    // Add default empty rows
-                    for (let i = 0; i < 5; i++) {
-                        addRow(null, true);
-                    }
-                }
-            {% endif %}
-        }
-
-        // Handle page unload
-        window.addEventListener('beforeunload', function() {
-            saveFormData();
-        });
-
-        // Initialize table when page loads
-        document.addEventListener("DOMContentLoaded", function() {
-            loadConfigData();
-        });
-    </script>
-{% endblock %}

ivoryos/routes/main/main.py

@@ -1,42 +0,0 @@
-from flask import Blueprint, render_template, current_app
-from flask_login import login_required
-from ivoryos.version import __version__ as ivoryos_version
-
-main = Blueprint('main', __name__, template_folder='templates/main')
-
-@main.route("/")
-@login_required
-def index():
-    """
-    .. :quickref: Home page; ivoryos home page
-
-    Home page for all available routes
-
-    .. http:get:: /
-
-    """
-    off_line = current_app.config["OFF_LINE"]
-    return render_template('home.html', off_line=off_line, version=ivoryos_version)
-
-
-@main.route("/help")
-def help_info():
-    """
-    .. :quickref: Help page; ivoryos info page
-
-    static information page
-
-    .. http:get:: /help
-
-    """
-    sample_deck = """
-    from vapourtec.sf10 import SF10
-
-    # connect SF10 pump
-    sf10 = SF10(device_port="com7")
-
-    # start ivoryOS
-    from ivoryos.app import ivoryos
-    ivoryos(__name__)
-    """
-    return render_template('help.html', sample_deck=sample_deck)

ivoryos/routes/main/templates/main/help.html

@@ -1,141 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Documentation {% endblock %}
-
-{% block body %}
-    <h2>Documentations:</h2>
-    <div class="accordion accordion-flush" id="helpPage" >
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#overall" aria-expanded="false" aria-controls="helpPageControl">
-                    General information - What is ivoryOS?
-                </button>
-            </h2>
-            <div id="overall" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    <p>
-                        This web app aims to ease up the control of any Python-based self-driving labs (SDLs) by extracting and displaying functions and parameters for initialized modules dynamically.
-                        The modules can be hardware API, high-level functions, or experiment workflow. This can potentially be used for general visual programming purposes.
-                    </p>
-{#                    <p>Controller: single instrument mode and multi-instrument interface.</p>#}
-{#                    <p>Workflow editor: automation workflow editor#}
-                </div>
-            </div>
-        </div>
-{#        <p>In the Controller tab, you can connect any instrument or instruments from a complete automation deck. The GUI will parse and show available functions and prompt user to the input argument values if need.</p>#}
-{#        <p>In the Build Workflow tab, you can edit your own automation workflow from scratch or from the workflow library, where stores the ongoing projects and some basic example workflows.</p>#}
-
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#connect-device" aria-expanded="false" aria-controls="helpPageControl">
-                    General information - start ivoryOS from script
-                </button>
-            </h2>
-            <div id="connect-device" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    <pre ><code class="python" >{{ sample_deck }}</code></pre>
-                </div>
-            </div>
-        </div>
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#library" aria-expanded="false" aria-controls="helpPageControl">
-                    Script Editor - Library
-                </button>
-            </h2>
-            <div id="library" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    <p>In "Library" Tab, the interactive database displays all workflow information</p>
-                    <p>On top of the library page, you can click filter to choose your desired deck out of other automation platforms. You can also search for experiment keyword on the right</p>
-                    <p>Note that you can edit/delete your own workflow anytime, but in case you would like to adapt other author's workflow, you need to save as your own in a different file name.</p>
-                </div>
-            </div>
-        </div>
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#editor" aria-expanded="false" aria-controls="helpPageControl">
-                    Script Editor - How to use script editor?
-                </button>
-            </h2>
-            <div id="editor" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    <p>You can browse and load other's workflow in "Library" Tab or go to "Build Workflow" Tab to build from scratch.</p>
-                    <p>On the workflow canvas, there are three coding blocks: Prep, Experiment and Clean up. As the names indicated, the Prep and Clean up are steps taken prior and after to the main experiment, they cannot be repeated. On the other hand, the Experiment section can be repeated by a designated times or <a href="#config">a .csv configuration file</a></p>
-                    <p>On the left panel, you can choose the deck profile on the top, and browse deck action and builtin python functions. Click to input your argument and add to the canvas, then drag the action to change their order.</p>
-                    <img src="{{url_for('static', filename='gui_annotation/Slide1.PNG')}}">
-                </div>
-            </div>
-        </div>
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#editor-advanced" aria-expanded="false" aria-controls="helpPageControl">
-                    Script Editor - How to save data and configure reaction?
-                </button>
-            </h2>
-            <div id="editor-advanced" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-
-                    <img src="{{url_for('static', filename='gui_annotation/Slide2.PNG')}}">
-                </div>
-            </div>
-        </div>
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#config" aria-expanded="false" aria-controls="helpPageControl">
-                    Run my script - How to execute my workflow?
-                </button>
-            </h2>
-            <div id="config" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    <p>For workflow with no parameters, simply input repeat times to run.</p>
-                    <p>To configure your workflow, if there are less or equal than 5 parameters, one can use the web form or import a csv file.
-                    For workflow with more than 5 parameters, web form is not available.</p>
-                    <p>If there is any output, Bayesian Optimization will be available for adaptive experimentation. Note that the outputs need to be numeric values. </p>
-{#                    <img src="{{url_for('static', filename='gui_annotation/Slide3.PNG')}}">#}
-                </div>
-            </div>
-        </div>
-
-
-
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#controller" aria-expanded="false" aria-controls="helpPageControl">
-                    Control - How to use device interface?
-                </button>
-            </h2>
-            <div id="controller" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    <p>The function cards are draggable for customized layout. The hidden icon is to remove functions from the interface. </p>
-{#                    <p>(1)     Import a python script where devices are connected using Deck Deice tab (e.g. applied to a complete automation deck with a deck.py file).</p>#}
-{#                    <p>(2)     Connect devices in the web app using New Deice tab. There are builtin instruments, but you can always import your own API.</p>#}
-                </div>
-            </div>
-        </div>
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#deck" aria-expanded="false" aria-controls="helpPageControl">
-                    Control - Connect new devices
-                </button>
-            </h2>
-            <div id="deck" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    <p>When temporarily connecting instruments, New device -> New connection -> Import API. Use absolute path of your Python API file.
-                        Then enter required info (e.g. COM port) to connect a device.</p>
-                </div>
-            </div>
-        </div>
-        <div class="accordion-item">
-            <h2 class="accordion-header">
-                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#install" aria-expanded="false" aria-controls="helpPageControl">
-                    Supports
-                </button>
-            </h2>
-            <div id="install" class="accordion-collapse collapse" data-bs-parent="#helpPage">
-                <div class="accordion-body">
-                    This is project is a work in progress. In case of any bugs or suggestions, reach out to Ivory: ivoryzhang@chem.ubc.ca or create an issue on GitLab:
-                    <a href="https://gitlab.com/heingroup/ivoryos">https://gitlab.com/heingroup/ivoryos</a>.
-                </div>
-            </div>
-        </div>
-    </div>
-{% endblock %}

ivoryos/routes/main/templates/main/home.html

@@ -1,103 +0,0 @@
-{% extends 'base.html' %}
-{% block title %}IvoryOS | Welcome{% endblock %}
-
-{% block body %}
-    <div class="p-4">
-        <h1 class="mb-4" style="font-size: 3rem; font-weight: bold; color: #343a40;">
-            Welcome
-        </h1>
-        <p class="mb-5">Version: {{ version }}</p>
-
-        {% if enable_design %}
-        <!-- Workflow Design Section -->
-        <h4 class="mb-3">Workflow Design</h4>
-        <div class="row">
-            <div class="col-lg-6 mb-3 d-flex align-items-stretch">
-                <div class="card rounded shadow-sm flex-fill">
-                    <div class="card-body">
-                        <h5 class="card-title">
-                            <i class="bi bi-folder2-open me-2"></i>Browse designs
-                        </h5>
-                        <p class="card-text">View all saved workflows from the database.</p>
-                        <a href="{{ url_for('database.load_from_database') }}" class="stretched-link"></a>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-6 mb-3 d-flex align-items-stretch">
-                <div class="card rounded shadow-sm flex-fill">
-                    <div class="card-body">
-                        <h5 class="card-title">
-                            <i class="bi bi-pencil-square me-2"></i>Edit designs
-                        </h5>
-                        <p class="card-text">Create or modify workflows using available functions.</p>
-                        <a href="{{ url_for('design.experiment_builder') }}" class="stretched-link"></a>
-                    </div>
-                </div>
-            </div>
-        </div>
-        {% endif %}
-
-        <!-- Workflow Control and Monitor Section -->
-        <h4 class="mt-5 mb-3">Workflow Control & Monitoring</h4>
-        <div class="row">
-            <!-- Always visible: Experiment data -->
-            <div class="col-lg-6 mb-3 d-flex align-items-stretch">
-                <div class="card rounded shadow-sm flex-fill">
-                    <div class="card-body">
-                        <h5 class="card-title">
-                            <i class="bi bi-graph-up-arrow me-2"></i>Experiment data
-                        </h5>
-                        <p class="card-text">Browse workflow logs and output data.</p>
-                        <a href="{{ url_for('database.list_workflows') }}" class="stretched-link"></a>
-                    </div>
-                </div>
-            </div>
-
-            <!-- Conditionally visible: Run current workflow -->
-            {% if not off_line %}
-            <div class="col-lg-6 mb-3 d-flex align-items-stretch">
-                <div class="card rounded shadow-sm flex-fill">
-                    <div class="card-body">
-                        <h5 class="card-title">
-                            <i class="bi bi-play-circle me-2"></i>Run current workflow
-                        </h5>
-                        <p class="card-text">Execute workflows with configurable parameters.</p>
-                        <a href="{{ url_for('design.experiment_run') }}" class="stretched-link"></a>
-                    </div>
-                </div>
-            </div>
-            {% endif %}
-        </div>
-
-
-
-        {% if not off_line %}
-        <!-- Direct Control Section -->
-        <h4 class="mt-5 mb-3">Direct Control</h4>
-        <div class="row">
-            <div class="col-lg-6 mb-3 d-flex align-items-stretch">
-                <div class="card rounded shadow-sm flex-fill">
-                    <div class="card-body">
-                        <h5 class="card-title">
-                            <i class="bi bi-toggle-on me-2"></i>Direct control
-                        </h5>
-                        <p class="card-text">Manually control individual components.</p>
-                        <a href="{{ url_for('control.deck_controllers') }}" class="stretched-link"></a>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-6 mb-3 d-flex align-items-stretch">
-                <div class="card rounded shadow-sm flex-fill">
-                    <div class="card-body">
-                        <h5 class="card-title">
-                            <i class="bi bi-usb-plug me-2"></i>Connect a new device
-                        </h5>
-                        <p class="card-text">Add new hardware temporarily or for testing purposes.</p>
-                        <a href="{{ url_for('control.controllers_home') }}" class="stretched-link"></a>
-                    </div>
-                </div>
-            </div>
-        </div>
-        {% endif %}
-    </div>
-{% endblock %}

ivoryos/static/js/overlay.js

@@ -1,12 +0,0 @@
-function addOverlayToButtons(buttonIds) {
-    buttonIds.forEach(function(buttonId) {
-        document.getElementById(buttonId).addEventListener('submit', function() {
-            // Display the overlay
-            document.getElementById('overlay').style.display = 'block';
-            document.getElementById('overlay-text').innerText = `Processing ${buttonId}...`;
-        });
-    });
-}
-
-// buttonIds should be set dynamically in your HTML template
-addOverlayToButtons(buttonIds);

ivoryos/static/js/socket_handler.js

@@ -1,125 +0,0 @@
-document.addEventListener("DOMContentLoaded", function() {
-    var socket = io.connect('http://' + document.domain + ':' + location.port);
-    socket.on('connect', function() {
-        console.log('Connected');
-    });
-    socket.on('progress', function(data) {
-        var progress = data.progress;
-        console.log(progress);
-        // Update the progress bar's width and appearance
-        var progressBar = document.getElementById('progress-bar-inner');
-        progressBar.style.width = progress + '%';
-        progressBar.setAttribute('aria-valuenow', progress);
-        const runPanel = document.getElementById("run-panel");
-        const codePanel = document.getElementById("code-panel");
-        if (progress === 1) {
-            if (runPanel) runPanel.style.display = "none";
-            if (codePanel) {
-                codePanel.style.display = "block";
-                codePanel.scrollIntoView({ behavior: "smooth" });
-            }
-            progressBar.classList.remove('bg-success');
-            progressBar.classList.remove('bg-danger');
-            progressBar.classList.add('progress-bar-animated');
-        }
-        if (progress === 100) {
-            // Remove animation and set green color when 100% is reached
-            progressBar.classList.remove('progress-bar-animated');
-            progressBar.classList.add('bg-success'); // Bootstrap class for green color
-            setTimeout(() => {
-                if (runPanel) runPanel.style.display = "block";
-                if (codePanel) codePanel.style.display = "none";
-            }, 1000);  // Small delay to let users see the completion
-        }
-    });
-
-    socket.on('error', function(errorData) {
-        console.error("Error received:", errorData);
-        var progressBar = document.getElementById('progress-bar-inner');
-
-        progressBar.classList.remove('bg-success');
-        progressBar.classList.add('bg-danger'); // Red color for error
-                // Show error modal
-        var errorModal = new bootstrap.Modal(document.getElementById('error-modal'));
-        document.getElementById('error-message').innerText = "An error occurred: " + errorData.message;
-        errorModal.show();
-
-    });
-
-    // Handle Pause/Resume Button
-    document.getElementById('pause-resume').addEventListener('click', function() {
-        socket.emit('pause');
-        console.log('Pause/Resume is toggled.');
-        var button = this;
-        var icon = button.querySelector("i");
-
-        // Toggle Pause and Resume
-        if (icon.classList.contains("bi-pause-circle")) {
-            icon.classList.remove("bi-pause-circle");
-            icon.classList.add("bi-play-circle");
-            button.innerHTML = '<i class="bi bi-play-circle"></i>';
-            button.setAttribute("title", "Resume execution");
-        } else {
-            icon.classList.remove("bi-play-circle");
-            icon.classList.add("bi-pause-circle");
-            button.innerHTML = '<i class="bi bi-pause-circle"></i>';
-            button.setAttribute("title", "Pause execution");
-        }
-    });
-
-    // Handle Modal Buttons
-    document.getElementById('continue-btn').addEventListener('click', function() {
-        socket.emit('pause');  // Resume execution
-        console.log("Execution resumed.");
-    });
-
-    document.getElementById('retry-btn').addEventListener('click', function() {
-        socket.emit('retry');  // Resume execution
-        console.log("Execution resumed, retrying.");
-    });
-
-    document.getElementById('stop-btn').addEventListener('click', function() {
-        socket.emit('pause');  // Resume execution
-        socket.emit('abort_current');  // Stop execution
-        console.log("Execution stopped.");
-
-        // Reset UI back to initial state
-        document.getElementById("code-panel").style.display = "none";
-        document.getElementById("run-panel").style.display = "block";
-    });
-
-    socket.on('log', function(data) {
-        var logMessage = data.message;
-        console.log(logMessage);
-        $('#logging-panel').append(logMessage + "<br>");
-        $('#logging-panel').scrollTop($('#logging-panel')[0].scrollHeight);
-    });
-
-    document.getElementById('abort-pending').addEventListener('click', function() {
-        var confirmation = confirm("Are you sure you want to stop after this iteration?");
-        if (confirmation) {
-            socket.emit('abort_pending');
-            console.log('Abort action sent to server.');
-        }
-    });
-    document.getElementById('abort-current').addEventListener('click', function() {
-        var confirmation = confirm("Are you sure you want to stop after this step?");
-        if (confirmation) {
-            socket.emit('abort_current');
-            console.log('Stop action sent to server.');
-    }
-    });
-
-    socket.on('execution', function(data) {
-        // Remove highlighting from all lines
-        document.querySelectorAll('pre code').forEach(el => el.style.backgroundColor = '');
-
-        // Get the currently executing line and highlight it
-        let executingLine = document.getElementById(data.section);
-        if (executingLine) {
-            executingLine.style.backgroundColor = '#cce5ff'; // Highlight
-            executingLine.style.transition = 'background-color 0.3s ease-in-out';
-
-        }
-    });
-});

ivoryos/static/js/sortable_card.js

@@ -1,24 +0,0 @@
-$(function() {
-    $("#sortable-grid").sortable({
-        items: ".card",
-        cursor: "move",
-        opacity: 0.7,
-        revert: true,
-        placeholder: "ui-state-highlight",
-        start: function(event, ui) {
-            ui.placeholder.height(ui.item.height());
-        },
-        update: function() {
-            const newOrder = $("#sortable-grid").sortable("toArray");
-            $.ajax({
-                url: saveOrderUrl,  // saveOrderUrl should be set dynamically in your HTML template
-                method: 'POST',
-                contentType: 'application/json',
-                data: JSON.stringify({ order: newOrder }),
-                success: function() {
-                    console.log('Order saved');
-                }
-            });
-        }
-    }).disableSelection();
-});

ivoryos/static/js/sortable_design.js

@@ -1,105 +0,0 @@
-$(document).ready(function () {
-    let dropTargetId = ""; // Store the ID of the drop target
-
-    $("#list ul").sortable({
-        cancel: ".unsortable",
-        opacity: 0.8,
-        cursor: "move",
-        placeholder: "drop-placeholder",
-        update: function () {
-            var item_order = [];
-            $("ul.reorder li").each(function () {
-                item_order.push($(this).attr("id"));
-            });
-            var order_string = "order=" + item_order.join(",");
-
-            $.ajax({
-                method: "POST",
-                url: updateListUrl,
-                data: order_string,
-                cache: false,
-                success: function (data) {
-                    $("#response").html(data);
-                    $("#response").slideDown("slow");
-                    window.location.href = window.location.href;
-                }
-            });
-        }
-    });
-
-    // Make Entire Accordion Item Draggable
-    $(".accordion-item").on("dragstart", function (event) {
-        let formHtml = $(this).find(".accordion-body").html(); // Get the correct form
-        event.originalEvent.dataTransfer.setData("form", formHtml || ""); // Store form HTML
-        event.originalEvent.dataTransfer.setData("action", $(this).find(".draggable-action").data("action"));
-        event.originalEvent.dataTransfer.setData("id", $(this).find(".draggable-action").attr("id"));
-
-        $(this).addClass("dragging");
-    });
-
-
-    $("#list ul, .canvas").on("dragover", function (event) {
-        event.preventDefault();
-        let $target = $(event.target).closest("li");
-
-        // If we're over a valid <li> element in the list
-        if ($target.length) {
-            dropTargetId = $target.attr("id") || ""; // Store the drop target ID
-
-            $(".drop-placeholder").remove(); // Remove existing placeholders
-            $("<li class='drop-placeholder'></li>").insertBefore($target); // Insert before the target element
-        } else if (!$("#list ul").children().length && $(this).hasClass("canvas")) {
-            $(".drop-placeholder").remove();  // Remove any placeholder
-            // $("#list ul").append("<li class='drop-placeholder'></li>"); // Append placeholder to canvas
-        } else {
-            dropTargetId = "";  // Append placeholder to canvas
-        }
-    });
-
-    $("#list ul, .canvas").on("dragleave", function () {
-        $(".drop-placeholder").remove(); // Remove placeholder on leave
-    });
-
-    $("#list ul, .canvas").on("drop", function (event) {
-        event.preventDefault();
-
-        var actionName = event.originalEvent.dataTransfer.getData("action");
-        var actionId = event.originalEvent.dataTransfer.getData("id");
-        var formHtml = event.originalEvent.dataTransfer.getData("form"); // Retrieve form HTML
-        let listLength = $("ul.reorder li").length;
-        dropTargetId = dropTargetId || listLength + 1;  // Assign a "last" ID or unique identifier
-        $(".drop-placeholder").remove();
-            // Trigger the modal with the appropriate action
-        triggerModal(formHtml, actionName, actionId, dropTargetId);
-
-    });
-
-    // Function to trigger the modal (same for both buttons and accordion items)
-    function triggerModal(formHtml, actionName, actionId, dropTargetId) {
-        if (formHtml && formHtml.trim() !== "") {
-            var $form = $("<div>").html(formHtml); // Convert HTML string to jQuery object
-
-            // Create a hidden input for the drop target ID
-            var $hiddenInput = $("<input>")
-                .attr("type", "hidden")
-                .attr("name", "drop_target_id")
-                .attr("id", "dropTargetInput")
-                .val(dropTargetId);
-
-            // Insert before the submit button
-            $form.find("button[type='submit']").before($hiddenInput);
-
-            $("#modalFormFields").empty().append($form.children());
-            $("#dropModal").modal("show"); // Show modal
-
-            // Store and display drop target ID in the modal
-            $("#modalDropTarget").text(dropTargetId || "N/A");
-
-            $("#modalFormFields").data("action-id", actionId);
-            $("#modalFormFields").data("action-name", actionName);
-            $("#modalFormFields").data("drop-target-id", dropTargetId);
-        } else {
-            console.error("Form HTML is undefined or empty!");
-        }
-    }
-});

ivoryos/static/style.css

@@ -1,211 +0,0 @@
-.login {
-    width: 500px;
-    padding: 8% 0 0;
-    margin: auto;
-    align-content: center;
-}
-.card{
-    display: flex;
-    justify-content: flex-end;
-    cursor: move;
-    border: none;
-    transition: transform 0.3s ease, box-shadow 0.3s ease;
-
-}
-
-.card a {
-    text-decoration: none;
-}
-.card-title {
-    color: #007bff; /* Bootstrap primary color */
-}
-.grid-container {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(350px, 400px));
-    gap: 25px;
-    padding: 10px;
-}
-.navbar-nav {
-    font-size: larger;
-}
-.navbar-nav li{
-    margin-right:10px;
-    margin-left:10px;
-}
-
-.canvas {
-    height: 70vh;
-    overflow: hidden;
-    overflow-y: scroll;
-    background: #e8e8cd;
-    background-size: 20px 20px;
-    background-image: radial-gradient(circle, cadetblue 1px, rgba(0, 0, 0, 0) 1px);
-}
-
-.canvas content{
-    margin-top: 10px;
-}
-body {
-    padding-top: 100px;
-    background-color: #f8f9fa; /* Light grey background */
-    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-}
-/*.run-panel-row-height {*/
-/*    height: 80vh;*/
-/*}*/
-pre {
-  tab-size: 4;
-}
-.scroll-column{
-  height: 90vh;
-    overflow: hidden;
-  overflow-y: scroll;
-}
-
-label {
-    display:block
-}
-
-.scroll {
-    overflow: auto;
-    -webkit-overflow-scrolling: touch; /* enables momentum-scrolling on iOS */
-    position: absolute;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-}
-
-
-/*Remove the scrollbar from Chrome, Safari, Edge and IE*/
-::-webkit-scrollbar {
-    background: transparent;
-}
-
-* {
-  -ms-overflow-style: none !important;
-}
-.script-table{
-    background: white;
-    width: fit-content;
-}
-.script-table td {
-    border-bottom: none;
-    border-top: cadetblue;
-}
-.script-table th{
-    border-top: cadetblue;
-    border-bottom: none;
-}
-
-.bottom-button {
-    position: absolute;
-    bottom: 20px;
-}
-
-hr.vertical {
-    width: 5px;
-    height: 100%;
-    display: inline-block;
-  /* or height in PX */
-}
-.list-group a {
-    text-align: left;
-}
-
-.tray input[type="checkbox"]:checked + label{
-    background: radial-gradient(circle, white 40%, midnightblue, dodgerblue 43%);
-}
-
-.btn-vial{
-    height: 50px;
-    width: 50px;
-    border-radius: 50%;
-    background: lightgray;
-    margin-right: 10px;
-    margin-top: 10px;
-    /*text-align: center;*/
-
-}
-
-.tray {
-    width: 70px;
-    height: 70px;
-    display: inline-block;
-    background: darkgrey;
-    /*text-align:center;*/
-    vertical-align: middle;
-}
-
-.disabled-link {
-  pointer-events: none;
-    color: currentColor;
-  cursor: not-allowed;
-  opacity: 0.5;
-  text-decoration: none;
-}
-
-
-.controller-card a {
-    text-decoration: none;
-}
-
-#logging-panel {
-    flex-grow: 1;
-    height: 50vh;
-    overflow-y: auto;
-    background-color: #f5f5f5;
-    padding: 10px;
-}
-
-.dropdown:hover .dropdown-menu {
-  display: block;
-}
-
-#reorder {
-  overflow-y: scroll;
-  -webkit-overflow-scrolling: touch;
-}
-
-.accordion-item.design-control .accordion-button.collapsed {
-    background-color:#c1f2f1 !important;
-}
-.accordion-item.design-control .accordion-button {
-    background-color:#b3dad9 !important;
-}
-.accordion-item.design-control .accordion-button:hover {
-    background-color:#b3dad9 !important;
-}
-
-.accordion-item.text-to-code .accordion-button.collapsed {
-    background-color: #cdc1f2 !important;
-}
-.accordion-item.text-to-code .accordion-button {
-    background-color: #cdc1f2 !important;
-}
-.accordion-item.text-to-code .accordion-button:hover {
-    background-color: #b8afdc !important;
-}
-.overlay {
-    position: fixed;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    background-color: rgba(0, 0, 0, 0.5);
-    display: none;
-    z-index: 1000;
-    text-align: center;
-    color: white;
-    font-size: 24px;
-    padding-top: 20%;
-}
-.drop-placeholder {
-    height: 2px !important;  /* Keep it very thin */
-    min-height: 2px !important;
-    margin: 0 !important;
-    padding: 0 !important;
-    background: rgba(0, 0, 0, 0.2); /* Slight visibility */
-    border-radius: 2px;
-    list-style: none; /* Remove any default list styling */
-}

ivoryos/templates/base.html

@@ -1,157 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>{% block title %}{% endblock %}</title>
-    {#bootstrap#}
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha2/dist/css/bootstrap.min.css" integrity="sha384-aFq/bzH65dt+w6FI2ooMVUpc+21e0SRygnTpmBvdBgSdnuTN7QbdgL+OapgHtvPp" crossorigin="anonymous">
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.css">
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
-    {#static#}
-    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
-    <link rel="shortcut icon" href="{{ url_for('static', filename='favicon.ico') }}" type="image/x-icon">
-    {#for python code displaying#}
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/default.min.css">
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha2/dist/js/bootstrap.bundle.min.js" integrity="sha384-qKXV1j0HvMUeCBQ+QVp7JcfGl760yU08IQ+GpUo5hlbpg51QRiuqHAJz8+BrxE/N" crossorigin="anonymous"></script>
-    <script>hljs.highlightAll();</script>
-    {#drag design#}
-    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.0/jquery.min.js"></script>
-    {#drag card#}
-    <script src="https://code.jquery.com/ui/1.12.1/jquery-ui.js"></script>
-</head>
-<body>
-    <nav class="navbar navbar-expand-lg navbar-light bg-light fixed-top">
-        <div class= "container">
-{#            {{ module_config }}#}
-            <a class="navbar-brand" href="{{ url_for('main.index') }}">
-                <img src="{{url_for('static', filename='logo.webp')}}" alt="Logo" height="60" class="d-inline-block align-text-bottom">
-            </a>
-            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
-                <span class="navbar-toggler-icon"></span>
-            </button>
-
-            <div class="collapse navbar-collapse" id="navbarSupportedContent">
-                <ul class="navbar-nav mr-auto">
-                    <li class="nav-item">
-                        <a class="nav-link" href="{{ url_for('main.index') }}" aria-current="page">Home</a>
-                    </li>
-                    {% if enable_design %}
-                        <li class="nav-item">
-                            <a class="nav-link" href="{{ url_for('database.load_from_database') }}" aria-current="page">Library</a>
-                        </li>
-                        <li class="nav-item">
-                            <a class="nav-link" href="{{ url_for('design.experiment_builder') }}">Design</a>
-                        </li>
-                        <li class="nav-item">
-                            <a class="nav-link" href="{{ url_for('design.experiment_run') }}">Compile/Run</a>
-                        </li>
-                        <li class="nav-item">
-                            <a class="nav-link" href="{{ url_for('database.list_workflows') }}">Data</a>
-                        </li>
-                    {% endif %}
-
-                    <li class="nav-item">
-                        <a class="nav-link" href="{{ url_for('control.deck_controllers') }}">Devices</a></li>
-                    </li>
-{#                    <li class="nav-item">#}
-{#                        <a class="nav-link" href="{{ url_for('control.controllers_home') }}">Temp Devices</a></li>#}
-{#                    </li>#}
-{#                    <li class="nav-item">#}
-{#                        <a class="nav-link" href="{{ url_for('main.help_info') }}">About</a>#}
-{#                    </li>#}
-                    {% if plugins %}
-                        {% for plugin in plugins %}
-                            <li class="nav-item">
-                                <a class="nav-link" href="{{ url_for(plugin+'.main') }}">{{ plugin.capitalize() }}</a></li>
-                            </li>
-                        {% endfor %}
-                    {% endif %}
-                </ul>
-                <ul class="navbar-nav ms-auto">
-
-                    {% if session["user"] %}
-                        <div class="dropdown">
-                            <li class="nav-item " aria-expanded="false"><i class="bi bi-person-circle"></i> {{ session["user"] }}</li>
-                            <ul class="dropdown-menu">
-                                <li><a class="dropdown-item" href="{{ url_for("auth.logout") }}" role="button" aria-expanded="false">Logout</a></li>
-                            </ul>
-
-                        </div>
-                    {% else %}
-                        <li class="nav-item">
-                            <a class="nav-link" href="{{ url_for("auth.login") }}">Login</a>
-                        </li>
-                    {% endif %}
-{#                    <li class="nav-item">#}
-{#                        <a class="nav-link"href="{{ url_for("signup") }}">Signup</a>#}
-{#                    </li>#}
-                </ul>
-            </div>
-        </div>
-    </nav>
-
-    <div class= "container">
-        <div class="flash">
-            {% with messages = get_flashed_messages() %}
-                {% if messages %}
-                <div class="alert alert-warning">
-                    Message:
-                    {% for message in messages %}
-                        <div >
-                            {{ message|safe }}
-                        </div>
-                    {% endfor %}
-                </div>
-                {% endif %}
-            {% endwith %}
-        </div>
-        {% block body %}{% endblock %}
-    </div>
-
-    <div class="modal fade" id="importModal" tabindex="-1" aria-labelledby="importModal" aria-hidden="true" >
-        <div class="modal-dialog">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h1 class="modal-title fs-5" id="importModal">Import deck by file path</h1>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-                </div>
-                <form method="POST" action="{{ url_for('control.import_deck') }}" enctype="multipart/form-data">
-                    <div class="modal-body">
-                        <h5>from connection history</h5>
-                        <div class="form-group">
-                            <select class="form-select" name="filepath">
-                            <option disabled selected value> -- select an option -- </option>
-                            {% for connection in history %}
-                                <option style="overflow-wrap: break-word;" name="filepath" id="filepath" value="{{connection}}">{{connection}}</option>
-                            {% endfor %}
-{#                            <option>clear history</option>#}
-                            </select>
-                        </div>
-                        <h5>input manually</h5>
-                        <div class="input-group mb-3">
-                            <label class="input-group-text" for="filepath">File Path:</label>
-                            <input type="text" class="form-control" name="filepath" id="filepath">
-                        </div>
-                        <div class="input-group mb-3">
-                            <div class="form-check">
-                                <input type="checkbox" class="form-check-input" id="update" name="update" value="update">
-                                <label class="form-check-label" for="update">Update editor config</label>
-                            </div>
-                        </div>
-
-                        <div class="modal-footer">
-                            <div class="form-check">
-                                <input type="checkbox" class="form-check-input" id="dismiss" name="dismiss" value="dismiss">
-                                <label class="form-check-label" for="dismiss">Don't remind me</label>
-                            </div>
-                            <button type="button" class="btn btn-secondary" data-bs-dismiss="modal"> Close </button>
-                            <button type="submit"  class="btn btn-primary"> Save </button>
-                        </div>
-                    </div>
-                </form>
-            </div>
-        </div>
-    </div>
-</body>
-</html>

ivoryos/utils/bo_campaign.py

@@ -1,87 +0,0 @@
-from ivoryos.utils.utils import install_and_import
-
-
-def ax_init_form(data, arg_types):
-    """
-    create Ax campaign from the web form input
-    :param data:
-    """
-    install_and_import("ax", "ax-platform")
-    parameter, objectives = ax_wrapper(data, arg_types)
-    from ax.service.ax_client import AxClient
-    ax_client = AxClient()
-    ax_client.create_experiment(parameter, objectives=objectives)
-    return ax_client
-
-
-def ax_wrapper(data: dict, arg_types: list):
-    """
-    Ax platform wrapper function for creating optimization campaign parameters and objective from the web form input
-    :param data: e.g.,
-    {
-        "param_1_type": "range", "param_1_value": [1,2],
-        "param_2_type": "range", "param_2_value": [1,2],
-        "obj_1_min": True,
-        "obj_2_min": True
-    }
-    :return: the optimization campaign parameters
-    parameter=[
-        {"name": "param_1", "type": "range", "bounds": [1,2]},
-        {"name": "param_1", "type": "range", "bounds": [1,2]}
-    ]
-    objectives=[
-        {"name": "obj_1", "min": True, "threshold": None},
-        {"name": "obj_2", "min": True, "threshold": None},
-    ]
-    """
-    from ax.service.utils.instantiation import ObjectiveProperties
-    parameter = []
-    objectives = {}
-    # Iterate through the webui_data dictionary
-    for key, value in data.items():
-        # Check if the key corresponds to a parameter type
-        if "_type" in key:
-            param_name = key.split("_type")[0]
-            param_type = value
-            param_value = data[f"{param_name}_value"].split(",")
-            try:
-                values = [float(v) for v in param_value]
-            except Exception:
-                values = param_value
-            if param_type == "range":
-                param = {"name": param_name, "type": param_type, "bounds": values}
-            if param_type == "choice":
-                param = {"name": param_name, "type": param_type, "values": values}
-            if param_type == "fixed":
-                param = {"name": param_name, "type": param_type, "value": values[0]}
-            _type = arg_types[param_name] if arg_types[param_name] in ["str", "bool", "int"] else "float"
-            param.update({"value_type": _type})
-            parameter.append(param)
-        elif key.endswith("_min"):
-            if not value == 'none':
-                obj_name = key.split("_min")[0]
-                is_min = True if value == "minimize" else False
-
-                threshold = None if f"{obj_name}_threshold" not in data else data[f"{obj_name}_threshold"]
-                properties = ObjectiveProperties(minimize=is_min)
-                objectives[obj_name] = properties
-
-    return parameter, objectives
-
-
-def ax_init_opc(bo_args):
-    install_and_import("ax", "ax-platform")
-    from ax.service.ax_client import AxClient
-    from ax.service.utils.instantiation import ObjectiveProperties
-
-    ax_client = AxClient()
-    objectives = bo_args.get("objectives")
-    objectives_formatted = {}
-    for obj in objectives:
-        obj_name = obj.get("name")
-        minimize = obj.get("minimize")
-        objectives_formatted[obj_name] = ObjectiveProperties(minimize=minimize)
-    bo_args["objectives"] = objectives_formatted
-    ax_client.create_experiment(**bo_args)
-
-    return ax_client

ivoryos/utils/client_proxy.py

@@ -1,57 +0,0 @@
-# import argparse
-import os
-
-# import requests
-
-# session = requests.Session()
-
-
-# Function to create class and methods dynamically
-def create_function(url, class_name, functions):
-    class_template = f'class {class_name.capitalize()}:\n    url = "{url}ivoryos/api/control/deck.{class_name}"\n'
-
-    for function_name, details in functions.items():
-        signature = details['signature']
-        docstring = details.get('docstring', '')
-
-        # Creating the function definition
-        method = f'    def {function_name}{signature}:\n'
-        if docstring:
-            method += f'        """{docstring}"""\n'
-
-        # Generating the session.post code for sending data
-        method += '        return session.post(self.url, data={'
-        method += f'"hidden_name": "{function_name}"'
-
-        # Extracting the parameters from the signature string for the data payload
-        param_str = signature[6:-1]  # Remove the "(self" and final ")"
-        params = [param.strip() for param in param_str.split(',')] if param_str else []
-
-        for param in params:
-            param_name = param.split(':')[0].strip()  # Split on ':' and get parameter name
-            method += f', "{param_name}": {param_name}'
-
-        method += '}).json()\n'
-        class_template += method + '\n'
-
-    return class_template
-
-# Function to export the generated classes to a Python script
-def export_to_python(class_definitions, path):
-    with open(os.path.join(path, "generated_proxy.py"), 'w') as f:
-        # Writing the imports at the top of the script
-        f.write('import requests\n\n')
-        f.write('session = requests.Session()\n\n')
-
-        # Writing each class definition to the file
-        for class_name, class_def in class_definitions.items():
-            f.write(class_def)
-            f.write('\n')
-
-        # Creating instances of the dynamically generated classes
-        for class_name in class_definitions.keys():
-            instance_name = class_name.lower()  # Using lowercase for instance names
-            f.write(f'{instance_name} = {class_name.capitalize()}()\n')
-
-
-

ivoryos/utils/db_models.py

@@ -1,700 +0,0 @@
-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
-from sqlalchemy_utils import JSONType
-
-db = SQLAlchemy()
-
-
-class User(db.Model, UserMixin):
-    __tablename__ = 'user'
-    # id = db.Column(db.Integer)
-    username = db.Column(db.String(50), primary_key=True, unique=True, nullable=False)
-    # email = db.Column(db.String)
-    hashPassword = db.Column(db.String(255))
-
-    # password = db.Column()
-    def __init__(self, username, password):
-        # self.id = id
-        self.username = username
-        # self.email = email
-        self.hashPassword = password
-
-    def get_id(self):
-        return self.username
-
-
-class Script(db.Model):
-    __tablename__ = 'script'
-    # id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(50), primary_key=True, unique=True)
-    deck = db.Column(db.String(50), nullable=True)
-    status = db.Column(db.String(50), nullable=True)
-    script_dict = db.Column(JSONType, nullable=True)
-    time_created = db.Column(db.String(50), nullable=True)
-    last_modified = db.Column(db.String(50), nullable=True)
-    id_order = db.Column(JSONType, nullable=True)
-    editing_type = db.Column(db.String(50), nullable=True)
-    author = db.Column(db.String(50), nullable=False)
-    # registered = db.Column(db.Boolean, nullable=True, default=False)
-
-    def __init__(self, name=None, deck=None, status=None, script_dict: dict = None, id_order: dict = None,
-                 time_created=None, last_modified=None, editing_type=None, author: str = None,
-                 # registered:bool=False,
-                 python_script: str = None
-                 ):
-        if script_dict is None:
-            script_dict = {"prep": [], "script": [], "cleanup": []}
-        elif type(script_dict) is not dict:
-            script_dict = json.loads(script_dict)
-        if id_order is None:
-            id_order = {"prep": [], "script": [], "cleanup": []}
-        elif type(id_order) is not dict:
-            id_order = json.loads(id_order)
-        if status is None:
-            status = 'editing'
-        if time_created is None:
-            time_created = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        if last_modified is None:
-            last_modified = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        if editing_type is None:
-            editing_type = "script"
-
-        self.name = name
-        self.deck = deck
-        self.status = status
-        self.script_dict = script_dict
-        self.time_created = time_created
-        self.last_modified = last_modified
-        self.id_order = id_order
-        self.editing_type = editing_type
-        self.author = author
-        self.python_script = python_script
-        # self.r = registered
-
-    def as_dict(self):
-        dict = self.__dict__
-        dict.pop('_sa_instance_state', None)
-        return dict
-
-    def get(self):
-        workflows = db.session.query(Script).all()
-        # result = script_schema.dump(workflows)
-        return workflows
-
-    def find_by_uuid(self, uuid):
-        for stype in self.script_dict:
-            for action in self.script_dict[stype]:
-
-                if action['uuid'] == int(uuid):
-                    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):
-        action = self.find_by_uuid(uuid)
-        if not action:
-            return
-        arg_types = action['arg_types']
-        if type(action['args']) is dict:
-            # pass
-            self.eval_list(args, arg_types)
-        else:
-            pass
-        action['args'] = args
-        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())
-
-    @property
-    def currently_editing_script(self):
-        return self.script_dict[self.editing_type]
-
-    @currently_editing_script.setter
-    def currently_editing_script(self, script):
-        self.script_dict[self.editing_type] = script
-
-    @property
-    def currently_editing_order(self):
-        return self.id_order[self.editing_type]
-
-    @currently_editing_order.setter
-    def currently_editing_order(self, script):
-        self.id_order[self.editing_type] = script
-
-    def update_time_stamp(self):
-        self.last_modified = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    def get_script(self, stype: str):
-        return self.script_dict[stype]
-
-    def isEmpty(self) -> bool:
-        if not (self.script_dict['script'] or self.script_dict['prep'] or self.script_dict['cleanup']):
-            return True
-        return False
-
-    def _sort(self, script_type):
-        if len(self.id_order[script_type]) > 0:
-            for action in self.script_dict[script_type]:
-                for i in range(len(self.id_order[script_type])):
-                    if action['id'] == int(self.id_order[script_type][i]):
-                        # print(i+1)
-                        action['id'] = i + 1
-                        break
-            self.id_order[script_type].sort()
-            if not int(self.id_order[script_type][-1]) == len(self.script_dict[script_type]):
-                new_order = list(range(1, len(self.script_dict[script_type]) + 1))
-                self.id_order[script_type] = [str(i) for i in new_order]
-            self.script_dict[script_type].sort(key=lambda x: x['id'])
-
-    def sort_actions(self, script_type=None):
-        if script_type:
-            self._sort(script_type)
-        else:
-            for i in self.stypes:
-                self._sort(i)
-
-    def add_action(self, action: dict, insert_position=None):
-        current_len = len(self.currently_editing_script)
-        action_to_add = action.copy()
-        action_to_add['id'] = current_len + 1
-        action_to_add['uuid'] = uuid.uuid4().fields[-1]
-        self.currently_editing_script.append(action_to_add)
-        self._insert_action(insert_position, current_len)
-        self.update_time_stamp()
-
-    def add_variable(self, statement, variable, type, insert_position=None):
-        variable = self.validate_function_name(variable)
-        convert_type = getattr(builtins, type)
-        statement = convert_type(statement)
-        current_len = len(self.currently_editing_script)
-        uid = uuid.uuid4().fields[-1]
-        action = {"id": current_len + 1, "instrument": 'variable', "action": variable,
-                        "args": {"statement": 'None' if statement == '' else statement}, "return": '', "uuid": uid,
-                        "arg_types": {"statement": type}}
-        self.currently_editing_script.append(action)
-        self._insert_action(insert_position, current_len)
-        self.update_time_stamp()
-
-    def _insert_action(self, insert_position, current_len, action_len:int=1):
-
-        if insert_position is None:
-            self.currently_editing_order.extend([str(current_len + i + 1) for i in range(action_len)])
-        else:
-            index = int(insert_position) - 1
-            self.currently_editing_order[index:index] = [str(current_len + i + 1) for i in range(action_len)]
-            self.sort_actions()
-
-    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 validate_variables(self, kwargs):
-        """
-        Validates the kwargs passed to the Script
-        """
-        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}
-            if isinstance(value, str) and value.startswith("#"):
-                kwargs[key] = f"#{self.validate_function_name(value[1:])}"
-        return kwargs
-
-    def add_logic_action(self, logic_type: str, statement, insert_position=None):
-        current_len = len(self.currently_editing_script)
-        uid = uuid.uuid4().fields[-1]
-        logic_dict = {
-            "if":
-                [
-                    {"id": current_len + 1, "instrument": 'if', "action": 'if',
-                     "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": '',
-                     "uuid": uid},
-                ],
-            "while":
-                [
-                    {"id": current_len + 1, "instrument": 'while', "action": 'while',
-                     "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": {"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]
-        self.currently_editing_script.extend(action_list)
-        self._insert_action(insert_position, current_len, len(action_list))
-        self.update_time_stamp()
-
-    def delete_action(self, id: int):
-        """
-        Delete the action by id (step number)
-        """
-        uid = next((action['uuid'] for action in self.currently_editing_script if action['id'] == int(id)), None)
-        id_to_be_removed = [action['id'] for action in self.currently_editing_script if action['uuid'] == uid]
-        order = self.currently_editing_order
-        script = self.currently_editing_script
-        self.currently_editing_order = [i for i in order if int(i) not in id_to_be_removed]
-        self.currently_editing_script = [action for action in script if action['id'] not in id_to_be_removed]
-        self.sort_actions()
-        self.update_time_stamp()
-
-    def duplicate_action(self, id: int):
-        """
-        duplicate action by id (step number), available only for non logic actions
-        """
-        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)
-        if action_to_duplicate is not None:
-            # Update IDs for all subsequent actions
-            for action in self.currently_editing_script:
-                if action['id'] > insert_id:
-                    action['id'] += 1
-            self.currently_editing_script[-1]['id'] = insert_id + 1
-            # Sort actions if necessary and update the time stamp
-            self.sort_actions()
-            self.update_time_stamp()
-        else:
-            raise ValueError("Action not found: Unable to duplicate the action with ID", id)
-
-    def config(self, stype):
-        """
-        take the global script_dict
-        :return: list of variable that require input
-        """
-        configure = []
-        config_type_dict = {}
-        for action in self.script_dict[stype]:
-            args = action['args']
-            if args is not None:
-                if type(args) is not dict:
-                    if type(args) is str and args.startswith("#") and not args[1:] in configure:
-                        configure.append(args[1:])
-                        config_type_dict[args[1:]] = action['arg_types']
-
-                else:
-                    for arg in args:
-                        if type(args[arg]) is str \
-                                and args[arg].startswith("#") \
-                                and not args[arg][1:] in configure:
-                            configure.append(args[arg][1:])
-                            if arg in action['arg_types']:
-                                if action['arg_types'][arg] == '':
-                                    config_type_dict[args[arg][1:]] = "any"
-                                else:
-                                    config_type_dict[args[arg][1:]] = action['arg_types'][arg]
-                            else:
-                                config_type_dict[args[arg][1:]] = "any"
-        # todo
-        return configure, config_type_dict
-
-    def config_return(self):
-        """
-        take the global script_dict
-        :return: list of variable that require input
-        """
-
-        return_list = set([action['return'] for action in self.script_dict['script'] if not action['return'] == ''])
-        output_str = "return {"
-        for i in return_list:
-            output_str += "'" + i + "':" + i + ","
-        output_str += "}"
-        return output_str, return_list
-
-    def finalize(self):
-        """finalize script, disable editing"""
-        self.status = "finalized"
-        self.update_time_stamp()
-
-    def save_as(self, name):
-        """resave script, enable editing"""
-        self.name = name
-        self.status = "editing"
-        self.update_time_stamp()
-
-    def indent(self, unit=0):
-        """helper: create _ unit of indent in code string"""
-        string = "\n"
-        for _ in range(unit):
-            string += "\t"
-        return string
-
-    def convert_to_lines(self, exec_str_collection: dict):
-        """
-        Parse a dictionary of script functions and extract function body lines.
-
-        :param exec_str_collection: Dictionary containing script types and corresponding function strings.
-        :return: A dict containing script types as keys and lists of function body lines as values.
-        """
-        line_collection = {}
-        for stype, func_str in exec_str_collection.items():
-            if func_str:
-                module = ast.parse(func_str)
-                func_def = next(node for node in module.body if isinstance(node, ast.FunctionDef))
-
-                # Extract function body as source lines
-                line_collection[stype] = [ast.unparse(node) for node in func_def.body if not isinstance(node, ast.Return)]
-                # print(line_collection[stype])
-        return line_collection
-
-    def compile(self, script_path=None):
-        """
-        Compile the current script to a Python file.
-        :return: String to write to a Python file.
-        """
-        self.sort_actions()
-        run_name = self.name if self.name else "untitled"
-        run_name = self.validate_function_name(run_name)
-        exec_str_collection = {}
-
-        for i in self.stypes:
-            if self.script_dict[i]:
-                func_str = self._generate_function_header(run_name, i) + self._generate_function_body(i)
-                exec_str_collection[i] = func_str
-        if script_path:
-            self._write_to_file(script_path, run_name, exec_str_collection)
-
-        return exec_str_collection
-
-
-
-    @staticmethod
-    def validate_function_name(name):
-        """Replace invalid characters with underscores"""
-        name = re.sub(r'\W|^(?=\d)', '_', name)
-        # Check if it's a Python keyword and adjust if necessary
-        if keyword.iskeyword(name):
-            name += '_'
-        return name
-
-    def _generate_function_header(self, run_name, stype):
-        """
-        Generate the function header.
-        """
-        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()]
-
-        script_type = f"_{stype}" if stype != "script" else ""
-        function_header = f"def {run_name}{script_type}("
-
-        if stype == "script":
-            function_header += ", ".join(configure)
-
-        function_header += "):"
-        # function_header += self.indent(1) + f"global {run_name}_{stype}"
-        return function_header
-
-    def _generate_function_body(self, stype):
-        """
-        Generate the function body for each type in stypes.
-        """
-        body = ''
-        indent_unit = 1
-
-        for index, action in enumerate(self.script_dict[stype]):
-            text, indent_unit = self._process_action(indent_unit, action, index, stype)
-            body += text
-        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):
-        """
-        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, statement, next_action)
-        elif instrument == 'while':
-            return self._process_while(indent_unit, action_name, statement, next_action)
-        elif instrument == 'variable':
-            return self.indent(indent_unit) + f"{action_name} = {statement}", indent_unit
-        elif instrument == 'wait':
-            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)
-        #todo
-        # elif instrument == 'registered_workflows':
-        #     return inspect.getsource(my_function)
-        else:
-            return self._process_instrument_action(indent_unit, instrument, action_name, args, save_data)
-
-    def _process_args(self, args):
-        """
-        Process arguments, handling any specific formatting needs.
-        """
-        if isinstance(args, str) and args.startswith("#"):
-            return args[1:]
-        return args
-
-    def _process_if(self, indent_unit, action, args, next_action):
-        """
-        Process 'if' and 'else' actions.
-        """
-        exec_string = ""
-        if action == 'if':
-            exec_string += self.indent(indent_unit) + f"if {args}:"
-            indent_unit += 1
-            if next_action and next_action['instrument'] == 'if' and next_action['action'] == 'else':
-                exec_string += self.indent(indent_unit) + "pass"
-            # else:
-
-        elif action == 'else':
-            indent_unit -= 1
-            exec_string += self.indent(indent_unit) + "else:"
-            indent_unit += 1
-            if next_action and next_action['instrument'] == 'if' and next_action['action'] == 'endif':
-                exec_string += self.indent(indent_unit) + "pass"
-        else:
-            indent_unit -= 1
-        return exec_string, indent_unit
-
-    def _process_while(self, indent_unit, action, args, next_action):
-        """
-        Process 'while' and 'endwhile' actions.
-        """
-        exec_string = ""
-        if action == 'while':
-            exec_string += self.indent(indent_unit) + f"while {args}:"
-            indent_unit += 1
-            if next_action and next_action['instrument'] == 'while':
-                exec_string += self.indent(indent_unit) + "pass"
-        elif action == 'endwhile':
-            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})"
-        elif isinstance(args, str):
-            single_line = f"{instrument}.{action} = {args}"
-        else:
-            single_line = f"{instrument}.{action}()"
-
-        if save_data:
-            save_data += " = "
-
-        return self.indent(indent_unit) + save_data + single_line, indent_unit
-
-    def _process_dict_args(self, args):
-        """
-        Process dictionary arguments, handling special cases like variables.
-        """
-        args_str = args.__str__()
-        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 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):
-        """
-        Get the next action in the sequence if it exists.
-        """
-        if index < (len(self.script_dict[stype]) - 1):
-            return self.script_dict[stype][index + 1]
-        return None
-
-    def _is_variable(self, arg):
-        """
-        Check if the argument is of type 'variable'.
-        """
-        return arg in self.script_dict and self.script_dict[arg].get("arg_types") == "variable"
-
-    def _write_to_file(self, script_path, run_name, exec_string):
-        """
-        Write the compiled script to a file.
-        """
-        with open(script_path + run_name + ".py", "w") as s:
-            if self.deck:
-                s.write(f"import {self.deck} as deck")
-            else:
-                s.write("deck = None")
-            s.write("\nimport time")
-            for i in exec_string.values():
-                s.write(f"\n\n\n{i}")
-
-class WorkflowRun(db.Model):
-    __tablename__ = 'workflow_runs'
-
-    id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(128), nullable=False)
-    platform = db.Column(db.String(128), nullable=False)
-    start_time = db.Column(db.DateTime, default=datetime.now())
-    end_time = db.Column(db.DateTime)
-    data_path = db.Column(db.String(256))
-    steps = db.relationship(
-        'WorkflowStep',
-        backref='workflow_runs',
-        cascade='all, delete-orphan',
-        passive_deletes=True
-    )
-    def as_dict(self):
-        dict = self.__dict__
-        dict.pop('_sa_instance_state', None)
-        return dict
-
-class WorkflowStep(db.Model):
-    __tablename__ = 'workflow_steps'
-
-    id = db.Column(db.Integer, primary_key=True)
-    workflow_id = db.Column(db.Integer, db.ForeignKey('workflow_runs.id', ondelete='CASCADE'), nullable=False)
-
-    phase = db.Column(db.String(64), nullable=False)  # 'prep', 'main', 'cleanup'
-    repeat_index = db.Column(db.Integer, default=0)   # Only applies to 'main' phase
-    step_index = db.Column(db.Integer, default=0)
-    method_name = db.Column(db.String(128), nullable=False)
-    start_time = db.Column(db.DateTime)
-    end_time = db.Column(db.DateTime)
-    run_error = db.Column(db.Boolean, default=False)
-
-    def as_dict(self):
-        dict = self.__dict__.copy()
-        dict.pop('_sa_instance_state', None)
-        return dict
-
-
-class SingleStep(db.Model):
-    __tablename__ = 'single_steps'
-
-    id = db.Column(db.Integer, primary_key=True)
-    method_name = db.Column(db.String(128), nullable=False)
-    kwargs = db.Column(JSONType, nullable=False)
-    start_time = db.Column(db.DateTime)
-    end_time = db.Column(db.DateTime)
-    run_error = db.Column(db.String(128))
-    output = db.Column(JSONType)
-
-    def as_dict(self):
-        dict = self.__dict__.copy()
-        dict.pop('_sa_instance_state', None)
-        return dict
-
-if __name__ == "__main__":
-    a = Script()
-
-    print("")

ivoryos/utils/form.py

@@ -1,560 +0,0 @@
-from enum import Enum
-from typing import get_origin, get_args, Union, Any
-
-from wtforms.fields.choices import SelectField
-from wtforms.fields.core import Field
-from wtforms.validators import InputRequired, ValidationError, Optional
-from wtforms.widgets.core import TextInput
-
-from flask_wtf import FlaskForm
-from wtforms import StringField, FloatField, HiddenField, BooleanField, IntegerField
-import inspect
-
-from ivoryos.utils.db_models import Script
-from ivoryos.utils.global_config import GlobalConfig
-
-global_config = GlobalConfig()
-
-def find_variable(data, script):
-    """
-    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
-
-
-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, variable_type = 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, variable_type = 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, variable_type = find_variable(valuelist[0], self.script)
-                    if 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
-            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, variable_type = 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
-        if self.script:
-            variable, variable_type = find_variable(valuelist[0], self.script)
-            if variable:
-                try:
-                    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:
-                    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()
-    false_values = (False, "false", "", "False", "f", "F")
-
-    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, variable_type = find_variable(value, self.script)
-            if variable:
-                if not variable_type == "function_output":
-                    raise ValueError("Not accepting boolean variables")
-                return variable
-
-        self.data = bool(value)
-
-    def process_formdata(self, valuelist):
-        # todo
-        # print(valuelist)
-        if not valuelist or not type(valuelist) is list:
-            self.data = False
-        else:
-            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, variable_type = find_variable(self.raw_data, self.script)
-            if variable:
-                return variable
-
-        if self.raw_data:
-            return str(self.raw_data[0])
-        return "y"
-
-
-class FlexibleEnumField(StringField):
-    def __init__(self, label=None, validators=None, choices=None, script=None, **kwargs):
-        super().__init__(label, validators, **kwargs)
-        self.script = script
-        self.enum_class = choices
-        self.choices = [e.name for e in self.enum_class]
-        # self.value_list = [e.name for e in self.enum_class]
-
-
-    def process_formdata(self, valuelist):
-        if valuelist:
-            key = valuelist[0]
-            if key in self.choices:
-                # Convert the string key to Enum instance
-                self.data = self.enum_class[key].value
-            elif self.data.startswith("#"):
-                if not self.script.editing_type == "script":
-                    raise ValueError(self.gettext("Variable is not supported in prep/cleanup"))
-                self.data = self.data
-            else:
-                raise ValidationError(
-                    f"Invalid choice: '{key}'. Must match one of {list(self.enum_class.__members__.keys())}")
-
-
-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 parse_annotation(annotation):
-    """
-    Given a type annotation, return:
-    - a list of all valid types (excluding NoneType)
-    - a boolean indicating if the value can be None (optional)
-    """
-    origin = get_origin(annotation)
-    args = get_args(annotation)
-
-    if annotation is Any:
-        return [str], True  # fallback: accept any string, optional
-
-    if origin is Union:
-        types = list(set(args))
-        is_optional = type(None) in types
-        non_none_types = [t for t in types if t is not type(None)]
-        return non_none_types, is_optional
-
-    # Not a Union, just a regular type
-    return [annotation], False
-
-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
-
-    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)
-
-        default_value = None
-        if autofill:
-            default_value = f'#{param.name}'
-        else:
-            if param.default is not param.empty:
-                if isinstance(param.default, Enum):
-                    default_value = param.default.name
-                else:
-                    default_value = param.default
-
-        field_kwargs = {
-            "label": formatted_param_name,
-            "default": default_value,
-            "validators": [InputRequired()] if param.default is param.empty else [Optional()],
-            **({"script": script} if (autofill or design) else {})
-        }
-        if isinstance(param.annotation, type) and issubclass(param.annotation, Enum):
-            # enum_class = [(e.name, e.value) for e in param.annotation]
-            field_class = FlexibleEnumField
-            placeholder_text = f"Choose or type a value for {param.annotation.__name__} (start with # for custom)"
-            extra_kwargs = {"choices": param.annotation}
-        else:
-            # print(param.annotation)
-            annotation, optional = parse_annotation(param.annotation)
-            annotation = annotation[0]
-            field_class, placeholder_text = annotation_mapping.get(
-                annotation,
-                (VariableOrStringField if design else StringField, f'Enter {param.annotation} value')
-            )
-            extra_kwargs = {}
-            if optional:
-                field_kwargs["filters"] = [lambda x: x if x != '' else None]
-
-
-        render_kwargs = {"placeholder": placeholder_text}
-
-        # Create the field with additional rendering kwargs for placeholder text
-        field = field_class(**field_kwargs, render_kw=render_kwargs, **extra_kwargs)
-        setattr(DynamicForm, param.name, field)
-
-    # setattr(DynamicForm, f'add', fname)
-    return DynamicForm
-
-
-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', "")
-    # print(signature, 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', 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 = 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):
-        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):
-    """
-    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_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_all_builtin_forms(script):
-    all_builtin_forms = {}
-    for logic_name in ['if', 'while', 'variable', 'wait', 'repeat']:
-        # signature = info.get('signature', {})
-        form_class = create_builtin_form(logic_name, script)
-        all_builtin_forms[logic_name] = form_class()
-    return all_builtin_forms
-
-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'
-    }.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)
-    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)
-        type_field = SelectField(
-            'Select Input Type',
-            choices=[('int', 'Integer'), ('float', 'Float'), ('str', 'String'), ('bool', 'Boolean')],
-            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 get_method_from_workflow(function_string):
-    """Creates a function from a string and assigns it a new name."""
-
-    namespace = {}
-    exec(function_string, globals(), namespace)  # Execute the string in a safe namespace
-    func_name = next(iter(namespace))
-    # Get the function name dynamically
-    return namespace[func_name]
-
-
-def create_workflow_forms(script, autofill: bool = False, design: bool = False):
-    workflow_forms = {}
-    functions = {}
-    class RegisteredWorkflows:
-        pass
-
-    deck_name = script.deck
-    workflows = Script.query.filter(Script.deck==deck_name, Script.name != script.name).all()
-    for workflow in workflows:
-        compiled_strs = workflow.compile().get('script', "")
-        method = get_method_from_workflow(compiled_strs)
-        functions[workflow.name] = dict(signature=inspect.signature(method), docstring=inspect.getdoc(method))
-        setattr(RegisteredWorkflows, workflow.name, method)
-
-        form_class = create_form_for_method(method, autofill, script, design)
-
-        hidden_method_name = HiddenField(name=f'hidden_name', description="",
-                                         render_kw={"value": f'{workflow.name}'})
-        if design:
-            return_value = StringField(label='Save value as', render_kw={"placeholder": "Optional"})
-            setattr(form_class, 'return', return_value)
-        setattr(form_class, 'workflow_name', hidden_method_name)
-        workflow_forms[workflow.name] = form_class()
-    global_config.registered_workflows = RegisteredWorkflows
-    return workflow_forms, functions
-
-
-def create_action_button(script, stype=None):
-    """
-    Creates action buttons for design route (design canvas)
-    :param script: Script object
-    :param stype: script type (script, prep, cleanup)
-    """
-    stype = stype or script.editing_type
-    variables = script.get_variables()
-    return [_action_button(i, variables) for i in script.get_script(stype)]
-
-
-def _action_button(action: dict, variables: dict):
-    """
-    Creates action button for one action
-    :param action: Action dict
-    :param variables: created variable dict
-    """
-    style = {
-        "repeat": "background-color: lightsteelblue",
-        "if": "background-color: salmon",
-        "while": "background-color: salmon",
-    }.get(action['instrument'], "")
-
-    if action['instrument'] in ['if', 'while', 'repeat']:
-        text = f"{action['action']} {action['args'].get('statement', '')}"
-    elif action['instrument'] == 'variable':
-        text = f"{action['action']} = {action['args'].get('statement')}"
-    else:
-        # regular action button
-        prefix = f"{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/global_config.py

@@ -1,87 +0,0 @@
-import threading
-
-
-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._registered_workflows = None
-            cls._instance._agent = None
-            cls._instance._defined_variables = {}
-            cls._instance._api_variables = set()
-            cls._instance._deck_snapshot = {}
-            cls._instance._runner_lock = threading.Lock()
-            cls._instance._runner_status = 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 registered_workflows(self):
-        return self._registered_workflows
-
-    @registered_workflows.setter
-    def registered_workflows(self, value):
-        if self._registered_workflows is None:
-            self._registered_workflows = value
-
-
-    @property
-    def deck_snapshot(self):
-        return self._deck_snapshot
-
-    @deck_snapshot.setter
-    def deck_snapshot(self, value):
-        self._deck_snapshot = 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_lock(self):
-        return self._runner_lock
-
-    @runner_lock.setter
-    def runner_lock(self, value):
-        self._runner_lock = value
-
-    @property
-    def runner_status(self):
-        return self._runner_status
-
-    @runner_status.setter
-    def runner_status(self, value):
-        self._runner_status = value

ivoryos/utils/input_types.md

@@ -1,14 +0,0 @@
-## Supported Input Types
-### **Commonly Used Types**
-| Type    | Example Input          | Example Conversion                   |
-|---------|------------------------|--------------------------------------|
-| `int`   | `"42"`                 | `42`                                 |
-| `float` | `"3.14"`               | `3.14`                               |
-| `str`   | `"hello"`              | `"hello"`                            |
-| `bool`  | `"True"` / `"False"`   | `True` / `False`                     |
-| `list ` | `"1,2,3"`              | `[1, 2, 3]`                          |
-| `tuple` | `"1,hello,3.5"`        | `(1, "hello", 3.5)`                  |
-| `set`   | `"1,2,3"`              | `{1, 2, 3}`                          |
-| `Any`   | `"anything"`           | `"anything"` (no conversion applied) |
-
----

ivoryos/utils/llm_agent.py

@@ -1,183 +0,0 @@
-import inspect
-import json
-import os
-import re
-
-from openai import OpenAI
-
-
-# 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.abstract_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
-
-"""

ivoryos/utils/script_runner.py

@@ -1,336 +0,0 @@
-import ast
-import os
-import csv
-import threading
-import time
-from datetime import datetime
-
-from ivoryos.utils import utils, bo_campaign
-from ivoryos.utils.db_models import Script, WorkflowRun, WorkflowStep, db, SingleStep
-from ivoryos.utils.global_config import GlobalConfig
-
-global_config = GlobalConfig()
-global deck
-deck = None
-# global deck, registered_workflows
-# deck, registered_workflows = None, None
-
-class ScriptRunner:
-    def __init__(self, globals_dict=None):
-        self.retry = False
-        if globals_dict is None:
-            globals_dict = globals()
-        self.globals_dict = globals_dict
-        self.pause_event = threading.Event()  # A threading event to manage pause/resume
-        self.pause_event.set()
-        self.stop_pending_event = threading.Event()
-        self.stop_current_event = threading.Event()
-        self.is_running = False
-        self.lock = global_config.runner_lock
-        self.paused = False
-        self.current_app = None
-
-    def toggle_pause(self):
-        """Toggles between pausing and resuming the script"""
-        self.paused = not self.paused
-        if self.pause_event.is_set():
-            self.pause_event.clear()  # Pause the script
-            return "Paused"
-        else:
-            self.pause_event.set()  # Resume the script
-            return "Resumed"
-
-    def pause_status(self):
-        """Toggles between pausing and resuming the script"""
-        return self.paused
-
-    def reset_stop_event(self):
-        """Resets the stop event"""
-        self.stop_pending_event.clear()
-        self.stop_current_event.clear()
-        self.pause_event.set()
-
-    def abort_pending(self):
-        """Abort the pending iteration after the current is finished"""
-        self.stop_pending_event.set()
-        # print("Stop pending tasks")
-
-    def stop_execution(self):
-        """Force stop everything, including ongoing tasks."""
-        self.stop_current_event.set()
-        self.abort_pending()
-
-
-    def run_script(self, script, repeat_count=1, run_name=None, logger=None, socketio=None, config=None, bo_args=None,
-                   output_path="", compiled=False, current_app=None):
-        global deck
-        if deck is None:
-            deck = global_config.deck
-
-        if self.current_app is None:
-            self.current_app = current_app
-        # time.sleep(1)  # Optional: may help ensure deck readiness
-
-        # Try to acquire lock without blocking
-        if not self.lock.acquire(blocking=False):
-            if logger:
-                logger.info("System is busy. Please wait for it to finish or stop it before starting a new one.")
-            return None
-
-        self.reset_stop_event()
-
-        thread = threading.Thread(
-            target=self._run_with_stop_check,
-            args=(script, repeat_count, run_name, logger, socketio, config, bo_args, output_path, current_app, compiled)
-        )
-        thread.start()
-        return thread
-
-    def exec_steps(self, script, section_name, logger, socketio, run_id, i_progress, **kwargs):
-        """
-        Executes a function defined in a string line by line
-        :param func_str: The function as a string
-        :param kwargs: Arguments to pass to the function
-        :return: The final result of the function execution
-        """
-        _func_str = script.python_script or script.compile()
-        step_list: list = script.convert_to_lines(_func_str).get(section_name, [])
-        global deck
-        # global deck, registered_workflows
-        if deck is None:
-            deck = global_config.deck
-        # if registered_workflows is None:
-        #     registered_workflows = global_config.registered_workflows
-
-        # for i, line in enumerate(step_list):
-        #     if line.startswith("registered_workflows"):
-        #
-        # func_str = script.compile()
-        # Parse function body from string
-        temp_connections = global_config.defined_variables
-        # Prepare execution environment
-        exec_globals = {"deck": deck, "time":time}  # Add required global objects
-        # exec_globals = {"deck": deck, "time": time, "registered_workflows":registered_workflows}  # Add required global objects
-        exec_globals.update(temp_connections)
-        exec_locals = {}  # Local execution scope
-
-        # Define function arguments manually in exec_locals
-        exec_locals.update(kwargs)
-        index = 0
-
-        # Execute each line dynamically
-        while index < len(step_list):
-            if self.stop_current_event.is_set():
-                logger.info(f'Stopping execution during {section_name}')
-                step = WorkflowStep(
-                    workflow_id=run_id,
-                    phase=section_name,
-                    repeat_index=i_progress,
-                    step_index=index,
-                    method_name="stop",
-                    start_time=datetime.now(),
-                    end_time=datetime.now(),
-                    run_error=False,
-                )
-                db.session.add(step)
-                break
-            line = step_list[index]
-            method_name = line.strip().split("(")[0] if "(" in line else line.strip()
-            start_time = datetime.now()
-            step = WorkflowStep(
-                workflow_id=run_id,
-                phase=section_name,
-                repeat_index=i_progress,
-                step_index=index,
-                method_name=method_name,
-                start_time=start_time,
-            )
-            db.session.add(step)
-            db.session.commit()
-            logger.info(f"Executing: {line}")
-            socketio.emit('execution', {'section': f"{section_name}-{index}"})
-            # self._emit_progress(socketio, 100)
-            # if line.startswith("registered_workflows"):
-            #     line = line.replace("registered_workflows.", "")
-            try:
-                if line.startswith("time.sleep("): # add safe sleep for time.sleep lines
-                    duration_str = line[len("time.sleep("):-1]
-                    duration = float(duration_str)
-                    self.safe_sleep(duration)
-                else:
-                    exec(line, exec_globals, exec_locals)
-                step.run_error = False
-            except Exception as e:
-                logger.error(f"Error during script execution: {e}")
-                socketio.emit('error', {'message': str(e)})
-
-                step.run_error = True
-                self.toggle_pause()
-            step.end_time = datetime.now()
-            # db.session.add(step)
-            db.session.commit()
-
-            self.pause_event.wait()
-
-            # todo update script during the run
-            # _func_str = script.compile()
-            # step_list: list = script.convert_to_lines(_func_str).get(section_name, [])
-            if not step.run_error:
-                index += 1
-            elif not self.retry:
-                index += 1
-        return exec_locals  # Return the 'results' variable
-
-    def _run_with_stop_check(self, script: Script, repeat_count: int, run_name: str, logger, socketio, config, bo_args,
-                             output_path, current_app, compiled):
-        time.sleep(1)
-        # _func_str = script.compile()
-        # step_list_dict: dict = script.convert_to_lines(_func_str)
-        self._emit_progress(socketio, 1)
-
-        # Run "prep" section once
-        script_dict = script.script_dict
-        with current_app.app_context():
-
-            run = WorkflowRun(name=script.name or "untitled", platform=script.deck or "deck",start_time=datetime.now())
-            db.session.add(run)
-            db.session.commit()
-            run_id = run.id  # Save the ID
-            global_config.runner_status = {"id":run_id, "type": "workflow"}
-            self._run_actions(script, section_name="prep", logger=logger, socketio=socketio, run_id=run_id)
-            output_list = []
-            _, arg_type = script.config("script")
-            _, return_list = script.config_return()
-
-            # Run "script" section multiple times
-            if repeat_count:
-                self._run_repeat_section(repeat_count, arg_type, bo_args, output_list, script,
-                                         run_name, return_list, compiled, logger, socketio, run_id=run_id)
-            elif config:
-                self._run_config_section(config, arg_type, output_list, script, run_name, logger,
-                                         socketio, run_id=run_id, compiled=compiled)
-
-            # Run "cleanup" section once
-            self._run_actions(script, section_name="cleanup", logger=logger, socketio=socketio,run_id=run_id)
-            # Reset the running flag when done
-            self.lock.release()
-            # Save results if necessary
-            filename = None
-            if not script.python_script and output_list:
-                filename = self._save_results(run_name, arg_type, return_list, output_list, logger, output_path)
-            self._emit_progress(socketio, 100)
-        with current_app.app_context():
-            run = db.session.get(WorkflowRun, run_id)  # SQLAlchemy 1.4+ recommended method
-            run.end_time = datetime.now()
-            run.data_path = filename
-            db.session.commit()
-
-    def _run_actions(self, script, section_name="", logger=None, socketio=None, run_id=None):
-        _func_str = script.python_script or script.compile()
-        step_list: list = script.convert_to_lines(_func_str).get(section_name, [])
-        logger.info(f'Executing {section_name} steps') if step_list else logger.info(f'No {section_name} steps')
-        if self.stop_pending_event.is_set():
-            logger.info(f"Stopping execution during {section_name} section.")
-            return
-        if step_list:
-            self.exec_steps(script, section_name, logger, socketio, run_id=run_id, i_progress=0)
-
-    def _run_config_section(self, config, arg_type, output_list, script, run_name, logger, socketio, run_id, compiled=True):
-        if not compiled:
-            for i in config:
-                try:
-                    i = utils.convert_config_type(i, arg_type)
-                    compiled = True
-                except Exception as e:
-                    logger.info(e)
-                    compiled = False
-                    break
-        if compiled:
-            for i, kwargs in enumerate(config):
-                kwargs = dict(kwargs)
-                if self.stop_pending_event.is_set():
-                    logger.info(f'Stopping execution during {run_name}: {i + 1}/{len(config)}')
-                    break
-                logger.info(f'Executing {i + 1} of {len(config)} with kwargs = {kwargs}')
-                progress = (i + 1) * 100 / len(config)
-                self._emit_progress(socketio, progress)
-                # fname = f"{run_name}_script"
-                # function = self.globals_dict[fname]
-                output = self.exec_steps(script, "script", logger, socketio, run_id, i, **kwargs)
-                if output:
-                    # kwargs.update(output)
-                    output_list.append(output)
-
-    def _run_repeat_section(self, repeat_count, arg_types, bo_args, output_list, script, run_name, return_list, compiled,
-                            logger, socketio, run_id):
-        if bo_args:
-            logger.info('Initializing optimizer...')
-            if compiled:
-                ax_client = bo_campaign.ax_init_opc(bo_args)
-            else:
-                ax_client = bo_campaign.ax_init_form(bo_args, arg_types)
-        for i_progress in range(int(repeat_count)):
-            if self.stop_pending_event.is_set():
-                logger.info(f'Stopping execution during {run_name}: {i_progress + 1}/{int(repeat_count)}')
-                break
-            logger.info(f'Executing {run_name} experiment: {i_progress + 1}/{int(repeat_count)}')
-            progress = (i_progress + 1) * 100 / int(repeat_count) - 0.1
-            self._emit_progress(socketio, progress)
-            if bo_args:
-                try:
-                    parameters, trial_index = ax_client.get_next_trial()
-                    logger.info(f'Output value: {parameters}')
-                    # fname = f"{run_name}_script"
-                    # function = self.globals_dict[fname]
-                    output = self.exec_steps(script, "script", logger, socketio, run_id, i_progress, **parameters)
-
-                    _output = {key: value for key, value in output.items() if key in return_list}
-                    ax_client.complete_trial(trial_index=trial_index, raw_data=_output)
-                    output.update(parameters)
-                except Exception as e:
-                    logger.info(f'Optimization error: {e}')
-                    break
-            else:
-                # fname = f"{run_name}_script"
-                # function = self.globals_dict[fname]
-                output = self.exec_steps(script, "script", logger, socketio, run_id, i_progress)
-
-            if output:
-                output_list.append(output)
-                logger.info(f'Output value: {output}')
-        return output_list
-
-    @staticmethod
-    def _save_results(run_name, arg_type, return_list, output_list, logger, output_path):
-        args = list(arg_type.keys()) if arg_type else []
-        args.extend(return_list)
-        filename = run_name + "_" + datetime.now().strftime("%Y-%m-%d %H-%M") + ".csv"
-        file_path = os.path.join(output_path, filename)
-        with open(file_path, "w", newline='') as file:
-            writer = csv.DictWriter(file, fieldnames=args)
-            writer.writeheader()
-            writer.writerows(output_list)
-        logger.info(f'Results saved to {file_path}')
-        return filename
-
-    @staticmethod
-    def _emit_progress(socketio, progress):
-        socketio.emit('progress', {'progress': progress})
-
-    def safe_sleep(self, duration: float):
-        interval = 1  # check every 1 second
-        end_time = time.time() + duration
-        while time.time() < end_time:
-            if self.stop_current_event.is_set():
-                return  # Exit early if stop is requested
-            time.sleep(min(interval, end_time - time.time()))
-
-    def get_status(self):
-        """Returns current status of the script runner."""
-        with self.current_app.app_context():
-            return {
-                "is_running": self.lock.locked(),
-                "paused": self.paused,
-                "stop_pending": self.stop_pending_event.is_set(),
-                "stop_current": self.stop_current_event.is_set(),
-            }

ivoryos/utils/task_runner.py

@@ -1,81 +0,0 @@
-import threading
-import time
-from datetime import datetime
-
-from ivoryos.utils.db_models import db, SingleStep
-from ivoryos.utils.global_config import GlobalConfig
-
-global_config = GlobalConfig()
-global deck
-deck = None
-
-
-class TaskRunner:
-    def __init__(self, globals_dict=None):
-        self.retry = False
-        if globals_dict is None:
-            globals_dict = globals()
-        self.globals_dict = globals_dict
-        self.lock = global_config.runner_lock
-
-
-    def run_single_step(self, component, method, kwargs, wait=True, current_app=None):
-        global deck
-        if deck is None:
-            deck = global_config.deck
-
-        # Try to acquire lock without blocking
-        if not self.lock.acquire(blocking=False):
-            current_status = global_config.runner_status
-            current_status["status"] = "busy"
-            return current_status
-
-
-        if wait:
-            output = self._run_single_step(component, method, kwargs, current_app)
-        else:
-            print("running with thread")
-            thread = threading.Thread(
-                target=self._run_single_step, args=(component, method, kwargs, current_app)
-            )
-            thread.start()
-            time.sleep(0.1)
-            output = {"status": "task started", "task_id": global_config.runner_status.get("id")}
-
-        return output
-
-    def _get_executable(self, component, deck, method):
-        if component.startswith("deck."):
-            component = component.split(".")[1]
-            instrument = getattr(deck, component)
-        else:
-            temp_connections = global_config.defined_variables
-            instrument = temp_connections.get(component)
-        function_executable = getattr(instrument, method)
-        return function_executable
-
-    def _run_single_step(self, component, method, kwargs, current_app=None):
-        try:
-            function_executable = self._get_executable(component, deck, method)
-            method_name = f"{function_executable.__self__.__class__.__name__}.{function_executable.__name__}"
-        except Exception as e:
-            self.lock.release()
-            return {"status": "error", "msg": e.__str__()}
-
-        # with self.lock:
-        with current_app.app_context():
-            step = SingleStep(method_name=method_name, kwargs=kwargs, run_error=False, start_time=datetime.now())
-            db.session.add(step)
-            db.session.commit()
-            global_config.runner_status = {"id":step.id, "type": "task"}
-            try:
-                output = function_executable(**kwargs)
-                step.output = output
-                step.end_time = datetime.now()
-            except Exception as e:
-                step.run_error = e.__str__()
-                step.end_time = datetime.now()
-            finally:
-                db.session.commit()
-                self.lock.release()
-            return output

ivoryos/utils/utils.py

@@ -1,422 +0,0 @@
-import ast
-import importlib
-import inspect
-import logging
-import os
-import pickle
-import socket
-import subprocess
-import sys
-from collections import Counter
-
-import flask
-from flask import session
-from flask_socketio import SocketIO
-
-from ivoryos.utils.db_models import Script
-
-
-def get_script_file():
-    """Get script from Flask session and returns the script"""
-    session_script = session.get("scripts")
-    if session_script:
-        s = Script()
-        s.__dict__.update(**session_script)
-        return s
-    else:
-        return Script(author=session.get('user'))
-
-
-def post_script_file(script, is_dict=False):
-    """
-    Post script to Flask. Script will be converted to a dict if it is a Script object
-    :param script: Script to post
-    :param is_dict: if the script is a dictionary,
-    """
-    if is_dict:
-        session['scripts'] = script
-    else:
-        session['scripts'] = script.as_dict()
-
-
-def create_gui_dir(parent_path):
-    """
-    Creates folders for ivoryos data
-    """
-    os.makedirs(parent_path, exist_ok=True)
-    for path in ["config_csv", "scripts", "results", "pseudo_deck"]:
-        os.makedirs(os.path.join(parent_path, path), exist_ok=True)
-
-
-def save_to_history(filepath, history_path):
-    """
-    For manual deck connection only
-    save deck file path that successfully connected to ivoryos to a history file
-    """
-    connections = []
-    try:
-        with open(history_path, 'r') as file:
-            lines = file.read()
-            connections = lines.split('\n')
-    except FileNotFoundError:
-        pass
-    if filepath not in connections:
-        with open(history_path, 'a') as file:
-            file.writelines(f"{filepath}\n")
-
-
-def import_history(history_path):
-    """
-    For manual deck connection only
-    load deck connection history from history file
-    """
-    connections = []
-    try:
-        with open(history_path, 'r') as file:
-            lines = file.read()
-            connections = lines.split('\n')
-    except FileNotFoundError:
-        pass
-    connections = [i for i in connections if not i == '']
-    return connections
-
-
-def available_pseudo_deck(path):
-    """
-    load pseudo deck (snapshot) from connection history
-    """
-    return os.listdir(path)
-
-
-def _inspect_class(class_object=None, debug=False):
-    """
-    inspect class object: inspect function signature if not name.startswith("_")
-    :param class_object: class object
-    :param debug: debug mode will inspect function.startswith("_")
-    :return: function: Dict[str, Dict[str, Union[Signature, str, None]]]
-    """
-    functions = {}
-    under_score = "_"
-    if debug:
-        under_score = "__"
-    for function, method in inspect.getmembers(type(class_object), predicate=callable):
-        if not function.startswith(under_score) and not function.isupper():
-            try:
-                annotation = inspect.signature(method)
-                docstring = inspect.getdoc(method)
-                functions[function] = dict(signature=annotation, docstring=docstring)
-
-            except Exception:
-                pass
-    return functions
-
-
-def _get_type_from_parameters(arg, parameters):
-    """get argument types from inspection"""
-    arg_type = ''
-    if type(parameters) is inspect.Signature:
-        annotation = parameters.parameters[arg].annotation
-    elif type(parameters) is dict:
-        annotation = parameters[arg]
-    if annotation is not inspect._empty:
-        # print(p[arg].annotation)
-        if annotation.__module__ == 'typing':
-
-            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 _convert_by_str(args, arg_types):
-    """
-    Converts a value to type through eval(f'{type}("{args}")')
-    """
-    if type(arg_types) is not list:
-        arg_types = [arg_types]
-    for arg_type in arg_types:
-        if not arg_type == "any":
-            try:
-                args = eval(f'{arg_type}("{args}")') if type(args) is str else eval(f'{arg_type}({args})')
-                return args
-            except Exception:
-                raise TypeError(f"Input type error: cannot convert '{args}' to {arg_type}.")
-
-
-def _convert_by_class(args, arg_types):
-    """
-    Converts a value to type through type(arg)
-    """
-    if arg_types.__module__ == 'builtins':
-        args = arg_types(args)
-        return args
-    elif arg_types.__module__ == "typing":
-        for i in arg_types.__args__:  # for typing.Union
-            try:
-                args = i(args)
-                return args
-            except Exception:
-                pass
-        raise TypeError("Input type error.")
-    # else:
-    #     args = globals()[args]
-    return args
-
-
-def convert_config_type(args, arg_types, is_class: bool = False):
-    """
-    Converts an argument from str to an arg type
-    """
-    if args:
-        for arg in args:
-            if arg not in arg_types.keys():
-                raise ValueError("config file format not supported.")
-            if args[arg] == '' or args[arg] == "None":
-                args[arg] = None
-            # elif args[arg] == "True" or args[arg] == "False":
-            #     args[arg] = bool_dict[args[arg]]
-            else:
-                arg_type = arg_types[arg]
-                try:
-                    args[arg] = ast.literal_eval(args[arg])
-                except ValueError:
-                    pass
-                if type(args[arg]) is not arg_type and not type(args[arg]).__name__ == arg_type:
-                    if is_class:
-                        # if arg_type.__module__ == 'builtins':
-                        args[arg] = _convert_by_class(args[arg], arg_type)
-                    else:
-                        args[arg] = _convert_by_str(args[arg], arg_type)
-    return args
-
-
-def import_module_by_filepath(filepath: str, name: str):
-    """
-    Import module by file path
-    :param filepath: full path of module
-    :param name: module's name
-    """
-    spec = importlib.util.spec_from_file_location(name, filepath)
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-class SocketIOHandler(logging.Handler):
-    def __init__(self, socketio: SocketIO):
-        super().__init__()
-        self.formatter = logging.Formatter('%(asctime)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-        self.socketio = socketio
-
-    def emit(self, record):
-        message = self.format(record)
-        # session["last_log"] = message
-        self.socketio.emit('log', {'message': message})
-
-
-def start_logger(socketio: SocketIO, logger_name: str, log_filename: str = None):
-    """
-    stream logger to web through web socketIO
-    """
-    # logging.basicConfig( format='%(asctime)s - %(message)s')
-    formatter = logging.Formatter(fmt='%(asctime)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
-    logger = logging.getLogger(logger_name)
-    logger.setLevel(logging.INFO)
-    file_handler = logging.FileHandler(filename=log_filename, )
-    file_handler.setFormatter(formatter)
-    logger.addHandler(file_handler)
-    # console_logger = logging.StreamHandler()  # stream to console
-    # logger.addHandler(console_logger)
-    socketio_handler = SocketIOHandler(socketio)
-    logger.addHandler(socketio_handler)
-    return logger
-
-
-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)
-    return arg_types
-
-
-def install_and_import(package, package_name=None):
-    """
-    Install the package and import it
-    :param package: package to import and install
-    :param package_name: pip install package name if different from package
-    """
-    try:
-        # Check if the package is already installed
-        importlib.import_module(package)
-        # print(f"{package} is already installed.")
-    except ImportError:
-        # If not installed, install it
-        # print(f"{package} is not installed. Installing now...")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", package_name or package])
-        # print(f"{package} has been installed successfully.")
-
-
-def web_config_entry_wrapper(data: dict, config_type: list):
-    """
-    Wrap the data dictionary from web config entries during execution configuration
-    :param data: data dictionary
-    :param config_type: data entry types ["str", "int", "float", "bool"]
-    """
-    rows = {}  # Dictionary to hold webui_data organized by rows
-
-    # Organize webui_data by rows
-    for key, value in data.items():
-        if value:  # Only process non-empty values
-            # Extract the field name and row index
-            field_name, row_index = key.split('[')
-            row_index = int(row_index.rstrip(']'))
-
-            # If row not in rows, create a new dictionary for that row
-            if row_index not in rows:
-                rows[row_index] = {}
-
-            # Add or update the field value in the specific row's dictionary
-            rows[row_index][field_name] = value
-
-    # Filter out any empty rows and create a list of dictionaries
-    filtered_rows = [row for row in rows.values() if len(row) == len(config_type)]
-
-    return filtered_rows
-
-
-def create_deck_snapshot(deck, save: bool = False, output_path: str = '', exclude_names: list[str] = []):
-    """
-    Create a deck snapshot of the given script
-    :param deck: python module name to create the deck snapshot from e.g. __main__
-    :param save: save the deck snapshot into pickle file
-    :param output_path: path to save the pickle file
-    :param exclude_names: module names to exclude from deck snapshot
-    """
-    exclude_classes = (flask.Blueprint, logging.Logger)
-
-    deck_snapshot = {}
-    included = {}
-    excluded = {}
-    failed = {}
-
-    for name, val in vars(deck).items():
-        qualified_name = f"deck.{name}"
-
-        # Exclusion checks
-        if (
-                type(val).__module__ == 'builtins'
-                or name[0].isupper()
-                or name.startswith("_")
-                or isinstance(val, exclude_classes)
-                or name in exclude_names
-        ):
-            excluded[qualified_name] = type(val).__name__
-            continue
-
-        try:
-            deck_snapshot[qualified_name] = _inspect_class(val)
-            included[qualified_name] = type(val).__name__
-        except Exception as e:
-            failed[qualified_name] = str(e)
-
-    # Final result
-    deck_summary = {
-        "included": included,
-        # "excluded": excluded,
-        "failed": failed
-    }
-
-    def print_deck_snapshot(deck_summary):
-        def print_section(title, items):
-            print(f"\n=== {title} ({len(items)}) ===")
-            if not items:
-                return
-            for name, class_type in items.items():
-                print(f"  {name}: {class_type}")
-
-        print_section("✅ INCLUDED", deck_summary["included"])
-        print_section("❌ FAILED", deck_summary["failed"])
-        print("\n")
-
-    print_deck_snapshot(deck_summary)
-
-    if deck_snapshot and save:
-        # pseudo_deck = parse_dict
-        parse_dict = deck_snapshot.copy()
-        parse_dict["deck_name"] = os.path.splitext(os.path.basename(deck.__file__))[
-            0] if deck.__name__ == "__main__" else deck.__name__
-        with open(os.path.join(output_path, f"{parse_dict['deck_name']}.pkl"), 'wb') as file:
-            pickle.dump(parse_dict, file)
-    return deck_snapshot
-
-
-def load_deck(pkl_name: str):
-    """
-    Loads a pickled deck snapshot from disk on offline mode
-    :param pkl_name: name of the pickle file
-    """
-    if not pkl_name:
-        return None
-    try:
-        with open(pkl_name, 'rb') as f:
-            pseudo_deck = pickle.load(f)
-        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())
-
-
-def get_method_from_workflow(function_string, func_name="workflow"):
-    """Creates a function from a string and assigns it a new name."""
-
-    namespace = {}
-    exec(function_string, globals(), namespace)  # Execute the string in a safe namespace
-    # func_name = next(iter(namespace))
-    # Get the function name dynamically
-    return namespace[func_name]
-
-# def load_workflows(script):
-#
-#     class RegisteredWorkflows:
-#         pass
-#     deck_name = script.deck
-#     workflows = Script.query.filter(Script.deck == deck_name, Script.name != script.name, Script.registered==True).all()
-#     for workflow in workflows:
-#         compiled_strs = workflow.compile().get('script', "")
-#         method = get_method_from_workflow(compiled_strs, func_name=workflow.name)
-#         setattr(RegisteredWorkflows, workflow.name, staticmethod(method))
-#     global_config.registered_workflows = RegisteredWorkflows()
-
-
-def get_local_ip():
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        s.connect(('10.255.255.255', 1))  # Dummy address to get interface IP
-        ip = s.getsockname()[0]
-    except Exception:
-        ip = '127.0.0.1'
-    finally:
-        s.close()
-    return ip

ivoryos/version.py

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

requirements.txt

@@ -1,11 +1 @@
-# Flask and SQL
-bcrypt
-Flask-Login
-Flask-Session
-Flask-SocketIO
-Flask-SQLAlchemy
-SQLAlchemy-Utils~=0.41
-wtforms~=3.2.1
-flask-wtf
-eventlet
-python-dotenv
+ivoryos>=1.0.7