ivoryos 1.3.8__tar.gz → 1.4.0__tar.gz

{ivoryos-1.3.8 → ivoryos-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivoryos
-Version: 1.3.8
+Version: 1.4.0
 Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
 Author-email: Ivory Zhang <ivoryzhang@chem.ubc.ca>
 License: MIT
@@ -17,6 +17,7 @@ Requires-Dist: Flask-SQLAlchemy
 Requires-Dist: Flask-WTF
 Requires-Dist: SQLAlchemy-Utils
 Requires-Dist: python-dotenv
+Requires-Dist: pandas
 Requires-Dist: astor; python_version < "3.9"
 Provides-Extra: optimizer-ax
 Requires-Dist: ax-platform; extra == "optimizer-ax"
@@ -26,7 +27,7 @@ Provides-Extra: optimizer-nimo
 Requires-Dist: nimo; extra == "optimizer-nimo"
 Provides-Extra: optimizer
 Requires-Dist: ax-platform>=1.1.2; extra == "optimizer"
-Requires-Dist: baybe; extra == "optimizer"
+Requires-Dist: baybe>=0.14.0; extra == "optimizer"
 Provides-Extra: doc
 Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: sphinx-rtd-theme; extra == "doc"

{ivoryos-1.3.8 → ivoryos-1.4.0}/ivoryos/optimizer/ax_optimizer.py

@@ -1,25 +1,28 @@
 # optimizers/ax_optimizer.py
 from typing import Dict
 
-
+from pandas import DataFrame
 
 from ivoryos.optimizer.base_optimizer import OptimizerBase
 from ivoryos.utils.utils import install_and_import
 
 class AxOptimizer(OptimizerBase):
-    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config=None):
+    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config=None,
+                 parameter_constraints:list=None, datapath=None):
+        self.trial_index_list = None
         try:
             from ax.api.client import Client
         except ImportError as e:
             install_and_import("ax", "ax-platform")
             raise ImportError("Please install Ax with pip install ax-platform to use AxOptimizer. Attempting to install Ax...")
-        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config)
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config, parameter_constraints, )
 
         self.client = Client()
         # 2. Configure where Ax will search.
         self.client.configure_experiment(
             name=experiment_name,
-            parameters=self._convert_parameter_to_ax_format(parameter_space)
+            parameters=self._convert_parameter_to_ax_format(parameter_space),
+            parameter_constraints=parameter_constraints
         )
         # 3. Configure the objective function.
         self.client.configure_optimization(objective=self._convert_objective_to_ax_format(objective_config))
@@ -48,12 +51,17 @@ class AxOptimizer(OptimizerBase):
         ax_params = []
         for p in parameter_space:
             if p["type"] == "range":
