ivoryos 1.2.7__py3-none-any.whl → 1.3.0__py3-none-any.whl

ivoryos/__init__.py

@@ -1,248 +1,13 @@
-import os
-import sys
-import uuid
-from typing import Union
-
-from flask import Flask, redirect, url_for, g, Blueprint, session
-from flask_login import AnonymousUserMixin
-
-# sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-
-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.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.server import run
 from ivoryos.optimizer.registry import OPTIMIZER_REGISTRY
-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=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}')
-
-@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, 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()
-
-    # 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
-
-
-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"])
-    global_config.optimizers = OPTIMIZER_REGISTRY
-    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_local_ip()
-        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
+from ivoryos.utils.decorators import block, BUILDING_BLOCKS
 
 
-def load_plugins(blueprints: Union[list, Blueprint], app, socketio):
-    """
-    Dynamically load installed plugins and attach Flask-SocketIO.
-    :param blueprints: Union[list, Blueprint] list of Blueprint objects or a single Blueprint object
-    :param app: Flask application instance
-    :param socketio: Flask-SocketIO instance
-    :return: list of plugin names
-    """
-    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
+__all__ = [
+    "block",
+    "BUILDING_BLOCKS",
+    "OPTIMIZER_REGISTRY",
+    "run",
+    "ivoryos_version",
+]

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/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/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/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/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/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>")