ivoryos 1.2.8__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

ivoryos/app.py

@@ -17,6 +17,42 @@ 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):
     """
@@ -45,7 +81,8 @@ def create_app(config_class=None):
 
     # Create database tables
     with app.app_context():
-        db.create_all()
+        # db.create_all()
+        reset_old_schema(db.engine, app.config['OUTPUT_FOLDER'])
 
     # Additional setup
     utils.create_gui_dir(app.config['OUTPUT_FOLDER'])

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/routes/control/templates/controllers.html

@@ -107,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/routes/data/data.py

@@ -3,7 +3,7 @@ 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
+from ivoryos.utils.db_models import db, WorkflowRun, WorkflowStep, WorkflowPhase
 
 data = Blueprint('data', __name__, template_folder='templates')
 
@@ -37,7 +37,6 @@ def list_workflows():
     else:
         return render_template('workflow_database.html', workflows=workflows)
 
-
 @data.get("/executions/records/<int:workflow_id>")
 def workflow_logs(workflow_id:int):
     """
@@ -50,47 +49,87 @@ def workflow_logs(workflow_id:int):
     :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
+            })
 
-    if request.method == 'GET':
-        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,
+        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
             })
-        else:
-            return render_template("workflow_view.html", workflow=workflow, grouped=grouped)
+
+        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>")

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

@@ -1,13 +1,42 @@
-<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 | format_name }}</strong>
-    <small class="text-muted">
-      <i class="fas fa-play-circle me-1"></i> Start: {{ step.start_time.strftime('%H:%M:%S') if step.start_time else 'N/A' }}
-      <i class="fas fa-stop-circle ms-2 me-1"></i> End: {{ step.end_time.strftime('%H:%M:%S') if step.end_time else 'N/A' }}
-      <!-- {% if step.run_error %}
-        <i class="fas fa-stop-circle ms-2 me-1"></i> Error: {{ step.run_error if step.run_error else 'N/A' }}
-      {% endif %} -->
-    </small>
-    <!-- <small>Error: {{ step.run_error }}</small> -->
-  </div>
-</div>
+<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>

ivoryos/routes/data/templates/workflow_view.html

@@ -4,127 +4,348 @@
 
 {% 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;
-  }
+    .vis-time-axis .vis-text.vis-minor,
+    .vis-time-axis .vis-text.vis-major {
+        color: #666;
+    }
+    .vis-item.stop {
+        background-color: #dc3545;
+        color: white;
+        border: none;
+        font-weight: bold;
+    }
+    .vis-item.prep {
+        background-color: #17a2b8;
+        border-color: #138496;
+    }
+    .vis-item.script {
+        background-color: #28a745;
+        border-color: #1e7e34;
+    }
+    .vis-item.cleanup {
+        background-color: #ffc107;
+        border-color: #d39e00;
+        color: #212529;
+    }
+    #visualization {
+        border: 1px solid #dee2e6;
+        border-radius: 0.375rem;
+        background-color: #fff;
+        min-height: 200px;
+    }
+
+    .section-header {
+        border-bottom: 2px solid #dee2e6;
+        padding-bottom: 0.5rem;
+        margin-bottom: 1rem;
+        color: #495057;
+    }
+    .loading-spinner {
+        display: none;
+    }
 </style>
 
-<div id="timeline"></div>
 