-                ax_params.append(
-                    RangeParameterConfig(
-                        name=p["name"],
-                        bounds=tuple(p["bounds"]),
-                        parameter_type=p["value_type"]
-                    ))
+                # if step is used here, convert to ChoiceParameterConfig
+                if  len(p["bounds"]) == 3:
+                    values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                    ax_params.append(ChoiceParameterConfig(name=p["name"], values=values, parameter_type="int", is_ordered=True))
+                else:
+                    ax_params.append(
+                        RangeParameterConfig(
+                            name=p["name"],
+                            bounds=tuple(p["bounds"]),
+                            parameter_type=p["value_type"]
+                        ))
             elif p["type"] == "choice":
                 ax_params.append(
                     ChoiceParameterConfig(
@@ -101,15 +109,22 @@ class AxOptimizer(OptimizerBase):
         return GenerationStrategy(steps=[generator_1, generator_2])
 
     def suggest(self, n=1):
-        trial_index, params = self.client.get_next_trials(1).popitem()
-        self.trial_index = trial_index
-        return params
+        trials = self.client.get_next_trials(n)
+        trial_index_list = []
+        param_list = []
+        for trial_index, params in trials.items():
+            trial_index_list.append(trial_index)
+            param_list.append(params)
+        self.trial_index_list = trial_index_list
+        return param_list
 
     def observe(self, results):
-        self.client.complete_trial(
-            trial_index=self.trial_index,
-            raw_data=results
-        )
+        for trial_index, result in zip(self.trial_index_list, results):
+            obj_only_result = {k: v for k, v in result.items() if k in [obj["name"] for obj in self.objective_config]}
+            self.client.complete_trial(
+                trial_index=trial_index,
+                raw_data=obj_only_result
+            )
 
     @staticmethod
     def get_schema():
@@ -117,29 +132,33 @@ class AxOptimizer(OptimizerBase):
             "parameter_types": ["range", "choice"],
             "multiple_objectives": True,
             # "objective_weights": True,
+            "supports_continuous": True,
+            "supports_constraints": True,
             "optimizer_config": {
                 "step_1": {"model": ["Sobol", "Uniform", "Factorial", "Thompson"], "num_samples": 5},
                 "step_2": {"model": ["BoTorch", "SAASBO", "SAAS_MTGP", "Legacy_GPEI", "EB", "EB_Ashr", "ST_MTGP", "BO_MIXED", "Contextual_SACBO"]}
             },
+
         }
 
-    def append_existing_data(self, existing_data):
+    def append_existing_data(self, existing_data:DataFrame):
         """
         Append existing data to the Ax experiment.
         :param existing_data: A dictionary containing existing data.
         """
-        from pandas import DataFrame
-        if not existing_data:
-            return
+
         if isinstance(existing_data, DataFrame):
+            if existing_data.empty:
+                return
             existing_data = existing_data.to_dict(orient="records")
         parameter_names = [i.get("name") for i in self.parameter_space]
         objective_names = [i.get("name") for i in self.objective_config]
-        for name, value in existing_data.items():
-            # First attach the trial and note the trial index
-            parameters = {name: value for name in existing_data if name in parameter_names}
+        for entry in existing_data:
+            # for name, value in entry.items():
+                # First attach the trial and note the trial index
+            parameters = {name: value for name, value in entry.items() if name in parameter_names}
             trial_index = self.client.attach_trial(parameters=parameters)
-            raw_data = {name: value for name in existing_data if name in objective_names}
+            raw_data = {name: value for name, value in entry.items() if name in objective_names}
             # Then complete the trial with the existing data
             self.client.complete_trial(trial_index=trial_index, raw_data=raw_data)
 

{ivoryos-1.3.8 → ivoryos-1.4.0}/ivoryos/optimizer/base_optimizer.py

@@ -5,7 +5,8 @@ from abc import ABC, abstractmethod
 
 
 class OptimizerBase(ABC):
-    def __init__(self, experiment_name:str, parameter_space: list, objective_config: dict, optimizer_config: dict, datapath:str=None):
+    def __init__(self, experiment_name:str, parameter_space: list, objective_config: dict, optimizer_config: dict,
+                 parameter_constraints:list=None, datapath:str=None):
         """
         :param experiment_name: arbitrary name
         :param parameter_space: list of parameter names
@@ -47,6 +48,19 @@ class OptimizerBase(ABC):
     def append_existing_data(self, existing_data):
         pass
 
+    @staticmethod
+    def _create_discrete_search_space(range_with_step=None, value_type ="float"):
+        if range_with_step is None:
+            range_with_step = []
+        import numpy as np
+        low, high, step = range_with_step
+        values = np.arange(low, high + 1e-9 * step, step).tolist()
+        if value_type == "float":
+            values = [float(v) for v in values]
+        if value_type == "int":
+            values = [int(v) for v in values]
+        return values
+
     @staticmethod
     def get_schema():
         """

{ivoryos-1.3.8 → ivoryos-1.4.0}/ivoryos/optimizer/baybe_optimizer.py

@@ -1,19 +1,21 @@
 ### Directory: ivoryos/optimizers/baybe_optimizer.py
 from typing import Dict
 
+from pandas import DataFrame
 
 from ivoryos.utils.utils import install_and_import
 from ivoryos.optimizer.base_optimizer import OptimizerBase
 
 class BaybeOptimizer(OptimizerBase):
-    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config):
+    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config,
+                 parameter_constraints:list=None, datapath=None):
         try:
             from baybe import Campaign
         except ImportError:
             install_and_import("baybe")
             print("Please install Baybe with pip install baybe to before register BaybeOptimizer.")
 
