ivoryos 1.2.7__tar.gz → 1.3.0__tar.gz

{ivoryos-1.2.7 → ivoryos-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivoryos
-Version: 1.2.7
+Version: 1.3.0
 Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
 Author-email: Ivory Zhang <ivoryzhang@chem.ubc.ca>
 License: MIT

ivoryos-1.3.0/ivoryos/__init__.py

@@ -0,0 +1,13 @@
+from ivoryos.server import run
+from ivoryos.optimizer.registry import OPTIMIZER_REGISTRY
+from ivoryos.version import __version__ as ivoryos_version
+from ivoryos.utils.decorators import block, BUILDING_BLOCKS
+
+
+__all__ = [
+    "block",
+    "BUILDING_BLOCKS",
+    "OPTIMIZER_REGISTRY",
+    "run",
+    "ivoryos_version",
+]

ivoryos-1.3.0/ivoryos/app.py

@@ -0,0 +1,131 @@
+import os
+import uuid
+
+from flask import Flask, session, g, redirect, url_for
+from flask_login import AnonymousUserMixin
+
+from ivoryos.utils import utils
+from ivoryos.utils.db_models import db
+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.data.data import data
+from ivoryos.routes.library.library import library
+from ivoryos.routes.design.design import design
+from ivoryos.routes.execute.execute import execute
+from ivoryos.routes.api.api import api
+from ivoryos.socket_handlers import socketio
+from ivoryos.routes.main.main import main
+from ivoryos.version import __version__ as ivoryos_version
+from sqlalchemy import inspect, text
+from flask import current_app
+
+
+def reset_old_schema(engine, db_dir):
+    inspector = inspect(engine)
+    tables = inspector.get_table_names()
+
+
+    # Check if old tables exist (no workflow_phases table)
+    has_workflow_phase = 'workflow_phases' in tables
+    old_workflow_run = 'old_workflow_run' in tables
+    old_workflow_step = 'workflow_steps' in tables
+
+    if not has_workflow_phase:
+        print("⚠️ Old workflow database detected! All previous workflows have been reset to support the new schema.")
+        # Backup old DB
+        db_path = os.path.join(db_dir, "ivoryos.db")
+        if os.path.exists(db_path):
+            # os.makedirs(backup_dir, exist_ok=True)
+            from datetime import datetime
+            import shutil
+            ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_path = os.path.join(db_dir, f"ivoryos_backup_{ts}.db")
+            shutil.copy(db_path, backup_path)
+            print(f"Backup created at {backup_path}")
+        with engine.begin() as conn:
+            # Drop old tables
+            if old_workflow_step:
+                conn.execute(text("DROP TABLE IF EXISTS workflow_steps"))
+            if old_workflow_run:
+                conn.execute(text("DROP TABLE IF EXISTS workflow_runs"))
+
+    # Recreate new schema
+    db.create_all()  # creates workflow_runs, workflow_phases, workflow_steps
+
+
+def create_app(config_class=None):
+    """
+    create app, init database
+    """
+
+    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=f'{url_prefix}/{auth.name}')
+    app.register_blueprint(library, url_prefix=f'{url_prefix}/{library.name}')
+    app.register_blueprint(control, url_prefix=f'{url_prefix}/instruments')
+    app.register_blueprint(design, url_prefix=f'{url_prefix}')
+    app.register_blueprint(execute, url_prefix=f'{url_prefix}')
+    app.register_blueprint(data, url_prefix=f'{url_prefix}')
+    app.register_blueprint(api, url_prefix=f'{url_prefix}/{api.name}')
+
+
+    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, cors_allowed_origins="*", cookie=None)
+    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()
+        reset_old_schema(db.engine, app.config['OUTPUT_FOLDER'])
+
+    # 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
+        session.permanent = False
+        # DEMO_MODE: Simulate logged-in user per session
+        if app.config.get("DEMO_MODE", False):
+            if "demo_user_id" not in session:
+                session["demo_user_id"] = f"demo_{str(uuid.uuid4())[:8]}"
+
+            class SessionDemoUser(AnonymousUserMixin):
+                @property
+                def is_authenticated(self):
+                    return True
+
+                def get_id(self):
+                    return session.get("demo_user_id")
+
+            login_manager.anonymous_user = SessionDemoUser
+
+
+
+    @app.route('/')
+    def redirect_to_prefix():
+        return redirect(url_for('main.index', version=ivoryos_version))  # Assuming 'index' is a route in your blueprint
+
+    @app.template_filter('format_name')
+    def format_name(name):
+        name = name.split(".")[-1]
+        text = ' '.join(word for word in name.split('_'))
+        return text.capitalize()
+
+    # app.config.setdefault("DEMO_MODE", False)
+    return app