+    <div class="timeline-section" style="margin-bottom: 2rem;">
+        <h3 class="section-header">
+            <i class="fas fa-clock me-2"></i>Execution Timeline
+        </h3>
+        <div class="alert alert-info" role="alert">
+            <i class="fas fa-info-circle me-2"></i>
+            <strong>Tip:</strong> Click on timeline items to navigate to detailed views. Use Ctrl+scroll to zoom.
+        </div>
+        <div id="visualization"></div>
+    </div>
+
+    <!-- Phase Output Plot Section -->
+
+    <div class="data-section" style="margin-bottom: 2rem;">
+        <h3 class="section-header">
+            <div class="col-md-6">
+                <label for="output-select" class="form-label">Select Data Type:</label>
+                <select id="output-select" class="form-select">
+                    <option value="">Loading data types...</option>
+                </select>
+            </div>
+        </h3>
+
+        <div class="plot-controls">
+            <div>
+                <div class="col-md-6 text-md-end">
+                    <div class="loading-spinner">
+                        <div class="spinner-border spinner-border-sm text-primary me-2" role="status">
+                            <span class="visually-hidden">Loading...</span>
+                        </div>
+                        Loading plot data...
+                    </div>
+                </div>
+            </div>
+        </div>
+        <div id="phase-plot" style="height:450px;" class="border rounded bg-white shadow-sm"></div>
+    </div>
+
+    <!-- Workflow Details Section -->
+
+    <div>
+        <h2 class="section-header">
+            <i class="fas fa-project-diagram me-2"></i>Workflow: {{ workflow.name }}
+        </h2>
+
+        <!-- Prep Phase -->
+        {% if grouped.prep %}
+            <div class="mb-4">
+                <h4 class="text-info mb-3">
+                    <i class="fas fa-tools me-2"></i>Prep
+                </h4>
+                <div class="row">
+                    {% for phase in grouped.prep %}
+                        <div class="col-lg-6 mb-3">
+                            {% include "components/step_card.html" %}
+                        </div>
+                    {% endfor %}
+                </div>
+            </div>
+        {% endif %}
+
+        <!-- Script Iterations -->
+        {% for repeat_index, phase_list in grouped.script.items()|sort %}
+            <div class="mb-4" id="card-iter{{ repeat_index }}">
+                <h4 class="text-success mb-3">
+                    <i class="fas fa-redo me-2"></i>Iteration {{ repeat_index }}
+                </h4>
+                <div class="row">
+                    {% for phase in phase_list %}
+                        <div class="col-lg-6 mb-3">
+                            {% include "components/step_card.html" %}
+                        </div>
+                    {% endfor %}
+                </div>
+            </div>
+        {% endfor %}
+
+        <!-- Cleanup Phase -->
+        {% if grouped.cleanup %}
+            <div>
+                <h4 class="text-warning mb-3">
+                    <i class="fas fa-broom me-2"></i>Cleanup
+                </h4>
+                <div class="row">
+                    {% for phase in grouped.cleanup %}
+                        <div class="col-lg-6 mb-3">
+                            {% include "components/step_card.html" %}
+                        </div>
+                    {% endfor %}
+                </div>
+            </div>
+        {% endif %}
+    </div>
+
+
+
+<!-- External Dependencies -->
 <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"/>
+<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
 
-<h1>Experiment Step View</h1>
+<script type="text/javascript">
+    document.addEventListener('DOMContentLoaded', function() {
+        // ---------------- Timeline Setup ----------------
+        const container = document.getElementById('visualization');
+        const groups = [
+            { id: 'all', content: 'Workflow Execution' }
+        ];
 
-<div id="visualization"></div>
+        const items = [
+            {% if grouped.prep %}
+                {
+                    id: 'prep',
+                    content: 'Prep',
+                    start: '{{ grouped.prep[0].start_time }}',
+                    end: '{{ grouped.prep[-1].end_time }}',
+                    className: 'prep',
+                    group: 'all',
+                },
+            {% endif %}
 
-<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' });
-      }
-    }
-  });
+            {% 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: 'all',
+                },
+                {% 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: 'all',
+                            title: 'Stop event at {{ step.start_time }}'
+                        },
+                    {% endif %}
+                {% endfor %}
+            {% endfor %}
+
+            {% if grouped.cleanup %}
+                {
+                    id: 'cleanup',
+                    content: 'Cleanup ',
+                    start: '{{ grouped.cleanup[0].start_time }}',
+                    end: '{{ grouped.cleanup[-1].end_time }}',
+                    className: 'cleanup',
+                    group: 'all',
+                },
+            {% endif %}
+        ];
+
+        var timeline = new vis.Timeline(container, items, groups, {
+            clickToUse: true,
+            stack: false,        // keep items from overlapping vertically
+            horizontalScroll: true,
+            zoomKey: 'ctrlKey'
+        });
+
+        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' });
+                }
+            }
+        });
+
+        // ---------------- Phase Data Plot ----------------
+        const loadingSpinner = document.querySelector('.loading-spinner');
+        const select = document.getElementById('output-select');
+
+        loadingSpinner.style.display = 'block';
+
+
+        fetch("{{ url_for('data.workflow_phase_data', workflow_id=workflow.id) }}")
+            .then(res => {
+                if (!res.ok) {
+                    throw new Error(`HTTP error! status: ${res.status}`);
+                }
+                return res.json();
+            })
+            .then(data => {
+                loadingSpinner.style.display = 'none';
+
+                const repeatKeys = Object.keys(data).sort((a, b) => a - b);
+                const dataSection = document.querySelector('.data-section'); // Get the entire section
+
+                if (!repeatKeys.length) {
+                    // Hide the entire data section if no data
+                    dataSection.style.display = 'none';
+                    return;
+                }
+
+                const allKeys = new Set();
+                repeatKeys.forEach(k => {
+                    Object.keys(data[k]).forEach(key => allKeys.add(key));
+                });
+
+                // If no keys found, also hide the section
+                if (allKeys.size === 0) {
+                    dataSection.style.display = 'none';
+                    return;
+                }
+
+                // Show the data section since we have data
+                dataSection.style.display = 'block';
+
+                // Clear and populate select options
+                select.innerHTML = '';
+                allKeys.forEach(k => {
+                    const option = new Option(k, k);
+                    select.appendChild(option);
+                });
+
+                function plotData(selectedKey) {
+                    const x = [];
+                    const y = [];
+
+                    repeatKeys.forEach(repeat_index => {
+                        const arr = data[repeat_index][selectedKey];
+                        if (arr && arr.length) {
+                            arr.forEach(d => {
+                                if (typeof d === 'object' && d.x !== undefined && d.y !== undefined) {
+                                    x.push(d.x);
+                                    y.push(d.y);
+                                } else if (typeof d === 'number') {
+                                    x.push(parseInt(repeat_index));
+                                    y.push(d);
+                                }
+                            });
+                        }
+                    });
+
+                    const trace = {
+                        x: x,
+                        y: y,
+                        mode: 'markers',
+                        name: selectedKey,
+                    };
+
+                    const layout = {
+                        xaxis: {
+                            title: 'Iteration Index',
+                            gridcolor: '#e9ecef'
+                        },
+                        yaxis: {
+                            title: selectedKey,
+                            gridcolor: '#e9ecef'
+                        },
+                        plot_bgcolor: '#ffffff',
+                        paper_bgcolor: '#ffffff',
+                        margin: { t: 60, r: 40, b: 60, l: 80 }
+                    };
+
+                    const config = {
+                        responsive: true,
+                        displayModeBar: true,
+                        modeBarButtonsToRemove: ['lasso2d', 'select2d']
+                    };
+
+                    Plotly.newPlot('phase-plot', [trace], layout, config);
+                }
+
+                select.addEventListener('change', e => {
+                    if (e.target.value) {
+                        plotData(e.target.value);
+                    }
+                });
+
+                // Plot first available data type
+                if (allKeys.size > 0) {
+                    plotData([...allKeys][0]);
+                }
+            })
+            .catch(error => {
+                loadingSpinner.style.display = 'none';
+                console.error('Error loading phase data:', error);
+
+                const dataSection = document.querySelector('.data-section');
+                // Hide the section on error as well
+                dataSection.style.display = 'none';
+
+                // Optionally, you could show an error message instead:
+                // dataSection.innerHTML = `
+                //     <div class="alert alert-danger m-3" role="alert">
+                //         <i class="fas fa-exclamation-triangle me-2"></i>
+                //         <strong>Error:</strong> Unable to load phase data. ${error.message}
+                //     </div>
+                // `;
+            });
+    });
 </script>
 
