ivoryos 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

ivoryos/static/js/sortable_design.js

@@ -1,16 +1,56 @@
-$(document).ready(function () {
-    let dropTargetId = ""; // Store the ID of the drop target
+// Move triggerModal to global scope
+function triggerModal(formHtml, actionName, actionId, dropTargetId) {
+    if (formHtml && formHtml.trim() !== "") {
+        var $form = $("<div>").html(formHtml);
+
+        var $hiddenInput = $("<input>")
+            .attr("type", "hidden")
+            .attr("name", "drop_target_id")
+            .attr("id", "dropTargetInput")
+            .val(dropTargetId);
+
+        $form.find("button[type='submit']").before($hiddenInput);
+
+        $("#modalFormFields").empty().append($form.children());
+
+        const $modal = $("#dropModal");
+
+        setTimeout(() => {
+            showModal($modal);
+        }, 0);
+
+        $("#modalDropTarget").text(dropTargetId || "N/A");
+        $("#modalFormFields")
+            .data("action-id", actionId)
+            .data("action-name", actionName)
+            .data("drop-target-id", dropTargetId);
+    } else {
+        console.error("Form HTML is undefined or empty!");
+    }
+}
+
+function showModal($modal) {
+    $modal.modal({
+        backdrop: 'static',
+        keyboard: true,
+        focus: true
+    }).modal('show');
+}
 
+const state = {
+    dropTargetId: ""
+};
+
+function initializeCanvas() {
     $("#list ul").sortable({
         cancel: ".unsortable",
         opacity: 0.8,
         cursor: "move",
         placeholder: "drop-placeholder",
         update: function () {
-            var item_order = [];
-            $("ul.reorder li").each(function () {
-                item_order.push($(this).attr("id"));
-            });
+            const item_order = $("ul.reorder li").map(function () {
+                return this.id;
+            }).get();
             var order_string = "order=" + item_order.join(",");
 
             $.ajax({
@@ -19,87 +59,80 @@ $(document).ready(function () {
                 data: order_string,
                 cache: false,
                 success: function (data) {
-                    $("#response").html(data);
-                    $("#response").slideDown("slow");
-                    window.location.href = window.location.href;
+                    // Update the canvas content with the new HTML
+                    updateActionCanvas(data)
                 }
+            }).fail(function (jqXHR, textStatus, errorThrown) {
+                console.error("Failed to update order:", textStatus, errorThrown);
             });
         }
     });
 
     // Make Entire Accordion Item Draggable
-    $(".accordion-item").on("dragstart", function (event) {
-        let formHtml = $(this).find(".accordion-body").html(); // Get the correct form
-        event.originalEvent.dataTransfer.setData("form", formHtml || ""); // Store form HTML
+    $(".accordion-item").off("dragstart").on("dragstart", function (event) {
+        let formHtml = $(this).find(".accordion-body").html();
+        event.originalEvent.dataTransfer.setData("form", formHtml || "");
         event.originalEvent.dataTransfer.setData("action", $(this).find(".draggable-action").data("action"));
         event.originalEvent.dataTransfer.setData("id", $(this).find(".draggable-action").attr("id"));
-
         $(this).addClass("dragging");
     });
 
-
-    $("#list ul, .canvas").on("dragover", function (event) {
+    $("#list ul, .canvas").off("dragover").on("dragover", function (event) {
         event.preventDefault();
         let $target = $(event.target).closest("li");
 
-        // If we're over a valid <li> element in the list
         if ($target.length) {
-            dropTargetId = $target.attr("id") || ""; // Store the drop target ID
-
-            $(".drop-placeholder").remove(); // Remove existing placeholders
-            $("<li class='drop-placeholder'></li>").insertBefore($target); // Insert before the target element
+            state.dropTargetId = $target.attr("id") || "";
+            insertDropPlaceholder($target);
         } else if (!$("#list ul").children().length && $(this).hasClass("canvas")) {
-            $(".drop-placeholder").remove();  // Remove any placeholder
-            // $("#list ul").append("<li class='drop-placeholder'></li>"); // Append placeholder to canvas
+            $(".drop-placeholder").remove();
         } else {
-            dropTargetId = "";  // Append placeholder to canvas
+            state.dropTargetId = "";
         }
     });
 
-    $("#list ul, .canvas").on("dragleave", function () {
-        $(".drop-placeholder").remove(); // Remove placeholder on leave
+    $("#list ul, .canvas").off("dragleave").on("dragleave", function () {
+        $(".drop-placeholder").remove();
     });
 
-    $("#list ul, .canvas").on("drop", function (event) {
+    $("#list ul, .canvas").off("drop").on("drop", function (event) {
         event.preventDefault();
-
         var actionName = event.originalEvent.dataTransfer.getData("action");
         var actionId = event.originalEvent.dataTransfer.getData("id");
-        var formHtml = event.originalEvent.dataTransfer.getData("form"); // Retrieve form HTML
+        var formHtml = event.originalEvent.dataTransfer.getData("form");
         let listLength = $("ul.reorder li").length;
-        dropTargetId = dropTargetId || listLength + 1;  // Assign a "last" ID or unique identifier
+        state.dropTargetId = state.dropTargetId || listLength + 1;
         $(".drop-placeholder").remove();
-            // Trigger the modal with the appropriate action
-        triggerModal(formHtml, actionName, actionId, dropTargetId);
-
+        document.activeElement?.blur();
+        triggerModal(formHtml, actionName, actionId, state.dropTargetId);
     });
+}
 
-    // Function to trigger the modal (same for both buttons and accordion items)
-    function triggerModal(formHtml, actionName, actionId, dropTargetId) {
-        if (formHtml && formHtml.trim() !== "") {
-            var $form = $("<div>").html(formHtml); // Convert HTML string to jQuery object
+function insertDropPlaceholder($target) {
+    $(".drop-placeholder").remove();
+    $("<li class='drop-placeholder'></li>").insertBefore($target);
+}
 
-            // Create a hidden input for the drop target ID
-            var $hiddenInput = $("<input>")
-                .attr("type", "hidden")
-                .attr("name", "drop_target_id")
-                .attr("id", "dropTargetInput")
-                .val(dropTargetId);
+// Add this function to sortable_design.js
+function initializeDragHandlers() {
+    $(".accordion-item").off("dragstart").on("dragstart", function (event) {
+        let formHtml = $(this).find(".accordion-body form").prop('outerHTML');
 
-            // Insert before the submit button
-            $form.find("button[type='submit']").before($hiddenInput);
+        if (!formHtml) {
+            console.error("Form not found in accordion-body");
+            return false;
+        }
 
-            $("#modalFormFields").empty().append($form.children());
-            $("#dropModal").modal("show"); // Show modal
+        event.originalEvent.dataTransfer.setData("form", formHtml);
+        event.originalEvent.dataTransfer.setData("action", $(this).find(".draggable-action").data("action"));
+        event.originalEvent.dataTransfer.setData("id", $(this).find(".draggable-action").attr("id"));
 
-            // Store and display drop target ID in the modal
-            $("#modalDropTarget").text(dropTargetId || "N/A");
+        $(this).addClass("dragging");
+    });
+}
 
-            $("#modalFormFields").data("action-id", actionId);
-            $("#modalFormFields").data("action-name", actionName);
-            $("#modalFormFields").data("drop-target-id", dropTargetId);
-        } else {
-            console.error("Form HTML is undefined or empty!");
-        }
-    }
-});
+// Make sure it's called in the document ready function
+$(document).ready(function () {
+    initializeCanvas();
+    initializeDragHandlers(); // Add this line
+});

ivoryos/static/js/ui_state.js

@@ -0,0 +1,113 @@
+// Toggle visibility of line numbers
+function toggleLineNumbers(save = true) {
+    const show = document.getElementById('toggleLineNumbers').checked;
+    document.querySelectorAll('.line-number').forEach(el => {
+        el.classList.toggle('d-none', !show);
+    });
+
+    if (save) {
+        localStorage.setItem('showLineNumbers', show ? 'true' : 'false');
+    }
+}
+
+// Toggle visibility of Python code overlay
+function toggleCodeOverlay(state = null) {
+    const overlay = document.getElementById("pythonCodeOverlay");
+    const checkbox = document.getElementById("showPythonCodeSwitch");
+
+    const isVisible = overlay.classList.contains("show");
+    const newState = state !== null ? state : !isVisible;
+
+    if (newState) {
+        overlay.classList.add("show");
+        checkbox.checked = true;
+    } else {
+        overlay.classList.remove("show");
+        checkbox.checked = false;
+    }
+
+    // Save state to session via PATCH
+    fetch(scriptUIStateUrl, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ show_code: newState })
+    });
+}
+
+
+function setScriptPhase(stype) {
+    fetch(scriptUIStateUrl, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ editing_type: stype })
+    })
+    .then(res => res.json())
+    .then(data => {
+        if (data.html) {
+            document.getElementById("canvas-wrapper").innerHTML = data.html;
+            initializeCanvas(); // Reinitialize the canvas functionality
+            document.querySelectorAll('#pythonCodeOverlay pre code').forEach((block) => {
+                hljs.highlightElement(block);
+            });
+        }
+    })
+    .catch(error => console.error("Failed to update editing type", error));
+}
+
+
+
+function changeDeck(deck) {
+    fetch(scriptUIStateUrl, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ deck_name: deck })
+    })
+    .then(res => res.json())
+    .then(data => {
+        if (data.html) {
+            document.getElementById("sidebar-wrapper").innerHTML = data.html;
+        }
+    })
+    .catch(error => console.error("Failed to change deck", error));
+}
+
+
+
+function toggleAutoFill() {
+    const instrumentValue = document.querySelector('.form-check.form-switch').dataset.instrument;
+
+    fetch(scriptUIStateUrl, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            autofill: document.getElementById("autoFillCheck").checked,
+            instrument: instrumentValue
+        })
+    })
+    .then(res => res.json())
+    .then(data => {
+        if (data.html) {
+            document.getElementById("instrument-panel").innerHTML = data.html;
+        }
+    })
+}
+// Restore state on page load
+document.addEventListener('DOMContentLoaded', () => {
+    const savedState = localStorage.getItem('showLineNumbers');
+    const checkbox = document.getElementById('toggleLineNumbers');
+
+    if (savedState === 'true') {
+        checkbox.checked = true;
+    }
+    if (checkbox) {
+        toggleLineNumbers(false);  // don't overwrite localStorage on load
+        checkbox.addEventListener('change', () => toggleLineNumbers());
+    }
+
+});