-        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config)
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config, parameter_constraints, )
         self._trial_id = 0
         self._trials = {}
 
@@ -25,8 +27,8 @@ class BaybeOptimizer(OptimizerBase):
 
 
     def suggest(self, n=1):
-        self.df = self.experiment.recommend(batch_size=n)
-        return self.df.to_dict(orient="records")[0]
+        # self.df = self.experiment.recommend(batch_size=n)
+        return self.experiment.recommend(batch_size=n).to_dict(orient="records")
 
     def observe(self, results, index=None):
         """
@@ -35,21 +37,19 @@ class BaybeOptimizer(OptimizerBase):
         :param index: The index of the trial in the DataFrame, if applicable.
 
         """
-        for name, value in results.items():
-            self.df[name] = [value]
-        self.experiment.add_measurements(self.df)
+        df = DataFrame(results)
+        self.experiment.add_measurements(df)
 
-    def append_existing_data(self, existing_data: Dict):
+    def append_existing_data(self, existing_data: DataFrame):
         """
         Append existing data to the Ax experiment.
         :param existing_data: A dictionary containing existing data.
         """
-        import pandas as pd
-        if not existing_data:
+        if existing_data.empty:
             return
         # parameter_names = [i.get("name") for i in self.parameter_space]
         # objective_names = [i.get("name") for i in self.objective_config]
-        self.experiment.add_measurements(pd.DataFrame(existing_data))
+        self.experiment.add_measurements(existing_data)
         # for name, value in existing_data.items():
         #     # First attach the trial and note the trial index
         #     parameters = {name: value for name in existing_data if name in parameter_names}
@@ -65,9 +65,11 @@ class BaybeOptimizer(OptimizerBase):
         :param parameter_space: The parameter space configuration.
         [
             {"name": "param_1", "type": "range", "bounds": [1.0, 2.0], "value_type": "float"},
-            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
-            {"name": "param_3", "type": "range", "bounds": [0 10], "value_type": "int"},
-            {"name": "param_4", "type": "substance", "bounds": ["methanol", "water", "toluene"], "value_type": "str"} #TODO
+            {"name": "param_2", "type": "range", "bounds": [1.0, 2.0, 0.5], "value_type": "float"},
+
+            {"name": "param_3", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_4", "type": "range", "bounds": [0 10], "value_type": "int"},
+            {"name": "param_5", "type": "substance", "bounds": ["methanol", "water", "toluene"], "value_type": "str"} #TODO
         ]
         :return: A list of Baybe parameters.
         """
@@ -77,7 +79,10 @@ class BaybeOptimizer(OptimizerBase):
         parameters = []
         for p in parameter_space:
             if p["type"] == "range":
-                if p["value_type"] == "float":
+                if len(p["bounds"]) == 3:
+                    values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                    parameters.append(NumericalDiscreteParameter(name=p["name"], values=values))
+                elif p["value_type"] == "float":
                     parameters.append(NumericalContinuousParameter(name=p["name"], bounds=p["bounds"]))
                 elif p["value_type"] == "int":
                     values = tuple([int(v) for v in range(p["bounds"][0], p["bounds"][1] + 1)])
@@ -106,10 +111,10 @@ class BaybeOptimizer(OptimizerBase):
         weights = []
         for obj in objective_config:
             obj_name = obj.get("name")
-            minimize = obj.get("minimize", False)
+            minimize = obj.get("minimize", True)
             weight = obj.get("weight", 1)
             weights.append(weight)
-            targets.append(NumericalTarget(name=obj_name, mode="MAX" if minimize else "MIN"))
+            targets.append(NumericalTarget(name=obj_name, minimize=minimize))
 
         if len(targets) == 1:
             return SingleTargetObjective(target=targets[0])
@@ -156,6 +161,8 @@ class BaybeOptimizer(OptimizerBase):
         return {
             "parameter_types": ["range", "choice", "substance"],
             "multiple_objectives": True,
+            "supports_continuous": True,
+            "supports_constraints": False,
             "optimizer_config": {
                 "step_1": {"model": ["Random", "FPS"], "num_samples": 10},
                 "step_2": {"model": ["BOTorch", "Naive Hybrid Space"]}

{ivoryos-1.3.8 → ivoryos-1.4.0}/ivoryos/optimizer/nimo_optimizer.py

@@ -7,7 +7,8 @@ from ivoryos.optimizer.base_optimizer import OptimizerBase
 
 
 class NIMOOptimizer(OptimizerBase):
-    def __init__(self, experiment_name:str, parameter_space: list, objective_config: list, optimizer_config: dict, datapath:str):
+    def __init__(self, experiment_name:str, parameter_space: list, objective_config: list, optimizer_config: dict,
+                 parameter_constraints:list=None, datapath:str=None):
         """
         :param experiment_name: arbitrary name
         :param parameter_space: list of parameter names
@@ -17,14 +18,14 @@ class NIMOOptimizer(OptimizerBase):
             {"name": "param_3", "type": "range", "bounds": [0 10], "value_type": "int"},
         ]
         :param objective_config: objective configuration