{ivoryos-1.2.7 → ivoryos-1.3.0}/ivoryos/routes/api/api.py

@@ -1,3 +1,4 @@
+import copy
 import os
 from flask import Blueprint, jsonify, request, current_app
 
@@ -46,7 +47,7 @@ def backend_control(instrument: str=None):
                                             current_app=current_app._get_current_object())
             return jsonify(output), 200
 
-    snapshot = global_config.deck_snapshot.copy()
+    snapshot = copy.deepcopy(global_config.deck_snapshot)
     # Iterate through each instrument in the snapshot
     for instrument_key, instrument_data in snapshot.items():
         # Iterate through each function associated with the current instrument

{ivoryos-1.2.7 → ivoryos-1.3.0}/ivoryos/routes/control/control.py

@@ -5,7 +5,7 @@ from ivoryos.routes.control.control_file import control_file
 from ivoryos.routes.control.control_new_device import control_temp
 from ivoryos.routes.control.utils import post_session_by_instrument, get_session_by_instrument, find_instrument_by_name
 from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils.form import create_form_from_module
+from ivoryos.utils.form import create_form_from_module, create_form_from_pseudo
 from ivoryos.utils.task_runner import TaskRunner
 
 global_config = GlobalConfig()
@@ -48,7 +48,10 @@ def deck_controllers(instrument: str = None):
     forms = None
     if instrument:
         inst_object = find_instrument_by_name(instrument)
-        forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
+        if instrument.startswith("blocks"):
+            forms = create_form_from_pseudo(pseudo=inst_object, autofill=False, design=False)
+        else:
+            forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
         order = get_session_by_instrument('card_order', instrument)
         hidden_functions = get_session_by_instrument('hidden_functions', instrument)
         functions = list(forms.keys())
@@ -99,12 +102,11 @@ def deck_controllers(instrument: str = None):
                 function_data["signature"] = str(function_data["signature"])
         return jsonify(snapshot)
 