-<h2>Workflow: {{ workflow.name }}</h2>
-
-{% if grouped.prep %}
-  <h4 class="mt-4">Prep Phase</h4>
-  {% for step in grouped.prep %}
-    {% include "components/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 "components/step_card.html" %}
-  {% endfor %}
-{% endfor %}
-
-{% if grouped.cleanup %}
-  <h4 class="mt-4">Cleanup Phase</h4>
-  {% for step in grouped.cleanup %}
-    {% include "components/step_card.html" %}
-  {% endfor %}
-{% endif %}
 {% endblock %}

ivoryos/server.py

@@ -94,12 +94,12 @@ def run(module=None, host="0.0.0.0", port=None, debug=None, llm_server=None, mod
         app.config["MODULE"] = module
         app.config["OFF_LINE"] = False
         global_config.deck = sys.modules[module]
+        global_config.building_blocks = utils.create_block_snapshot()
         global_config.deck_snapshot = utils.create_deck_snapshot(global_config.deck,
                                                                  output_path=dummy_deck_path,
                                                                  save=True,
                                                                  exclude_names=exclude_names
                                                                  )
-        global_config.building_blocks = utils.create_block_snapshot()
 
     else:
         app.config["OFF_LINE"] = True

ivoryos/static/js/socket_handler.js

@@ -1,5 +1,5 @@
 document.addEventListener("DOMContentLoaded", function() {
-    var socket = io.connect('http://' + document.domain + ':' + location.port);
+    var socket = io();
     socket.on('connect', function() {
         console.log('Connected');
     });

ivoryos/utils/db_models.py

@@ -689,6 +689,7 @@ class Script(db.Model):
         return "\n".join(lines)
 
 class WorkflowRun(db.Model):
+    """Represents the entire experiment"""
     __tablename__ = 'workflow_runs'
 
     id = db.Column(db.Integer, primary_key=True)
@@ -697,30 +698,65 @@ class WorkflowRun(db.Model):
     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',
+    repeat_mode = db.Column(db.String(64), default="none")  # static_repeat, sweep, optimizer
+
+    # A run contains multiple iterations
+    phases = db.relationship(
+        'WorkflowPhase',
+        backref='workflow_runs', # Clearer back-reference name
         cascade='all, delete-orphan',
-        passive_deletes=True
+        lazy='dynamic' # Good for handling many iterations
     )
     def as_dict(self):
         dict = self.__dict__
         dict.pop('_sa_instance_state', None)
         return dict
 
+class WorkflowPhase(db.Model):
+    """Represents a single function call within a WorkflowRun."""
+    __tablename__ = 'workflow_phases'
+
+    id = db.Column(db.Integer, primary_key=True)
+    # Foreign key to link this iteration to its parent run
+    run_id = db.Column(db.Integer, db.ForeignKey('workflow_runs.id', ondelete='CASCADE'), nullable=False)
+
+    # NEW: Store iteration-specific parameters here
+    name = db.Column(db.String(64), nullable=False)  # 'prep', 'main', 'cleanup'
+    repeat_index = db.Column(db.Integer, default=0)
+
+    parameters = db.Column(JSONType)  # Use db.JSON for general support
+    outputs = db.Column(JSONType)
+    start_time = db.Column(db.DateTime, default=datetime.now)
+    end_time = db.Column(db.DateTime)
+
+    # An iteration contains multiple steps
+    steps = db.relationship(
+        'WorkflowStep',
+        backref='workflow_phases',  # Clearer back-reference name
+        cascade='all, delete-orphan'
+    )
+
+    def as_dict(self):
+        dict = self.__dict__.copy()
+        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)
+    # workflow_id = db.Column(db.Integer, db.ForeignKey('workflow_runs.id', ondelete='CASCADE'), nullable=True)
+    phase_id = db.Column(db.Integer, db.ForeignKey('workflow_phases.id', ondelete='CASCADE'), nullable=True)
 
-    phase = db.Column(db.String(64), nullable=False)  # 'prep', 'main', 'cleanup'
-    repeat_index = db.Column(db.Integer, default=0)   # Only applies to 'main' phase
+    # 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)
+    output = db.Column(JSONType, default={})
+    # Using as_dict method from ModelBase
 
     def as_dict(self):
         dict = self.__dict__.copy()
@@ -737,7 +773,7 @@ class SingleStep(db.Model):
     start_time = db.Column(db.DateTime)
     end_time = db.Column(db.DateTime)
     run_error = db.Column(db.String(128))
-    output = db.Column(JSONType)
+    output = db.Column(JSONType, nullable=True)
 
     def as_dict(self):
         dict = self.__dict__.copy()

ivoryos/utils/form.py

@@ -210,10 +210,10 @@ class FlexibleEnumField(StringField):
             if key in self.choices:
                 # Convert the string key to Enum instance
                 self.data = self.enum_class[key].value
-            elif self.data.startswith("#"):
+            elif key.startswith("#"):
                 if not self.script.editing_type == "script":
                     raise ValueError(self.gettext("Variable is not supported in prep/cleanup"))
-                self.data = self.data
+                self.data = key
             else:
                 raise ValidationError(
                     f"Invalid choice: '{key}'. Must match one of {list(self.enum_class.__members__.keys())}")
@@ -286,7 +286,9 @@ def create_form_for_method(method, autofill, script=None, design=True):
             # 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)

ivoryos/utils/script_runner.py

@@ -6,7 +6,7 @@ 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.db_models import Script, WorkflowRun, WorkflowStep, db, WorkflowPhase
 from ivoryos.utils.global_config import GlobalConfig
 from ivoryos.utils.decorators import BUILDING_BLOCKS
 
@@ -93,7 +93,7 @@ class ScriptRunner:
         thread.start()
         return thread
 
-    def exec_steps(self, script, section_name, logger, socketio, run_id, i_progress, **kwargs):
+    def exec_steps(self, script, section_name, logger, socketio, phase_id, **kwargs):
         """
         Executes a function defined in a string line by line
         :param func_str: The function as a string
@@ -136,9 +136,9 @@ class ScriptRunner:
             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,
+                    phase_id=phase_id,
+                    # phase=section_name,
+                    # repeat_index=i_progress,
                     step_index=index,
                     method_name="stop",
                     start_time=datetime.now(),
@@ -148,21 +148,24 @@ class ScriptRunner:
                 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()
+
+            method_name = line.strip()
+            # start_time = datetime.now()
+
             step = WorkflowStep(
-                workflow_id=run_id,
-                phase=section_name,
-                repeat_index=i_progress,
+                phase_id=phase_id,
+                # phase=section_name,
+                # repeat_index=i_progress,
                 step_index=index,
                 method_name=method_name,
-                start_time=start_time,
+                start_time=datetime.now(),
             )
             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:
@@ -172,12 +175,13 @@ class ScriptRunner:
                     self.safe_sleep(duration)
                 else:
                     exec(line, exec_globals, exec_locals)
-                step.run_error = False
+                # step.run_error = False
 
             except HumanInterventionRequired as e:
                 logger.warning(f"Human intervention required: {e}")
                 socketio.emit('human_intervention', {'message': str(e)})
                 # Instead of auto-resume, explicitly stay paused until user action
+                # step.run_error = False
                 self.toggle_pause()
 
             except Exception as e:
@@ -187,7 +191,7 @@ class ScriptRunner:
                 step.run_error = True
                 self.toggle_pause()
             step.end_time = datetime.now()
-            # db.session.add(step)
+            step.output = exec_locals
             db.session.commit()
 
             self.pause_event.wait()
@@ -195,10 +199,9 @@ class ScriptRunner:
             # 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:
+            if not step.run_error or 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,
@@ -210,14 +213,17 @@ class ScriptRunner:
         filename = None
         error_flag = False
         # create a new run entry in the database
-        try:
-            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"}
+        repeat_mode = "batch" if config else "optimizer" if bo_args or optimizer else "repeat"
+        with current_app.app_context():
+            run = WorkflowRun(name=script.name or "untitled", platform=script.deck or "deck", start_time=datetime.now(),
+                              repeat_mode=repeat_mode
+                              )
+            db.session.add(run)
+            db.session.commit()
+            run_id = run.id  # Save the ID
+            try:
 
+                global_config.runner_status = {"id":run_id, "type": "workflow"}
                 # Run "prep" section once
                 self._run_actions(script, section_name="prep", logger=logger, socketio=socketio, run_id=run_id)
                 output_list = []
@@ -234,35 +240,52 @@ class ScriptRunner:
                 # 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
-
                 # Save results if necessary
-
                 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)
 
-        except Exception as e:
-            logger.error(f"Error during script execution: {e.__str__()}")
-            error_flag = True
-        finally:
-            self.lock.release()
-            with current_app.app_context():
-                run = db.session.get(WorkflowRun, run_id)
-                run.end_time = datetime.now()
-                run.data_path = filename
-                run.run_error = error_flag
-                db.session.commit()
+            except Exception as e:
+                logger.error(f"Error during script execution: {e.__str__()}")
+                error_flag = True
+            finally:
+                self.lock.release()
+        with current_app.app_context():
+            run = db.session.get(WorkflowRun, run_id)
+            run.end_time = datetime.now()
+            run.data_path = filename
+            run.run_error = error_flag
+            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 not step_list:
+            logger.info(f'No {section_name} steps')
+            return None
+
+        logger.info(f'Executing {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)
+            return None
+
+        phase = WorkflowPhase(
+            run_id=run_id,
+            name=section_name,
+            repeat_index=0,
+            start_time=datetime.now()
+        )
+        db.session.add(phase)
+        db.session.commit()
+        phase_id = phase.id
+
+        step_outputs = self.exec_steps(script, section_name, logger, socketio, phase_id=phase_id)
+        # Save phase-level output
+        phase.outputs = step_outputs
+        phase.end_time = datetime.now()
+        db.session.commit()
+        return step_outputs
 
     def _run_config_section(self, config, arg_type, output_list, script, run_name, logger, socketio, run_id, compiled=True):
         if not compiled:
@@ -285,10 +308,25 @@ class ScriptRunner:
                 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)
+
+                phase = WorkflowPhase(
+                    run_id=run_id,
+                    name="main",
+                    repeat_index=i,
+                    parameters=kwargs,
+                    start_time=datetime.now()
+                )
+                db.session.add(phase)
+                db.session.commit()
+
+                phase_id = phase.id
+                output = self.exec_steps(script, "script", logger, socketio, phase_id, **kwargs)
                 if output:
                     # kwargs.update(output)
                     output_list.append(output)
+                    phase.outputs = {k:v for k, v in output.items() if k not in arg_type.keys()}
+                phase.end_time = datetime.now()
+                db.session.commit()
 
     def _run_repeat_section(self, repeat_count, arg_types, bo_args, output_list, script, run_name, return_list, compiled,
                             logger, socketio, history, output_path, run_id, optimizer=None):
@@ -325,6 +363,17 @@ class ScriptRunner:
             if self.stop_pending_event.is_set():
                 logger.info(f'Stopping execution during {run_name}: {i_progress + 1}/{int(repeat_count)}')
                 break
+
+            phase = WorkflowPhase(
+                run_id=run_id,
+                name="main",
+                repeat_index=i_progress,
+                start_time=datetime.now()
+            )
+            db.session.add(phase)
+            db.session.commit()
+            phase_id = phase.id
+
             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)
@@ -334,7 +383,9 @@ class ScriptRunner:
                     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)
+                    phase.parameters = parameters
+
+                    output = self.exec_steps(script, "script", logger, socketio, phase_id, **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)
@@ -346,7 +397,8 @@ class ScriptRunner:
                 try:
                     parameters = optimizer.suggest(1)
                     logger.info(f'Output value: {parameters}')
-                    output = self.exec_steps(script, "script", logger, socketio, run_id, i_progress, **parameters)
+                    phase.parameters = parameters
+                    output = self.exec_steps(script, "script", logger, socketio, phase_id, **parameters)
                     if output:
                         optimizer.observe(output)
                         output.update(parameters)
@@ -356,17 +408,20 @@ class ScriptRunner:
             else:
                 # fname = f"{run_name}_script"
                 # function = self.globals_dict[fname]
-                output = self.exec_steps(script, "script", logger, socketio, run_id, i_progress)
+                output = self.exec_steps(script, "script", logger, socketio, phase_id)
 
             if output:
                 output_list.append(output)
                 logger.info(f'Output value: {output}')
+                phase.outputs = output
+            phase.end_time = datetime.now()
+            db.session.commit()
 
         if bo_args:
             ax_client.save_to_json_file(os.path.join(output_path, f"{run_name}_ax_client.json"))
-        logger.info(
-            f'Optimization complete. Results saved to {os.path.join(output_path, f"{run_name}_ax_client.json")}'
-        )
+            logger.info(
+                f'Optimization complete. Results saved to {os.path.join(output_path, f"{run_name}_ax_client.json")}'
+            )
         return output_list
 
     @staticmethod

ivoryos/utils/utils.py

@@ -349,8 +349,8 @@ def create_deck_snapshot(deck, save: bool = False, output_path: str = '', exclud
             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_section("✅ INCLUDED MODULES", deck_summary["included"])
+        print_section("❌ FAILED MODULES", deck_summary["failed"])
         print("\n")
 
     print_deck_snapshot(deck_summary)
@@ -380,7 +380,10 @@ def create_block_snapshot(save: bool = False, output_path: str = ''):
                 "docstring": meta["docstring"],
                 "path": f"{func.__module__}.{func.__qualname__}"
             }
-    print(block_snapshot)
+    if block_snapshot:
+        print(f"\n=== ✅ BUILDING_BLOCKS ({len(block_snapshot)}) ===")
+        for category, blocks in block_snapshot.items():
+            print(f"  {category}: ", ",".join(blocks.keys()))
     return block_snapshot
 
 def load_deck(pkl_name: str):

ivoryos/version.py

@@ -1 +1 @@
-__version__ = "1.2.8"
+__version__ = "1.3.0a0"

{ivoryos-1.2.8.dist-info → ivoryos-1.3.0a0.dist-info}/METADATA

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

{ivoryos-1.2.8.dist-info → ivoryos-1.3.0a0.dist-info}/RECORD

@@ -1,15 +1,15 @@
 ivoryos/__init__.py,sha256=eUtNgSskl--l94VUTT1bgiBR8gdMMFQgjHEsHOxdHyI,320
-ivoryos/app.py,sha256=yU3f4mu2LL82NEPvQid5GWdfrIa4F_04Feb0bl-ICV4,3323
+ivoryos/app.py,sha256=tnFimgKnjRLhgIiraAVhEZFmcp6TGho7mQ5a5Y35rlY,4794
 ivoryos/config.py,sha256=y3RxNjiIola9tK7jg-mHM8EzLMwiLwOzoisXkDvj0gA,2174
-ivoryos/server.py,sha256=2ka-xqWpuY9HIqxtA24jU_dIX51DRx1ccejpJnBKgaE,6742
+ivoryos/server.py,sha256=K0_Ioui0uKshKl5fxGB_1wJD4OckXyR9DdOfCIhvkfE,6742
 ivoryos/socket_handlers.py,sha256=VWVWiIdm4jYAutwGu6R0t1nK5MuMyOCL0xAnFn06jWQ,1302
-ivoryos/version.py,sha256=CfVXm0wwlKPW0khOcwhWw61TpgtZiLijCePsAIOK3aU,22
+ivoryos/version.py,sha256=GwyZSgQ0KlyF3ijF7TCPwJatDgrQSpWwNG6zXK-nBNM,24
 ivoryos/optimizer/ax_optimizer.py,sha256=PoSu8hrDFFpqyhRBnaSMswIUsDfEX6sPWt8NEZ_sobs,7112
 ivoryos/optimizer/base_optimizer.py,sha256=JTbUharZKn0t8_BDbAFuwZIbT1VOnX1Xuog1pJuU8hY,1992
 ivoryos/optimizer/baybe_optimizer.py,sha256=EdrrRiYO-IOx610cPXiQhH4qG8knUP0uiZ0YoyaGIU8,7954
 ivoryos/optimizer/registry.py,sha256=lr0cqdI2iEjw227ZPRpVkvsdYdddjeJJRzawDv77cEc,219
 ivoryos/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivoryos/routes/api/api.py,sha256=1Hq4FOBtSEXqjataoPUdAWHvezw07xqhEI1fJdoSn5U,2284
+ivoryos/routes/api/api.py,sha256=97Y7pqTwOaWgZgI5ovEPxEBm6Asrt0Iy0VhBkVp2xqA,2304
 ivoryos/routes/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/auth/auth.py,sha256=CqoP9cM8BuXVGHGujX7-0sNAOdWILU9amyBrObOD6Ss,3283
 ivoryos/routes/auth/templates/login.html,sha256=WSRrKbdM_oobqSXFRTo-j9UlOgp6sYzS9tm7TqqPULI,1207
@@ -19,13 +19,13 @@ ivoryos/routes/control/control.py,sha256=6LnVF4mGgfLQvzmrSFxaFz9lBtBe4WnXlIouDxt
 ivoryos/routes/control/control_file.py,sha256=3fQ9R8EcdqKs_hABn2EqRAB1xC2DHAT_q_pwsMIDDQI,864
 ivoryos/routes/control/control_new_device.py,sha256=mfJKg5JAOagIpUKbp2b5nRwvd2V3bzT3M0zIhIsEaFM,5456
 ivoryos/routes/control/utils.py,sha256=XlhhqAtOj7n3XfHPDxJ8TvCV2K2I2IixB0CBkl1QeQc,1242
-ivoryos/routes/control/templates/controllers.html,sha256=XoV1HVjB6ho4Ah8HerqqmbiWK0N_HyFKhmqu4E2JXdM,8966
+ivoryos/routes/control/templates/controllers.html,sha256=5hF3zcx5Rpy0Zaoq-5YGrR_TvPD9MGIa30fI4smEii0,9702
 ivoryos/routes/control/templates/controllers_new.html,sha256=eVeLABT39DWOIYrwWClw7sAD3lCoAGCznygPgFbQoRc,5945
 ivoryos/routes/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivoryos/routes/data/data.py,sha256=AoqCaIAK0f9hstF1pxlJFeK_J-wKbMfXWGNDUbaBFFk,4218
+ivoryos/routes/data/data.py,sha256=wJCd9TytdYCeU6BaGEUhBQHRYo7yn9OagIWa2qwSZEo,5583
 ivoryos/routes/data/templates/workflow_database.html,sha256=ofvHcovpwmJXo1SFiSrL8I9kLU_3U1UxsJUUrQ2CJUU,4878
-ivoryos/routes/data/templates/workflow_view.html,sha256=72xKreX9WhYx-0n0cFf-CL-fJIWXPCIaTi_Aa8Tq3xg,3651
-ivoryos/routes/data/templates/components/step_card.html,sha256=9lKR4NCgU2v5Nbdv2uaJ-9aKibtiB_2-Y_kyHX6Ka1k,730
+ivoryos/routes/data/templates/workflow_view.html,sha256=Ti17kzlPlYTmzx5MkdsPlXJ1_k6QgMYQBM6FHjG50go,12491
+ivoryos/routes/data/templates/components/step_card.html,sha256=XWsr7qxAY76RCuQHETubWjWBlPgs2HkviH4ju6qfBKo,1923
 ivoryos/routes/design/__init__.py,sha256=zS3HXKaw0ALL5n6t_W1rUz5Uj5_tTQ-Y1VMXyzewvR0,113
 ivoryos/routes/design/design.py,sha256=xYDwtCdTcCd282guaIeNvfUFc5UsiypkQVpRvFqRujQ,18246
 ivoryos/routes/design/design_file.py,sha256=m4yku8fkpLUs4XvLJBqR5V-kyaGKbGB6ZoRxGbjEU5Q,2140
@@ -78,7 +78,7 @@ ivoryos/static/js/action_handlers.js,sha256=UJHKFhYRNQRBo0AHLCIxhWxt8OSgYeyLynzP
 ivoryos/static/js/db_delete.js,sha256=l67fqUaN_FVDaL7v91Hd7LyRbxnqXx9nyjF34-7aewY,561
 ivoryos/static/js/overlay.js,sha256=dPxop19es0E0ZUSY3d_4exIk7CJuQEnlW5uTt5fZfzI,483
 ivoryos/static/js/script_metadata.js,sha256=m8VYZ8OGT2oTx1kXMXq60bKQI9WCbJNkzcFDzLvRuGc,1188
-ivoryos/static/js/socket_handler.js,sha256=vrpVyYMsFpHIJjqke5LwVttRI6IJMXSx_D0AMhWRg3k,6906
+ivoryos/static/js/socket_handler.js,sha256=5MGLj-nNA3053eBcko4MZAB5zq2mkgr1g__c_rr3cE8,6849
 ivoryos/static/js/sortable_card.js,sha256=ifmlGe3yy0U_KzMphV4ClRhK2DLOvkELYMlq1vECuac,807
 ivoryos/static/js/sortable_design.js,sha256=ASc9P6_423Mczeg6QH6LVtyxLyWhpxWJP2nEEjR9K1M,5474
 ivoryos/static/js/ui_state.js,sha256=XYsOcfGlduqLlqHySvPrRrR50CiAsml51duqneigsRY,3368
@@ -86,18 +86,18 @@ ivoryos/templates/base.html,sha256=cl5w6E8yskbUzdiJFal6fZjnPuFNKEzc7BrrbRd6bMI,8
 ivoryos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/utils/bo_campaign.py,sha256=Fil-zT7JexL_p9XqyWByjAk42XB1R9XUKN8CdV5bi6c,9714
 ivoryos/utils/client_proxy.py,sha256=74G3HAuq50iEHkSvlMZFmQaukm613FbRgOdzO_T3dMg,10191
-ivoryos/utils/db_models.py,sha256=aJ9JOmKERXqGrhSTqIbdTGeq16aalDUaOmU3kvZvx0U,29542
+ivoryos/utils/db_models.py,sha256=TaRA65Zmj2lIqQk5sDoQzP_od6QnPUYJgvDAV9LkqYM,31074
 ivoryos/utils/decorators.py,sha256=p1Bdl3dCeaHNv6-cCCUOZMiFu9kRaqqQnkFJUkzPoJE,991
-ivoryos/utils/form.py,sha256=G9wkxCF3aozWBvm865DcCkA6G4dQfNQWKlPejYp5t-U,22311
+ivoryos/utils/form.py,sha256=Ej9tx06KZZ5fPQm1ho1byotNocF3u24aatc2ZyI0rK4,22301
 ivoryos/utils/global_config.py,sha256=D6oz5dttyaP24jbqnw1sR64moSb-7jJkSpRuufdA_TI,2747
 ivoryos/utils/llm_agent.py,sha256=-lVCkjPlpLues9sNTmaT7bT4sdhWvV2DiojNwzB2Lcw,6422
 ivoryos/utils/py_to_json.py,sha256=fyqjaxDHPh-sahgT6IHSn34ktwf6y51_x1qvhbNlH-U,7314
-ivoryos/utils/script_runner.py,sha256=gQp37yzlo04h6bxbHloOOim4cLn43S0web7-XN2TQjA,17799
+ivoryos/utils/script_runner.py,sha256=TksUOaisnGj-A3lT78Ni6ilK_huc96WSq2uUPEcxdek,19354
 ivoryos/utils/serilize.py,sha256=lkBhkz8r2bLmz2_xOb0c4ptSSOqjIu6krj5YYK4Nvj8,6784
 ivoryos/utils/task_runner.py,sha256=bfG6GubdlzgD8rBwzD00aGB5LDFmb9hLFJIOMH8hVv4,3248
-ivoryos/utils/utils.py,sha256=JfDANbhjD6eBJTKeTtEn6B060jd9HACMLxrrQjJzaAI,14589
-ivoryos-1.2.8.dist-info/licenses/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
-ivoryos-1.2.8.dist-info/METADATA,sha256=lw0l8cYCIOBgPxYj3PxoOcAwyLDUL4T6Ij_DrRQsBXc,7351
-ivoryos-1.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ivoryos-1.2.8.dist-info/top_level.txt,sha256=FRIWWdiEvRKqw-XfF_UK3XV0CrnNb6EmVbEgjaVazRM,8
-ivoryos-1.2.8.dist-info/RECORD,,
+ivoryos/utils/utils.py,sha256=09VPNRaIoA-mp1TXLGC3BwM2tDaAJ36csvNtW19KsU0,14792
+ivoryos-1.3.0a0.dist-info/licenses/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
+ivoryos-1.3.0a0.dist-info/METADATA,sha256=kZj0TN3_lInWJMDyHoTX6hpH8ACgKwMX7UkT4kpdDeo,7353
+ivoryos-1.3.0a0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ivoryos-1.3.0a0.dist-info/top_level.txt,sha256=FRIWWdiEvRKqw-XfF_UK3XV0CrnNb6EmVbEgjaVazRM,8
+ivoryos-1.3.0a0.dist-info/RECORD,,