-                [
+        [
             {"name": "obj_1", "minimize": True, "weight": 1},
             {"name": "obj_2", "minimize": False, "weight": 1}
         ]
         :param optimizer_config: optimizer configuration
-        optimizer_config={
-            "step_1": {"model": "Random", "num_samples": 10},
-            "step_2": {"model": "BOTorch"}
+        {
+            "step_1": {"model": "RE", "num_samples": 10},
+            "step_2": {"model": "PDC"}
         }
         """
         self.current_step = 0
@@ -33,15 +34,17 @@ class NIMOOptimizer(OptimizerBase):
         self.objective_config = objective_config
         self.optimizer_config = optimizer_config
 
-        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config, datapath)
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config, parameter_constraints, datapath)
+
+        os.makedirs(os.path.join(self.datapath, "nimo_data"), exist_ok=True)
 
         step_1 = optimizer_config.get("step_1", {})
         step_2 = optimizer_config.get("step_2", {})
         self.step_1_generator = step_1.get("model", "RE")
         self.step_1_batch_num = step_1.get("num_samples", 1)
         self.step_2_generator = step_2.get("model", "PDC")
-        self.candidates = os.path.join(self.datapath, f"{self.experiment_name}_candidates.csv")
-        self.proposals = os.path.join(self.datapath, f"{self.experiment_name}_proposals.csv")
+        self.candidates = os.path.join(self.datapath, "nimo_data", f"{self.experiment_name}_candidates.csv")
+        self.proposals = os.path.join(self.datapath, "nimo_data", f"{self.experiment_name}_proposals.csv")
         self.n_objectives = len(self.objective_config)
         self._create_candidates_csv()
 
@@ -50,6 +53,7 @@ class NIMOOptimizer(OptimizerBase):
         # Extract parameter names and their possible values
         import pandas as pd
         import nimo
+        import numpy as np
         if os.path.exists(self.candidates) and nimo.history(self.candidates, self.n_objectives):
             return
         param_names = [p["name"] for p in self.parameter_space]
@@ -58,11 +62,9 @@ class NIMOOptimizer(OptimizerBase):
         for p in self.parameter_space:
             if p["type"] == "choice" and isinstance(p["bounds"], list):
                 param_values.append(p["bounds"])
-            elif p["type"] == "range" and len(p["bounds"]) == 2:
-                low, high = p["bounds"]
-                num_points = 10  # you can customize this granularity
-                step = (high - low) / (num_points - 1)
-                param_values.append([round(low + i * step, 4) for i in range(num_points)])
+            elif p["type"] == "range" and len(p["bounds"]) == 3:
+                values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                param_values.append(values)
             else:
                 raise ValueError(f"Unsupported parameter format: {p}")
 
@@ -71,7 +73,6 @@ class NIMOOptimizer(OptimizerBase):
 
         # Create a DataFrame with parameter columns
         df = pd.DataFrame(combos, columns=param_names)
-
         # Add empty objective columns
         for obj in self.objective_config:
             df[obj["name"]] = ""
@@ -99,20 +100,19 @@ class NIMOOptimizer(OptimizerBase):
         for _, row in proposals_df.iterrows():
             proposal = {name: row[name] for name in param_names}
             proposals.append(proposal)
-        return proposals[0] if n == 1 else proposals
+        return proposals
 
     def _convert_observation_to_list(self, obs: dict) -> list:
         obj_names = [o["name"] for o in self.objective_config]
         return [obs.get(name, None) for name in obj_names]
 
-    def observe(self, results: dict):
+    def observe(self, results: list):
         """
         observe single output, nimo obj input is [1,2,3] or [[1, 2], [1, 2], [1, 2]] for MO
-        :param results: {"objective_name": "value"}
+        :param results: [{"objective_name": "value"}, {"objective_name": "value"}]]
         """
         import nimo
-        nimo_objective_values = [self._convert_observation_to_list(results)]
-
+        nimo_objective_values = [self._convert_observation_to_list(result) for result in results]
         nimo.output_update(input_file=self.proposals,
                            output_file=self.candidates,
                            num_objectives=self.n_objectives,
@@ -126,11 +126,13 @@ class NIMOOptimizer(OptimizerBase):
     @staticmethod
     def get_schema():
         return {
-            "parameter_types": ["choice"],
+            "parameter_types": ["choice", "range"],
             "multiple_objectives": True,
+            "supports_continuous": False,
+            "supports_constraints": False,
             "optimizer_config": {
-                "step_1": {"model": ["RE", "ES", "PDC"], "num_samples": 5},
-                "step_2": {"model": ["PHYSBO", "BLOX", "PTR", "SLESA", "BOMP", "COMBI"]}
+                "step_1": {"model": ["RE", "ES"], "num_samples": 5},
+                "step_2": {"model": ["PHYSBO", "PDC", "BLOX", "PTR", "SLESA", "BOMP", "COMBI"]}
             },
         }
 
@@ -140,7 +142,7 @@ class NIMOOptimizer(OptimizerBase):
 if __name__ == "__main__":
     parameter_space = [
         {"name": "silica", "type": "choice", "bounds": [100], "value_type": "float"},
-        {"name": "water", "type": "choice", "bounds": [900, 800, 750, 700, 650, 600, 550, 500], "value_type": "float"},
+        {"name": "water", "type": "range", "bounds": [500, 900, 50], "value_type": "float"},
         {"name": "PVA", "type": "choice", "bounds": [0, 0.005, 0.0075, 0.01, 0.05, 0.075, 0.1], "value_type": "float"},
         {"name": "SDS", "type": "choice", "bounds": [0], "value_type": "float"},
         {"name": "DTAB", "type": "choice", "bounds": [0, 0.005, 0.0075, 0.01, 0.05, 0.075, 0.1], "value_type": "float"},
@@ -158,5 +160,5 @@ if __name__ == "__main__":
     nimo_optimizer = NIMOOptimizer(experiment_name="example_experiment", optimizer_config=optimizer_config, parameter_space=parameter_space, objective_config=objective_config)
     nimo_optimizer.suggest(n=1)
     nimo_optimizer.observe(
-        results={"objective": 1.0}
+        results=[{"objective": 1.0}]
     )

{ivoryos-1.3.8 → ivoryos-1.4.0}/ivoryos/routes/data/data.py

@@ -118,25 +118,43 @@ def workflow_phase_data(workflow_id: int):
 
     :param workflow_id: workflow id
     """
+
     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()
+    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})
+
+        # Normalize everything to a list of dicts
+        if isinstance(outputs, dict):
+            outputs = [outputs]
+        elif isinstance(outputs, list):
+            # flatten if it’s nested like [[{...}, {...}]]
+            outputs = [
+                item for sublist in outputs
+                for item in (sublist if isinstance(sublist, list) else [sublist])
+            ]
+
+        # convert each output entry to plotting format
+        for out in outputs:
+            if not isinstance(out, dict):
+                continue
+            for k, v in out.items():
+                if isinstance(v, (int, float)):
+                    phase_data[phase_index].setdefault(k, []).append(
+                        {"x": phase_index, "y": v}
+                    )
+                elif isinstance(v, list) and all(isinstance(i, (int, float)) for i in v):
+                    phase_data[phase_index].setdefault(k, []).extend(
+                        {"x": phase_index, "y": val} for val in v
+                    )
 
     return jsonify(phase_data)
 

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