ivoryos/utils/bo_campaign.py

@@ -1,3 +1,5 @@
+from typing import Dict, Any
+import re
 from ivoryos.utils.utils import install_and_import
 
 
@@ -124,4 +126,138 @@ def exisitng_data_gs(data_len):
                 ),
             ]
         )
-    return gs
+    return gs
+
+
+def parse_optimization_form(form_data: Dict[str, str]):
+    """
+    Parse dynamic form data into structured optimization configuration.
+
+    Expected form field patterns:
+    - Objectives: {name}_min, {name}_weight
+    - Parameters: {name}_type, {name}_min, {name}_max, {name}_choices, {name}_value_type
+    - Config: step{n}_model, step{n}_num_samples
+    """
+
+    objectives = []
+    parameters = []
+    config = {}
+
+    # Track processed field names to avoid duplicates
+    processed_objectives = set()
+    processed_parameters = set()
+
+    # Parse objectives
+    for field_name, value in form_data.items():
+        if field_name.endswith('_min') and value:
+            # Extract objective name
+            obj_name = field_name.replace('_min', '')
+            if obj_name in processed_objectives:
+                continue
+
+            # Check if corresponding weight exists
+            weight_field = f"{obj_name}_weight"
+            if weight_field in form_data and form_data[weight_field]:
+                objectives.append({
+                    "name": obj_name,
+                    "minimize": value == "minimize",
+                    "weight": float(form_data[weight_field])
+                })
+            else:
+                objectives.append({
+                    "name": obj_name,
+                    "minimize": value == "minimize",
+                })
+            processed_objectives.add(obj_name)
+
+    # Parse parameters
+    for field_name, value in form_data.items():
+        if field_name.endswith('_type') and value:
+            # Extract parameter name
+            param_name = field_name.replace('_type', '')
+            if param_name in processed_parameters:
+                continue
+
+            parameter = {
+                "name": param_name,
+                "type": value
+            }
+
+            # Get value type (default to float)
+            value_type_field = f"{param_name}_value_type"
+            value_type = form_data.get(value_type_field, "float")
+            parameter["value_type"] = value_type
+
+            # Handle different parameter types
+            if value == "range":
+                min_field = f"{param_name}_min"
+                max_field = f"{param_name}_max"
+
+                if min_field in form_data and max_field in form_data:
+                    min_val = form_data[min_field]
+                    max_val = form_data[max_field]
+
+                    if min_val and max_val:
+                        # Convert based on value_type
+                        if value_type == "int":
+                            bounds = [int(min_val), int(max_val)]
+                        elif value_type == "float":
+                            bounds = [float(min_val), float(max_val)]
+                        else:  # string
+                            bounds = [str(min_val), str(max_val)]
+
+                        parameter["bounds"] = bounds
+
+            elif value == "choice":
+                choices_field = f"{param_name}_choices"
+                if choices_field in form_data and form_data[choices_field]:
+                    # Split choices by comma and clean whitespace
+                    choices = [choice.strip() for choice in form_data[choices_field].split(',')]
+
+                    # Convert choices based on value_type
+                    if value_type == "int":
+                        choices = [int(choice) for choice in choices if choice.isdigit()]
+                    elif value_type == "float":
+                        choices = [float(choice) for choice in choices if
+                                   choice.replace('.', '').replace('-', '').isdigit()]
+                    # For string, keep as is
+
+                    parameter["bounds"] = choices
+
+            elif value == "fixed":
+                fixed_field = f"{param_name}_value"
+                if fixed_field in form_data and form_data[fixed_field]:
+                    fixed_val = form_data[fixed_field]
+
+                    # Convert based on value_type
+                    if value_type == "int":
+                        parameter["value"] = int(fixed_val)
+                    elif value_type == "float":
+                        parameter["value"] = float(fixed_val)
+                    else:
+                        parameter["value"] = str(fixed_val)
+
+            parameters.append(parameter)
+            processed_parameters.add(param_name)
+
+    # Parse configuration steps
+    step_pattern = re.compile(r'step(\d+)_(.+)')
+    steps = {}
+
+    for field_name, value in form_data.items():
+        match = step_pattern.match(field_name)
+        if match and value:
+            step_num = int(match.group(1))
+            step_attr = match.group(2)
+            step_key = f"step_{step_num}"
+
+            if step_key not in steps:
+                steps[step_key] = {}
+
+            # Convert num_samples to int if it's a number field
+            if step_attr == "num_samples":
+                steps[step_key][step_attr] = int(value)
+            else:
+                steps[step_key][step_attr] = value
+
+    return parameters, objectives, steps

