ivoryos 1.3.9__py3-none-any.whl → 1.4.1__py3-none-any.whl

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,25 @@ 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
+            )
+
+    def get_plots(self, plot_type):
+        return None
 
     @staticmethod
     def get_schema():
@@ -117,29 +135,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/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,23 @@ class OptimizerBase(ABC):
     def append_existing_data(self, existing_data):
         pass
 
+    @abstractmethod
+    def get_plots(self, plot_type):
+        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/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])
@@ -148,6 +153,9 @@ class BaybeOptimizer(OptimizerBase):
             recommender=step_2_recommender
         )
 
+    def get_plots(self, plot_type):
+        return None
+
     @staticmethod
     def get_schema():
         """
@@ -156,6 +164,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/optimizer/nimo_optimizer.py

@@ -1,4 +1,5 @@
 ### ivoryos/optimizers/nimo_optimizer.py
+import glob
 import itertools
 import os
 
@@ -7,7 +8,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
@@ -33,7 +35,7 @@ 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)
 
@@ -52,6 +54,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]
@@ -60,11 +63,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}")
 
@@ -73,7 +74,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"]] = ""
@@ -101,20 +101,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,
@@ -124,12 +123,22 @@ class NIMOOptimizer(OptimizerBase):
         # TODO, history is part of the candidate file, we probably won't need this
         pass
 
+    def get_plots(self, plot_type):
+        import nimo
+        nimo.visualization.plot_phase_diagram.plot(input_file=self.candidates,
+                                                   fig_folder=os.path.join(self.datapath, "nimo_data"))
+        files = sorted(glob.glob(os.path.join(os.path.join(self.datapath, "nimo_data"), "phase_diagram_*.png")))
+        if not files:
+            return None
+        return files[-1]
 
     @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"], "num_samples": 5},
                 "step_2": {"model": ["PHYSBO", "PDC", "BLOX", "PTR", "SLESA", "BOMP", "COMBI"]}
@@ -142,7 +151,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"},
@@ -160,5 +169,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/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/routes/data/templates/components/step_card.html

@@ -4,14 +4,31 @@
             <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>
+        {% 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>
@@ -29,13 +46,32 @@
             </div>
         {% endif %}
         {% if phase.outputs %}
-            <div class="mt-1">
+            <div class="mt-2">
                 <strong>Outputs:</strong>
-                <ul class="mb-0">
+
+                {% if phase.outputs is mapping %}
                     {% for key, value in phase.outputs.items() %}
-                        <li>{{ key }}: {{ value }}</li>
+                        <span class="badge bg-success me-1">{{ key }}: {{ value }}</span>
                     {% endfor %}
-                </ul>
+
+                {% 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>

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,

ivoryos/routes/design/design.py

@@ -100,6 +100,27 @@ def experiment_builder():
                            script=script, defined_variables=deck_variables, buttons_dict=design_buttons,
                            local_variables=global_config.defined_variables, block_variables=global_config.building_blocks)
 
+@design.route("/draft/code_preview", methods=["GET"])
+@login_required
+def compile_preview():
+    # Get mode and batch from query parameters
+    script = utils.get_script_file()
+    mode = request.args.get("mode", "single")   # default to "single"
+    batch = request.args.get("batch", "sample") # default to "sample"
+
+    try:
+        # Example: decide which code to return based on mode/batch
+        if mode == "single":
+            code = script.compile(current_app.config['SCRIPT_FOLDER'])
+        elif mode == "batch":
+            code = script.compile(current_app.config['SCRIPT_FOLDER'], batch=True, mode=batch)
+        else:
+            code = "Invalid mode. Please select 'single' or 'batch'."
+    except Exception as e:
+        code = f"Error compiling: {e}"
+    # print(code)
+    return jsonify(code=code)
+
 
 @design.route("/draft/meta", methods=["PATCH"])
 @login_required
@@ -320,13 +341,16 @@ def methods_handler(instrument: str = ''):
     request.form
     if "hidden_name" in request.form:
         deck_snapshot = global_config.deck_snapshot
+        block_snapshot = global_config.building_blocks
         method_name = request.form.get("hidden_name", None)
         form = forms.get(method_name) if forms else None
         insert_position = request.form.get("drop_target_id", None)
+
         if form:
             kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'}
             if form.validate_on_submit():
                 function_name = kwargs.pop("hidden_name")
+                batch_action = kwargs.pop("batch_action", False)
                 save_data = kwargs.pop('return', '')
                 primitive_arg_types = utils.get_arg_type(kwargs, functions[function_name])
 
@@ -335,11 +359,17 @@ def methods_handler(instrument: str = ''):
 
                 script.eval_list(kwargs, primitive_arg_types)
                 kwargs = script.validate_variables(kwargs)
+                coroutine = False
+                if instrument.startswith("deck") and deck_snapshot:
+                    coroutine = deck_snapshot[instrument][function_name].get("coroutine", False)
+                elif instrument.startswith("blocks") and block_snapshot:
+                    coroutine = block_snapshot[instrument][function_name].get("coroutine", False)
                 action = {"instrument": instrument, "action": function_name,
                           "args": kwargs,
                           "return": save_data,
                           'arg_types': primitive_arg_types,
-                          "coroutine": deck_snapshot[instrument][function_name].get("coroutine", False) if deck_snapshot else False,
+                          "coroutine": coroutine,
+                          "batch_action": batch_action,
                           }
                 script.add_action(action=action, insert_position=insert_position)
             else:

ivoryos/routes/design/design_step.py

@@ -57,8 +57,9 @@ def save_step(uuid: int):
         kwargs = {field.name: field.data for field in forms if field.name != 'csrf_token'}
         if forms and forms.validate_on_submit():
             save_as = kwargs.pop('return', '')
+            batch_action = kwargs.pop('batch_action', False)
             kwargs = script.validate_variables(kwargs)
-            script.update_by_uuid(uuid=uuid, args=kwargs, output=save_as)
+            script.update_by_uuid(uuid=uuid, args=kwargs, output=save_as, batch_action=batch_action)
         else:
             warning = f"Compilation failed: {str(forms.errors)}"
     utils.post_script_file(script)