@@ -0,0 +1,78 @@
+<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>
+            {% if phase.parameters is mapping %}
+                {% 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 %}
+            {% else %}
+                {% for batch in phase.parameters %}
+                    <div class="mt-1">
+                        <span class="badge bg-info text-dark me-1">Batch {{ loop.index }}</span>
+                        {% for key, value in batch.items() %}
+                            <span class="badge bg-secondary me-1">{{ key }}: {{ value }}</span>
+                        {% endfor %}
+                    </div>
+                {% endfor %}
+            {% endif %}
+        </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-2">
+                <strong>Outputs:</strong>
+
+                {% if phase.outputs is mapping %}
+                    {% for key, value in phase.outputs.items() %}
+                        <span class="badge bg-success me-1">{{ key }}: {{ value }}</span>
+                    {% endfor %}
+
+                {% elif phase.outputs is sequence %}
+                    {% for batch in phase.outputs %}
+                        <div class="mt-1">
+                            <span class="badge bg-info text-dark me-1">Batch {{ loop.index }}</span>
+                            {% if batch is mapping %}
+                                {% for key, value in batch.items() %}
+                                    <span class="badge bg-success me-1">{{ key }}: {{ value }}</span>
+                                {% endfor %}
+                            {% elif batch is sequence %}
+                                {% for kwargs in batch %}
+                                    {% for key, value in kwargs.items() %}
+                                        <span class="badge bg-success me-1">{{ key }}: {{ value }}</span>
+                                    {% endfor %}
+                                {% endfor %}
+                            {% endif %}
+                        </div>
+                    {% endfor %}
+                {% endif %}
+            </div>
+        {% endif %}
+    </div>
+</div>