ivoryos/utils/db_models.py

@@ -265,11 +265,20 @@ class Script(db.Model):
         output_variables: Dict[str, str] = self.get_variables()
         # print(output_variables)
         for key, value in kwargs.items():
-            if type(value) is str and value in output_variables:
-                var_type = output_variables[value]
-                kwargs[key] = {value: var_type}
-            if isinstance(value, str) and value.startswith("#"):
-                kwargs[key] = f"#{self.validate_function_name(value[1:])}"
+            if isinstance(value, str):
+                if value in output_variables:
+                    var_type = output_variables[value]
+                    kwargs[key] = {value: var_type}
+                elif value.startswith("#"):
+                    kwargs[key] = f"#{self.validate_function_name(value[1:])}"
+                else:
+                    # attempt to convert to numerical or bool value for args with no type hint
+                    try:
+                        converted = ast.literal_eval(value)
+                        if isinstance(converted, (int, float, bool)):
+                            kwargs[key] = converted
+                    except (ValueError, SyntaxError):
+                        pass
         return kwargs
 
     def add_logic_action(self, logic_type: str, statement, insert_position=None):

ivoryos/utils/form.py

@@ -214,11 +214,6 @@ class FlexibleEnumField(StringField):
                     f"Invalid choice: '{key}'. Must match one of {list(self.enum_class.__members__.keys())}")
 
 