-    deck_variables = global_config.deck_snapshot.keys()
-    temp_variables = global_config.defined_variables.keys()
     return render_template(
         "controllers.html",
-        defined_variables=deck_variables,
-        temp_variables=temp_variables,
+        defined_variables=global_config.deck_snapshot.keys(),
+        block_variables=global_config.building_blocks.keys(),
+        temp_variables=global_config.defined_variables.keys(),
         instrument=instrument,
         forms=forms,
         session=session

{ivoryos-1.2.7 → ivoryos-1.3.0}/ivoryos/routes/control/templates/controllers.html

@@ -49,6 +49,24 @@
             </div>
           </div>
         {% endif %}
+
+          {% if block_variables %}
+            <div class="mb-4">
+            <h6 class="fw-bold text-secondary mb-2" style="letter-spacing: 1px;">Methods</h6>
+            <div class="list-group">
+              {% for inst in block_variables %}
+                <a class="list-group-item list-group-item-action d-flex align-items-center {% if instrument == inst %}active bg-warning text-dark border-0{% else %}bg-light{% endif %}"
+                   href="{{ url_for('control.deck_controllers') }}?instrument={{ inst }}"
+                   style="border-radius: 0.5rem; margin-bottom: 0.5rem; transition: background 0.2s;">
+                  <span class="flex-grow-1">{{ inst | format_name }}</span>
+                  {% if instrument == inst %}
+                    <span class="ms-auto">&gt;</span>
+                  {% endif %}
+                </a>
+              {% endfor %}
+            </div>
+          </div>
+          {% endif %}
         <!-- Action Buttons -->
         <div class="mb-4">
           <a href="{{ url_for('control.file.download_proxy', filetype='proxy') }}" class="btn btn-outline-primary w-100 mb-2">
@@ -89,6 +107,15 @@
                                 {{ 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 %}

{ivoryos-1.2.7 → ivoryos-1.3.0}/ivoryos/routes/control/utils.py

@@ -13,6 +13,8 @@ def find_instrument_by_name(name: str):
     if name.startswith("deck"):
         name = name.replace("deck.", "")
         return getattr(global_config.deck, name)
+    elif name.startswith("blocks"):
+        return global_config.building_blocks[name]
     elif name in global_config.defined_variables:
         return global_config.defined_variables[name]
     elif name in globals():

ivoryos-1.3.0/ivoryos/routes/data/data.py

@@ -0,0 +1,170 @@
+import os
+
+from flask import Blueprint, redirect, url_for, request, render_template, current_app, jsonify, send_file
+from flask_login import login_required
+
+from ivoryos.utils.db_models import db, WorkflowRun, WorkflowStep, WorkflowPhase
+
+data = Blueprint('data', __name__, template_folder='templates')
+
+
+
+@data.route('/executions/records')
+@login_required
+def list_workflows():
+    """
+    .. :quickref: Workflow Execution Database; list all workflow execution records
+
+    list all workflow execution records
+
+    .. http:get:: /executions/records
+
+    """
+    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)
+
+@data.get("/executions/records/<int:workflow_id>")
+def workflow_logs(workflow_id:int):
+    """
+    .. :quickref: Workflow Data Database; get workflow data, steps, and logs
+
+    get workflow data logs by workflow id
+
+    .. http:get:: /executions/<int:workflow_id>
+
+    :param workflow_id: workflow id
+    :type workflow_id: int
+    """
+    workflow = db.session.get(WorkflowRun, workflow_id)
+    if not workflow:
+        return jsonify({"error": "Workflow not found"}), 404
+
+    # Query all phases for this run, ordered by start_time
+    phases = WorkflowPhase.query.filter_by(run_id=workflow_id).order_by(WorkflowPhase.start_time).all()
+
+    # Prepare grouped data for template (full objects)
+    grouped = {
+        "prep": [],
+        "script": {},
+        "cleanup": [],
+    }
+
+    # Prepare grouped data for JSON (dicts)
+    grouped_json = {
+        "prep": [],
+        "script": {},
+        "cleanup": [],
+    }
+
+    for phase in phases:
+        phase_dict = phase.as_dict()
+
+        # Steps sorted by step_index
+        steps = sorted(phase.steps, key=lambda s: s.step_index)
+        phase_steps_dicts = [s.as_dict() for s in steps]
+
+        if phase.name == "prep":
+            grouped["prep"].append(phase)
+            grouped_json["prep"].append({
+                **phase_dict,
+                "steps": phase_steps_dicts
+            })
+
+        elif phase.name == "main":
+            grouped["script"].setdefault(phase.repeat_index, []).append(phase)
+            grouped_json["script"].setdefault(phase.repeat_index, []).append({
+                **phase_dict,
+                "steps": phase_steps_dicts
+            })
+
+        elif phase.name == "cleanup":
+            grouped["cleanup"].append(phase)
+            grouped_json["cleanup"].append({
+                **phase_dict,
+                "steps": phase_steps_dicts
+            })
+
+    if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':
+        return jsonify({
+            "workflow_info": workflow.as_dict(),
+            "phases": grouped_json,
+        })
+    else:
+        return render_template("workflow_view.html", workflow=workflow, grouped=grouped)
+
+
+@data.get("/executions/data/<int:workflow_id>")
+def workflow_phase_data(workflow_id: int):
+    workflow = db.session.get(WorkflowRun, workflow_id)
+    if not workflow:
+        return jsonify({})
+
+    phase_data = {}
+    # Only plot 'main' phases
+    main_phases = WorkflowPhase.query.filter_by(run_id=workflow_id, name='main').order_by(
+        WorkflowPhase.repeat_index).all()
+
+    for phase in main_phases:
+        outputs = phase.outputs or {}
+        phase_index = phase.repeat_index
+        # Convert each key to list of dicts for x (phase_index) and y (value)
+        phase_data[phase_index] = {}
+        for k, v in outputs.items():
+            if isinstance(v, (int, float)):
+                phase_data[phase_index][k] = [{"x": phase_index, "y": v}]
+            elif isinstance(v, list) and all(isinstance(i, (int, float)) for i in v):
+                phase_data[phase_index][k] = v.map(lambda val, idx=0: {"x": phase_index, "y": val})
+
+    return jsonify(phase_data)
+
+
+@data.delete("/executions/records/<int:workflow_id>")
+@login_required
+def delete_workflow_record(workflow_id: int):
+    """
+    .. :quickref: Workflow Data Database; delete a workflow execution record
+
+    delete a workflow execution record by workflow id
+
+    .. http:delete:: /executions/records/<int:workflow_id>
+
+    :param workflow_id: workflow id
+    :type workflow_id: int
+    :status 200: return success message
+    """
+    run = WorkflowRun.query.get(workflow_id)
+    db.session.delete(run)
+    db.session.commit()
+    return jsonify(success=True)
+
+
+@data.route('/files/execution-data/<string:filename>')
+@login_required
+def download_results(filename:str):
+    """
+    .. :quickref: Workflow data; download a workflow data file (.CSV)
+
+    .. http:get:: /files/execution-data/<string:filename>
+
+    :param filename: workflow data filename
+    :type filename: str
+
+    # :status 302: load pseudo deck and then redirects to :http:get:`/ivoryos/executions`
+    """
+
+    filepath = os.path.join(current_app.config["DATA_FOLDER"], filename)
+    return send_file(os.path.abspath(filepath), as_attachment=True)

ivoryos-1.3.0/ivoryos/routes/data/templates/components/step_card.html

@@ -0,0 +1,42 @@
+<div class="card mb-2 {{ 'border-danger text-danger bg-light' if phase.run_error else 'border-secondary' }}">
+    <div class="card-body p-2">
+        <small class="text-muted">
+            <i class="fas fa-play-circle me-1"></i> Start: {{ phase.start_time.strftime('%H:%M:%S') if phase.start_time else 'N/A' }}
+            <i class="fas fa-stop-circle ms-2 me-1"></i> End: {{ phase.end_time.strftime('%H:%M:%S') if phase.end_time else 'N/A' }}
+        </small>
+            {% if phase.parameters %}
+            <div class="mt-2">
+                <strong>Parameters: </strong>
+                    {% for key, value in phase.parameters.items() %}
+                    <span class="badge bg-secondary me-1">{{ key }}: {{ value }}</span>
+                    {% endfor %}
+            </div>
+            {% endif %}
+        {% if phase.steps %}
+            <div class="mt-2">
+                <strong>Steps:</strong>
+                <ul class="mb-0">
+                    {% for step in phase.steps %}
+                        <li class="{{ 'text-danger' if step.run_error else '' }}">
+                            {{ step.method_name }}
+                            <small class="text-muted">
+                              ({{ step.start_time.strftime('%H:%M:%S') if step.start_time else 'N/A' }} –
+                              {{ step.end_time.strftime('%H:%M:%S') if step.end_time else 'N/A' }})
+                            </small>
+                        </li>
+                    {% endfor %}
+                </ul>
+            </div>
+        {% endif %}
+        {% if phase.outputs %}
+            <div class="mt-1">
+                <strong>Outputs:</strong>
+                <ul class="mb-0">
+                    {% for key, value in phase.outputs.items() %}
+                        <li>{{ key }}: {{ value }}</li>
+                    {% endfor %}
+                </ul>
+            </div>
+        {% endif %}
+    </div>
+</div>