{ivoryos-1.3.8 → ivoryos-1.4.0}/ivoryos/routes/data/templates/workflow_view.html

@@ -276,12 +276,17 @@
                     repeatKeys.forEach(repeat_index => {
                         const arr = data[repeat_index][selectedKey];
                         if (arr && arr.length) {
-                            arr.forEach(d => {
+                            const batchCount = arr.length;
+
+                            arr.forEach((d, batchIdx) => {
+                                // Compute fractional x for batch indexing: e.g. 1.1, 1.2, 1.3
+                                const xVal = parseFloat(repeat_index) + (batchIdx + 1) / (batchCount + 1);
+
                                 if (typeof d === 'object' && d.x !== undefined && d.y !== undefined) {
-                                    x.push(d.x);
+                                    x.push(xVal);
                                     y.push(d.y);
                                 } else if (typeof d === 'number') {
-                                    x.push(parseInt(repeat_index));
+                                    x.push(xVal);
                                     y.push(d);
                                 }
                             });
@@ -293,12 +298,16 @@
                         y: y,
                         mode: 'markers',
                         name: selectedKey,
+                        marker: { size: 8 },
+                        line: { shape: 'linear', width: 1 },
                     };
 
                     const layout = {
                         xaxis: {
-                            title: 'Iteration Index',
-                            gridcolor: '#e9ecef'
+                            title: 'Trial (Batch Sub-index)',
+                            gridcolor: '#e9ecef',
+                            tickvals: repeatKeys.map(k => parseFloat(k)),
+                            ticktext: repeatKeys.map(k => `Trial ${k}`),
                         },
                         yaxis: {
                             title: selectedKey,