-def format_name(name):
-    """Converts 'example_name' to 'Example Name'."""
-    name = name.split(".")[-1]
-    text = ' '.join(word for word in name.split('_'))
-    return text.capitalize()
 
 def parse_annotation(annotation):
     """
@@ -264,7 +259,7 @@ def create_form_for_method(method, autofill, script=None, design=True):
     for param in sig.parameters.values():
         if param.name == 'self':
             continue
-        formatted_param_name = format_name(param.name)
+        # formatted_param_name = format_name(param.name)
 
         default_value = None
         if autofill:
@@ -277,7 +272,7 @@ def create_form_for_method(method, autofill, script=None, design=True):
                     default_value = param.default
 
         field_kwargs = {
-            "label": formatted_param_name,
+            "label": param.name,
             "default": default_value,
             "validators": [InputRequired()] if param.default is param.empty else [Optional()],
             **({"script": script} if (autofill or design) else {})
@@ -396,12 +391,12 @@ def create_form_from_action(action: dict, script=None, design=True):
     }
 
     for name, param_type in arg_types.items():
-        formatted_param_name = format_name(name)
+        # formatted_param_name = format_name(name)
         value = args.get(name, "")
         if type(value) is dict:
             value = next(iter(value))
         field_kwargs = {
-            "label": formatted_param_name,
+            "label": name,
             "default": f'{value}',
             "validators": [InputRequired()],
             **({"script": script})

ivoryos/utils/global_config.py

@@ -15,6 +15,7 @@ class GlobalConfig:
             cls._instance._deck_snapshot = {}
             cls._instance._runner_lock = threading.Lock()
             cls._instance._runner_status = None
+            cls._instance._optimizers = {}
         return cls._instance
 
     @property
@@ -84,4 +85,15 @@ class GlobalConfig:
 
     @runner_status.setter
     def runner_status(self, value):
-        self._runner_status = value
+        self._runner_status = value
+
+    @property
+    def optimizers(self):
+        return self._optimizers
+
+    @optimizers.setter
+    def optimizers(self, value):
+        if isinstance(value, dict):
+            self._optimizers = value
+        else:
+            raise ValueError("Optimizers must be a dictionary.")

ivoryos/utils/script_runner.py

@@ -62,7 +62,7 @@ class ScriptRunner:
 
 
     def run_script(self, script, repeat_count=1, run_name=None, logger=None, socketio=None, config=None, bo_args=None,
-                   output_path="", compiled=False, current_app=None, history=None):
+                   output_path="", compiled=False, current_app=None, history=None, optimizer=None):
         global deck
         if deck is None:
             deck = global_config.deck
@@ -82,7 +82,7 @@ class ScriptRunner:
         thread = threading.Thread(
             target=self._run_with_stop_check,
             args=(script, repeat_count, run_name, logger, socketio, config, bo_args, output_path, current_app, compiled,
-                  history)
+                  history, optimizer)
         )
         thread.start()
         return thread
@@ -183,7 +183,7 @@ class ScriptRunner:
         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,
-                             output_path, current_app, compiled, history=None):
+                             output_path, current_app, compiled, history=None, optimizer=None):
         time.sleep(1)
         # _func_str = script.compile()
         # step_list_dict: dict = script.convert_to_lines(_func_str)
@@ -207,7 +207,7 @@ class ScriptRunner:
             if repeat_count:
                 self._run_repeat_section(repeat_count, arg_type, bo_args, output_list, script,
                                          run_name, return_list, compiled, logger, socketio,
-                                         history, output_path, run_id=run_id)
+                                         history, output_path, run_id=run_id, optimizer=optimizer)
             elif config:
                 self._run_config_section(config, arg_type, output_list, script, run_name, logger,
                                          socketio, run_id=run_id, compiled=compiled)
@@ -264,7 +264,7 @@ class ScriptRunner:
                     output_list.append(output)
 
     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):
+                            logger, socketio, history, output_path, run_id, optimizer=None):
         if bo_args:
             logger.info('Initializing optimizer...')
             if compiled:
@@ -283,6 +283,14 @@ class ScriptRunner:
                         output_list.append(row)
                 else:
                     ax_client = bo_campaign.ax_init_form(bo_args, arg_types)
+        elif optimizer and history:
+            import pandas as pd
+            file_path = os.path.join(output_path, history)
+
+            previous_runs = pd.read_csv(file_path)
+            optimizer.append_existing_data(previous_runs)
+            for row in previous_runs:
+                output_list.append(row)
 
 
 
@@ -307,6 +315,17 @@ class ScriptRunner:
                 except Exception as e:
                     logger.info(f'Optimization error: {e}')
                     break
+            elif optimizer:
+                try:
+                    parameters = optimizer.suggest(1)
+                    logger.info(f'Output value: {parameters}')
+                    output = self.exec_steps(script, "script", logger, socketio, run_id, i_progress, **parameters)
+                    if output:
+                        optimizer.observe(output)
+                        output.update(parameters)
+                except Exception as e:
+                    logger.info(f'Optimization error: {e}')
+                    break
             else:
                 # fname = f"{run_name}_script"
                 # function = self.globals_dict[fname]