ivoryos 1.2.5__py3-none-any.whl → 1.4.4__py3-none-any.whl

ivoryos/static/js/socket_handler.js

@@ -1,5 +1,5 @@
 document.addEventListener("DOMContentLoaded", function() {
-    var socket = io.connect('http://' + document.domain + ':' + location.port);
+    var socket = io();
     socket.on('connect', function() {
         console.log('Connected');
     });
@@ -37,13 +37,43 @@ document.addEventListener("DOMContentLoaded", function() {
         console.error("Error received:", errorData);
         var progressBar = document.getElementById('progress-bar-inner');
 
-        progressBar.classList.remove('bg-success');
-        progressBar.classList.add('bg-danger'); // Red color for error
-                // Show error modal
+        progressBar.classList.remove('bg-success', 'bg-warning');
+        progressBar.classList.add('bg-danger');
+
         var errorModal = new bootstrap.Modal(document.getElementById('error-modal'));
-        document.getElementById('error-message').innerText = "An error occurred: " + errorData.message;
+        document.getElementById('errorModalLabel').innerText = "Error Detected";
+        document.getElementById('error-message').innerText =
+            "An error occurred: " + errorData.message;
+
+        // Show all buttons again
+        document.getElementById('retry-btn').style.display = "inline-block";
+        document.getElementById('continue-btn').style.display = "inline-block";
+        document.getElementById('stop-btn').style.display = "inline-block";
+
         errorModal.show();
+    });
+
+
+    socket.on('human_intervention', function(data) {
+        console.warn("Human intervention required:", data);
+        var progressBar = document.getElementById('progress-bar-inner');
 
+        // Set progress bar to yellow
+        progressBar.classList.remove('bg-success', 'bg-danger');
+        progressBar.classList.add('bg-warning');
+
+        // Reuse error modal but update content
+        var errorModal = new bootstrap.Modal(document.getElementById('error-modal'));
+        document.getElementById('errorModalLabel').innerText = "Human Intervention Required";
+        document.getElementById('error-message').innerText =
+            "Workflow paused: " + (data.message || "Please check and manually resume.");
+
+        // Optionally: hide retry button, since it may not apply
+        document.getElementById('retry-btn').style.display = "none";
+        document.getElementById('continue-btn').style.display = "inline-block";
+        document.getElementById('stop-btn').style.display = "inline-block";
+
+        errorModal.show();
     });
 
     // Handle Pause/Resume Button
@@ -71,6 +101,11 @@ document.addEventListener("DOMContentLoaded", function() {
     document.getElementById('continue-btn').addEventListener('click', function() {
         socket.emit('pause');  // Resume execution
         console.log("Execution resumed.");
+
+        // Reset progress bar color to running (blue)
+        var progressBar = document.getElementById('progress-bar-inner');
+        progressBar.classList.remove('bg-danger', 'bg-warning');
+        progressBar.classList.add('bg-primary');
     });
 
     document.getElementById('retry-btn').addEventListener('click', function() {

ivoryos/static/js/sortable_design.js

@@ -106,6 +106,7 @@ function initializeCanvas() {
         document.activeElement?.blur();
         triggerModal(formHtml, actionName, actionId, state.dropTargetId);
     });
+    initializeCodeOverlay();
 }
 
 function insertDropPlaceholder($target) {
@@ -115,20 +116,37 @@ function insertDropPlaceholder($target) {
 
 // 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');
-
-        if (!formHtml) {
-            console.error("Form not found in accordion-body");
-            return false;
-        }
+    const $cards = $(".accordion-item.design-control");
 
-        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"));
+    // Toggle draggable based on mouse/touch position
+    $cards.off("mousedown touchstart").on("mousedown touchstart", function (event) {
+        this.setAttribute("draggable", $(event.target).closest(".input-group").length ? "false" : "true");
+    });
 
-        $(this).addClass("dragging");
+    // Handle the actual drag
+    $cards.off("dragstart dragend").on({
+        dragstart: function (event) {
+            if (this.getAttribute("draggable") !== "true") {
+                event.preventDefault();
+                return false;
+            }
+
+            const formHtml = $(this).find(".accordion-body form").prop("outerHTML");
+            if (!formHtml) return false;
+
+            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");
+        },
+        dragend: function () {
+            $(this).removeClass("dragging").attr("draggable", "false");
+        }
     });
+
+    // Prevent form inputs from being draggable
+    $(".accordion-item input, .accordion-item select").attr("draggable", "false");
 }
 
 // Make sure it's called in the document ready function

ivoryos/templates/base.html

@@ -24,9 +24,25 @@
     <nav class="navbar navbar-expand-lg navbar-light bg-light fixed-top">
         <div class= "container">
 {#            {{ module_config }}#}
+
             <a class="navbar-brand" href="{{ url_for('main.index') }}">
-                <img src="{{url_for('static', filename='logo.webp')}}" alt="Logo" height="60" class="d-inline-block align-text-bottom">
+                {% if current_user.is_authenticated %}
+                    {% if current_user.settings.logo_mode == 'replace' and current_user.settings.logo_filename %}
+                        <img src="{{ url_for('static', filename='user_logos/' ~ current_user.settings.logo_filename) }}" alt="User Logo" height="50">
+                    {% else %}
+
+                        {% if current_user.settings.logo_mode == 'add' and current_user.settings.logo_filename %}
+                            <img src="{{ url_for('static', filename='user_logos/' ~ current_user.settings.logo_filename) }}" alt="User Logo" height="50" class="ms-2">
+                        {% endif %}
+                        <img src="{{ url_for('static', filename='ivoryos_logo.png') }}" alt="IvoryOS" height="50">
+                    {% endif %}
+                {% else %}
+                    <img src="{{ url_for('static', filename='ivoryos_logo.png') }}" alt="IvoryOS" height="50">
+                {% endif %}
             </a>
+
+
+
             <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
                 <span class="navbar-toggler-icon"></span>
             </button>
@@ -69,11 +85,12 @@
                     {% endif %}
                 </ul>
                 <ul class="navbar-nav ms-auto">
-{#                    {{ current_user }}#}
                     {% if current_user.is_authenticated %}
                         <div class="dropdown">
                             <li class="nav-item " aria-expanded="false"><i class="bi bi-person-circle"></i> {{ current_user.get_id() }}</li>
                             <ul class="dropdown-menu">
+                                <li><a class="dropdown-item" href="{{ url_for("auth.change_password") }}" role="button" aria-expanded="false">Change Password</a></li>
+                                <li><a class="dropdown-item" data-bs-toggle="modal" data-bs-target="#logoModal" role="button" aria-expanded="false">Customize Logo</a></li>
                                 <li><a class="dropdown-item" href="{{ url_for("auth.logout") }}" role="button" aria-expanded="false">Logout</a></li>
                             </ul>
 
@@ -153,5 +170,47 @@
             </div>
         </div>
     </div>
+
+    <!-- Logo Customization Modal -->
+    <div class="modal fade" id="logoModal" tabindex="-1" aria-labelledby="logoModalLabel" aria-hidden="true">
+        <div class="modal-dialog modal-dialog-centered">
+            <div class="modal-content shadow-lg">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="logoModalLabel">Customize Navbar Logo</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <form method="POST"
+                    action="{{ url_for('main.customize_logo') }}"
+                    enctype="multipart/form-data">
+                    <div class="modal-body">
+                        <div class="mb-3">
+                            <label class="form-label fw-semibold">Upload your logo</label>
+                            <input type="file" name="logo" accept="image/*" class="form-control" required>
+                        </div>
+                        <div class="mb-2">
+                            <label class="form-label fw-semibold">Display mode</label>
+                            <div class="form-check">
+                                <input class="form-check-input" type="radio" name="mode" id="add" value="add" checked>
+                                <label class="form-check-label" for="add">
+                                Add next to IvoryOS logo
+                                </label>
+                            </div>
+                            <div class="form-check">
+                                <input class="form-check-input" type="radio" name="mode" id="replace" value="replace">
+                                <label class="form-check-label" for="replace">
+                                Replace IvoryOS logo
+                                </label>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="modal-footer">
+                        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
+                        <button type="submit" class="btn btn-primary">Apply</button>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+
 </body>
 </html>

ivoryos/utils/bo_campaign.py

@@ -134,7 +134,7 @@ 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
+    - Objectives: {name}_obj_min, {name}_weight
     - Parameters: {name}_type, {name}_min, {name}_max, {name}_choices, {name}_value_type
     - Config: step{n}_model, step{n}_num_samples
     """
@@ -149,25 +149,25 @@ def parse_optimization_form(form_data: Dict[str, str]):
 
     # Parse objectives
     for field_name, value in form_data.items():
-        if field_name.endswith('_min') and value:
+        if field_name.endswith('_obj_min') and value:
             # Extract objective name
-            obj_name = field_name.replace('_min', '')
+            obj_name = field_name.replace('_obj_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({
+            early_stop_field = f"{obj_name}_obj_threshold"
+
+            config = {
                     "name": obj_name,
                     "minimize": value == "minimize",
-                })
+                }
+            if weight_field in form_data and form_data[weight_field]:
+                config["weight"] = float(form_data[weight_field])
+            if early_stop_field in form_data and form_data[early_stop_field]:
+                config["early_stop"] = float(form_data[early_stop_field])
+            objectives.append(config)
             processed_objectives.add(obj_name)
 
     # Parse parameters
@@ -192,11 +192,11 @@ def parse_optimization_form(form_data: Dict[str, str]):
             if value == "range":
                 min_field = f"{param_name}_min"
                 max_field = f"{param_name}_max"
-
+                step_field = f"{param_name}_step"
                 if min_field in form_data and max_field in form_data:
                     min_val = form_data[min_field]
                     max_val = form_data[max_field]
-
+                    step_val = form_data[step_field] if step_field in form_data else None
                     if min_val and max_val:
                         # Convert based on value_type
                         if value_type == "int":
@@ -204,12 +204,13 @@ def parse_optimization_form(form_data: Dict[str, str]):
                         elif value_type == "float":
                             bounds = [float(min_val), float(max_val)]
                         else:  # string
-                            bounds = [str(min_val), str(max_val)]
-
+                            bounds = [float(min_val), float(max_val)]
+                        if step_val:
+                            bounds.append(float(step_val))
                         parameter["bounds"] = bounds
 
             elif value == "choice":
-                choices_field = f"{param_name}_choices"
+                choices_field = f"{param_name}_value"
                 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(',')]

ivoryos/utils/client_proxy.py

@@ -1,57 +1,288 @@
-# import argparse
 import os
+import re
+from typing import Dict, Set, Any, Optional
 
-# import requests
 
-# session = requests.Session()
+class ProxyGenerator:
+    """
+    A class to generate Python proxy interfaces for API clients.
 
+    This generator creates client classes that wrap API endpoints,
+    automatically handling request/response cycles and error handling.
+    """
 
-# Function to create class and methods dynamically
-def create_function(url, class_name, functions):
-    class_template = f'class {class_name.capitalize()}:\n    url = "{url}ivoryos/api/control/deck.{class_name}"\n'
+    # Common typing symbols to scan for in function signatures
+    TYPING_SYMBOLS = {
+        "Optional", "Union", "List", "Dict", "Tuple",
+        "Any", "Callable", "Iterable", "Sequence", "Set"
+    }
 
-    for function_name, details in functions.items():
-        signature = details['signature']
-        docstring = details.get('docstring', '')
+    def __init__(self, base_url: str, api_path_template: str = "ivoryos/instruments/deck.{class_name}"):
+        """
+        Initialize the ProxyGenerator.
+
+        Args:
+            base_url: The base URL for the API
+            api_path_template: Template for API paths, with {class_name} placeholder
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_path_template = api_path_template
+        self.used_typing_symbols: Set[str] = set()
+
+    def extract_typing_from_signatures(self, functions: Dict[str, Dict[str, Any]]) -> Set[str]:
+        """
+        Scan function signatures for typing symbols and track usage.
+
+        Args:
+            functions: Dictionary of function definitions with signatures
+
+        Returns:
+            Set of typing symbols found in the signatures
+        """
+        for function_data in functions.values():
+            signature = function_data.get("signature", "")
+            for symbol in self.TYPING_SYMBOLS:
+                if re.search(rf"\b{symbol}\b", signature):
+                    self.used_typing_symbols.add(symbol)
+        return self.used_typing_symbols
+
+    def create_class_definition(self, class_name: str, functions: Dict[str, Dict[str, Any]]) -> str:
+        """
+        Generate a class definition string for one API client class.
+
+        Args:
+            class_name: Name of the class to generate
+            functions: Dictionary of function definitions
+
+        Returns:
+            String containing the complete class definition
+        """
+        capitalized_name = class_name.capitalize()
+        api_url = f"{self.base_url}/{self.api_path_template.format(class_name=class_name)}"
+
+        class_template = f"class {capitalized_name}:\n"
+        class_template += f'    """Auto-generated API client for {class_name} operations."""\n'
+        class_template += f'    url = "{api_url}"\n\n'
+
+        # Add the __init__ with auth
+        class_template += self._generate_init()
+
+        # Add the _auth
+        class_template += self._generate_auth()
+
+        # Add the base _call method
+        class_template += self._generate_call_method()
+
+        # Add individual methods for each function
+        for function_name, details in functions.items():
+            method_def = self._generate_method(function_name, details)
+            class_template += method_def + "\n"
+
+        return class_template
+
+    def _generate_call_method(self) -> str:
+        """Generate the base _call method for API communication."""
+        return '''    def _call(self, payload):
+        """Make API call with error handling."""
+        res = session.post(self.url, json=payload, allow_redirects=False)
+            # Handle 302 redirect (likely auth issue)
+        if res.status_code == 302:
+            try:
+                self._auth()
+                res = session.post(self.url, json=payload, allow_redirects=False)
+            except Exception as e:
+                raise AuthenticationError(
+                    "Authentication failed during re-attempt. "
+                    "Please check your credentials or connection."
+                ) from e
+        res.raise_for_status()
+        data = res.json()
+        if not data.get('success'):
+            raise Exception(data.get('output', "Unknown API error."))
+        return data.get('output')
+
+'''
+
+    def _generate_method(self, function_name: str, details: Dict[str, Any]) -> str:
+        """
+        Generate a single method definition.
+
+        Args:
+            function_name: Name of the method
+            details: Function details including signature and docstring
+
+        Returns:
+            String containing the method definition
+        """
+        signature = details.get("signature", "(self)")
+        docstring = details.get("docstring", "")
+
+        # Build method header
+        method = f"    def {function_name}{signature}:\n"
 
-        # Creating the function definition
-        method = f'    def {function_name}{signature}:\n'
         if docstring:
             method += f'        """{docstring}"""\n'
 
-        # Generating the session.post code for sending data
-        method += '        return session.post(self.url, data={'
-        method += f'"hidden_name": "{function_name}"'
+        # Build payload
+        method += f'        payload = {{"hidden_name": "{function_name}"}}\n'
+
+        # Extract parameters from signature (excluding 'self')
+        params = self._extract_parameters(signature)
+
+        for param_name in params:
+            method += f'        payload["{param_name}"] = {param_name}\n'
+
+        method += "        return self._call(payload)\n"
 
-        # Extracting the parameters from the signature string for the data payload
-        param_str = signature[6:-1]  # Remove the "(self" and final ")"
-        params = [param.strip() for param in param_str.split(',')] if param_str else []
+        return method
+
+    def _extract_parameters(self, signature: str) -> list:
+        """
+        Extract parameter names from a function signature.
+
+        Args:
+            signature: Function signature string like "(self, param1, param2: int = 5)"
+
+        Returns:
+            List of parameter names (excluding 'self')
+        """
+        # Remove parentheses and split by comma
+        param_str = signature.strip("()").strip()
+        if not param_str or param_str == "self":
+            return []
+
+        params = [param.strip() for param in param_str.split(",")]
+        result = []
 
         for param in params:
-            param_name = param.split(':')[0].strip()  # Split on ':' and get parameter name
-            method += f', "{param_name}": {param_name}'
+            if param and param != "self":
+                # Extract parameter name (before : or = if present)
+                param_name = param.split(":")[0].split("=")[0].strip()
+                if param_name:
+                    result.append(param_name)
+
+        return result
+
+    def generate_proxy_file(self,
+                            snapshot: Dict[str, Dict[str, Any]],
+                            output_path: str,
+                            filename: str = "generated_proxy.py") -> str:
+        """
+        Generate the complete proxy file from a snapshot of instruments.
+
+        Args:
+            snapshot: Dictionary containing instrument data with functions
+            output_path: Directory to write the output file
+            filename: Name of the output file
+
+        Returns:
+            Path to the generated file
+        """
+        class_definitions = {}
+        self.used_typing_symbols.clear()
+
+        # Process each instrument in the snapshot
+        for instrument_key, instrument_data in snapshot.items():
+            # Convert function signatures to strings if needed
+            for function_key, function_data in instrument_data.items():
+                if 'signature' in function_data:
+                    function_data['signature'] = str(function_data['signature'])
+
+            # Extract class name from instrument path
+            class_name = instrument_key.split('.')[-1]
+
+            # Generate class definition
+            class_definitions[class_name] = self.create_class_definition(
+                class_name, instrument_data
+            )
+
+            # Track typing symbols used
+            self.extract_typing_from_signatures(instrument_data)
+
+        # Write the complete file
+        filepath = self._write_proxy_file(class_definitions, output_path, filename)
+        return filepath
+
+    def _write_proxy_file(self,
+                          class_definitions: Dict[str, str],
+                          output_path: str,
+                          filename: str) -> str:
+        """
+        Write the generated classes to a Python file.
+
+        Args:
+            class_definitions: Dictionary of class names to class definition strings
+            output_path: Directory to write the file
+            filename: Name of the file
+
+        Returns:
+            Full path to the written file
+        """
+        filepath = os.path.join(output_path, filename)
+
+        with open(filepath, "w") as f:
+            # Write imports
+            f.write("import requests\n")
+            if self.used_typing_symbols:
+                f.write(f"from typing import {', '.join(sorted(self.used_typing_symbols))}\n")
+            f.write("\n")
+
+            # Write session setup
+            f.write("session = requests.Session()\n\n")
+
+            # Write class definitions
+            for class_name, class_def in class_definitions.items():
+                f.write(class_def)
+                f.write("\n")
+
+            # Create default instances
+            f.write("# Default instances for convenience\n")
+            for class_name in class_definitions.keys():
+                instance_name = class_name.lower()
+                f.write(f"{instance_name} = {class_name.capitalize()}()\n")
+
+        return filepath
 
-        method += '}).json()\n'
-        class_template += method + '\n'
+    def generate_from_flask_route(self,
+                                  snapshot: Dict[str, Dict[str, Any]],
+                                  request_url_root: str,
+                                  output_folder: str) -> str:
+        """
+        Convenience method that matches the original Flask route behavior.
 
-    return class_template
+        Args:
+            snapshot: The deck snapshot from global_config
+            request_url_root: The URL root from Flask request
+            output_folder: Output folder path from app config
 
-# Function to export the generated classes to a Python script
-def export_to_python(class_definitions, path):
-    with open(os.path.join(path, "generated_proxy.py"), 'w') as f:
-        # Writing the imports at the top of the script
-        f.write('import requests\n\n')
-        f.write('session = requests.Session()\n\n')
+        Returns:
+            Path to the generated file
+        """
+        # Set the base URL from the request
+        self.base_url = request_url_root.rstrip('/')
 
-        # Writing each class definition to the file
-        for class_name, class_def in class_definitions.items():
-            f.write(class_def)
-            f.write('\n')
+        # Generate the proxy file
+        return self.generate_proxy_file(snapshot, output_folder)
 
-        # Creating instances of the dynamically generated classes
-        for class_name in class_definitions.keys():
-            instance_name = class_name.lower()  # Using lowercase for instance names
-            f.write(f'{instance_name} = {class_name.capitalize()}()\n')
+    def _generate_init(self):
+        return '''    def __init__(self, username=None, password=None):
+        """Initialize the client with authentication."""
+        self.username = username
+        self.password = password
+        self._auth()
 
+'''
 
 
+    def _generate_auth(self):
+        return f"""    def _auth(self):
+        username = self.username or 'admin'
+        password = self.password or 'admin'
+        res = session.post(
+            '{self.base_url}/ivoryos/auth/login',
+            data={{"username": username, "password": password}}
+        )
+        if res.status_code != 200:
+            raise Exception("Authentication failed")
+                    
+"""