ivoryos 0.1.20__py3-none-any.whl → 0.1.21__py3-none-any.whl

ivoryos/static/js/socket_handler.js

@@ -27,6 +27,57 @@ document.addEventListener("DOMContentLoaded", function() {
         }, 1000);  // Small delay to let users see the completion
         }
     });
+
+    socket.on('error', function(errorData) {
+        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
+        var errorModal = new bootstrap.Modal(document.getElementById('error-modal'));
+        document.getElementById('error-message').innerText = "An error occurred: " + errorData.message;
+        errorModal.show();
+
+    });
+
+    // Handle Pause/Resume Button
+    document.getElementById('pause-resume').addEventListener('click', function() {
+        socket.emit('pause');
+        console.log('Pause/Resume is toggled.');
+        var button = this;
+        var icon = button.querySelector("i");
+
+        // Toggle Pause and Resume
+        if (icon.classList.contains("bi-pause-circle")) {
+            icon.classList.remove("bi-pause-circle");
+            icon.classList.add("bi-play-circle");
+            button.innerHTML = '<i class="bi bi-play-circle"></i>';
+            button.setAttribute("title", "Resume execution");
+        } else {
+            icon.classList.remove("bi-play-circle");
+            icon.classList.add("bi-pause-circle");
+            button.innerHTML = '<i class="bi bi-pause-circle"></i>';
+            button.setAttribute("title", "Pause execution");
+        }
+    });
+
+    // Handle Modal Buttons
+    document.getElementById('continue-btn').addEventListener('click', function() {
+        socket.emit('pause');  // Resume execution
+        console.log("Execution resumed.");
+    });
+
+    document.getElementById('stop-btn').addEventListener('click', function() {
+        socket.emit('pause');  // Resume execution
+        socket.emit('abort_current');  // Stop execution
+        console.log("Execution stopped.");
+
+        // Reset UI back to initial state
+        document.getElementById("code-panel").style.display = "none";
+        document.getElementById("run-panel").style.display = "block";
+    });
+
     socket.on('log', function(data) {
         var logMessage = data.message;
         console.log(logMessage);
@@ -49,24 +100,16 @@ document.addEventListener("DOMContentLoaded", function() {
     }
     });
 
-    document.getElementById('pause-resume').addEventListener('click', function() {
+    socket.on('execution', function(data) {
+        // Remove highlighting from all lines
+        document.querySelectorAll('pre code').forEach(el => el.style.backgroundColor = '');
 
-        socket.emit('pause');
-        console.log('Pause/Resume is toggled.');
-        var button = this;
-        var icon = button.querySelector("i");
+        // Get the currently executing line and highlight it
+        let executingLine = document.getElementById(data.section);
+        if (executingLine) {
+            executingLine.style.backgroundColor = '#cce5ff'; // Highlight
+            executingLine.style.transition = 'background-color 0.3s ease-in-out';
 
-        // Toggle between Pause and Resume
-        if (icon.classList.contains("bi-pause-circle")) {
-            icon.classList.remove("bi-pause-circle");
-            icon.classList.add("bi-play-circle");
-            button.innerHTML = '<i class="bi bi-play-circle"></i>';
-            button.setAttribute("title", "Resume execution");
-        } else {
-            icon.classList.remove("bi-play-circle");
-            icon.classList.add("bi-pause-circle");
-            button.innerHTML = '<i class="bi bi-pause-circle"></i>';
-            button.setAttribute("title", "Pause execution");
         }
     });
 });

ivoryos/static/js/sortable_design.js

@@ -1,36 +1,105 @@
-$(document).ready(function(){
-    function slideout(){
-        setTimeout(function(){
-            $("#response").slideUp("slow", function () {});
-        }, 2000);
-    }
+$(document).ready(function () {
+    let dropTargetId = ""; // Store the ID of the drop target
+
+    $("#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"));
+            });
+            var order_string = "order=" + item_order.join(",");
+
+            $.ajax({
+                method: "POST",
+                url: updateListUrl,
+                data: order_string,
+                cache: false,
+                success: function (data) {
+                    $("#response").html(data);
+                    $("#response").slideDown("slow");
+                    slideout();
+                }
+            });
+        }
+    });
+
+    // 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
+        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) {
+        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
+        } 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
+        } else {
+            dropTargetId = "";  // Append placeholder to canvas
+        }
+    });
 
-    $("#response").hide();
-
-    $(function() {
-        $("#list ul").sortable({
-            cancel: ".unsortable",
-            opacity: 0.8,
-            cursor: 'move',
-            update: function() {
-                var item_order = [];
-                $('ul.reorder li').each(function() {
-                    item_order.push($(this).attr("id"));
-                });
-                var order_string = 'order=' + item_order.join(',');
-
-                $.ajax({
-                    method: "POST",
-                    url: updateListUrl,  // updateListUrl should be set dynamically in your HTML template
-                    data: order_string,
-                    cache: false,
-                    success: function(data){
-                        $("#response").html(data);
-                        $("#response").slideDown('slow');
-                        slideout();
-                    }
-                });
-            }
-        });
+    $("#list ul, .canvas").on("dragleave", function () {
+        $(".drop-placeholder").remove(); // Remove placeholder on leave
     });
+
+    $("#list ul, .canvas").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
+        let listLength = $("ul.reorder li").length;
+        dropTargetId = dropTargetId || listLength + 1;  // Assign a "last" ID or unique identifier
+        $(".drop-placeholder").remove();
+            // Trigger the modal with the appropriate action
+        triggerModal(formHtml, actionName, actionId, 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
+
+            // 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);
+
+            // Insert before the submit button
+            $form.find("button[type='submit']").before($hiddenInput);
+
+            $("#modalFormFields").empty().append($form.children());
+            $("#dropModal").modal("show"); // Show modal
+
+            // Store and display drop target ID in the modal
+            $("#modalDropTarget").text(dropTargetId || "N/A");
+
+            $("#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!");
+        }
+    }
 });

ivoryos/static/style.css

@@ -199,4 +199,13 @@ hr.vertical {
     color: white;
     font-size: 24px;
     padding-top: 20%;
+}
+.drop-placeholder {
+    height: 2px !important;  /* Keep it very thin */
+    min-height: 2px !important;
+    margin: 0 !important;
+    padding: 0 !important;
+    background: rgba(0, 0, 0, 0.2); /* Slight visibility */
+    border-radius: 2px;
+    list-style: none; /* Remove any default list styling */
 }

ivoryos/templates/base.html

@@ -54,9 +54,9 @@
                     <li class="nav-item">
                         <a class="nav-link" href="{{ url_for('control.controllers_home') }}">Temp Devices</a></li>
                     </li>
-                    <li class="nav-item">
-                        <a class="nav-link" href="{{ url_for('main.help_info') }}">About</a>
-                    </li>
+{#                    <li class="nav-item">#}
+{#                        <a class="nav-link" href="{{ url_for('main.help_info') }}">About</a>#}
+{#                    </li>#}
                     {% if plugins %}
                         {% for plugin in plugins %}
                             <li class="nav-item">

ivoryos/utils/db_models.py

@@ -196,28 +196,37 @@ class Script(db.Model):
             for i in self.stypes:
                 self._sort(i)
 
-    def add_action(self, action: dict):
+    def add_action(self, action: dict, insert_position=None):
         current_len = len(self.currently_editing_script)
         action_to_add = action.copy()
         action_to_add['id'] = current_len + 1
         action_to_add['uuid'] = uuid.uuid4().fields[-1]
         self.currently_editing_script.append(action_to_add)
-        self.currently_editing_order.append(str(current_len + 1))
+        self._insert_action(insert_position, current_len)
         self.update_time_stamp()
 
-    def add_variable(self, statement, variable, type):
+    def add_variable(self, statement, variable, type, insert_position=None):
         variable = self.validate_function_name(variable)
         convert_type = getattr(builtins, type)
         statement = convert_type(statement)
         current_len = len(self.currently_editing_script)
         uid = uuid.uuid4().fields[-1]
-        action_list = [{"id": current_len + 1, "instrument": 'variable', "action": variable,
+        action = {"id": current_len + 1, "instrument": 'variable', "action": variable,
                         "args": {"statement": 'None' if statement == '' else statement}, "return": '', "uuid": uid,
-                        "arg_types": {"statement": type}}]
-        self.currently_editing_script.extend(action_list)
-        self.currently_editing_order.extend([str(current_len + i + 1) for i in range(len(action_list))])
+                        "arg_types": {"statement": type}}
+        self.currently_editing_script.append(action)
+        self._insert_action(insert_position, current_len)
         self.update_time_stamp()
 
+    def _insert_action(self, insert_position, current_len, action_len:int=1):
+
+        if insert_position is None:
+            self.currently_editing_order.extend([str(current_len + i + 1) for i in range(action_len)])
+        else:
+            index = int(insert_position) - 1
+            self.currently_editing_order[index:index] = [str(current_len + i + 1) for i in range(action_len)]
+            self.sort_actions()
+
     def get_added_variables(self):
         added_variables: Dict[str, str] = {action["action"]: action["arg_types"]["statement"] for action in
                                            self.currently_editing_script if action["instrument"] == "variable"}
@@ -251,7 +260,7 @@ class Script(db.Model):
                 kwargs[key] = f"#{self.validate_function_name(value[1:])}"
         return kwargs
 
-    def add_logic_action(self, logic_type: str, statement):
+    def add_logic_action(self, logic_type: str, statement, insert_position=None):
         current_len = len(self.currently_editing_script)
         uid = uuid.uuid4().fields[-1]
         logic_dict = {
@@ -291,7 +300,7 @@ class Script(db.Model):
         }
         action_list = logic_dict[logic_type]
         self.currently_editing_script.extend(action_list)
-        self.currently_editing_order.extend([str(current_len + i + 1) for i in range(len(action_list))])
+        self._insert_action(insert_position, current_len, len(action_list))
         self.update_time_stamp()
 
     def delete_action(self, id: int):
@@ -446,7 +455,8 @@ class Script(db.Model):
         configure = [param + f":{param_type}" if not param_type == "any" else "" for param, param_type in
                      config_type.items()]
 
-        function_header = f"def {run_name}_{stype}("
+        script_type = f"_{stype}" if stype != "script" else ""
+        function_header = f"def {run_name}{script_type}("
 
         if stype == "script":
             function_header += ", ".join(configure)
@@ -492,6 +502,9 @@ class Script(db.Model):
             return f"{self.indent(indent_unit)}time.sleep({statement})", indent_unit
         elif instrument == 'repeat':
             return self._process_repeat(indent_unit, action_name, statement, next_action)
+        #todo
+        # elif instrument == 'registered_workflows':
+        #     return inspect.getsource(my_function)
         else:
             return self._process_instrument_action(indent_unit, instrument, action_name, args, save_data)
 

ivoryos/utils/form.py

@@ -7,6 +7,10 @@ from flask_wtf import FlaskForm
 from wtforms import StringField, FloatField, HiddenField, BooleanField, IntegerField
 import inspect
 
+from ivoryos.utils.db_models import Script
+from ivoryos.utils.global_config import GlobalConfig
+
+global_config = GlobalConfig()
 
 def find_variable(data, script):
     """
@@ -345,6 +349,13 @@ def create_form_from_action(action: dict, script=None, design=True):
         setattr(DynamicForm, 'return', return_value)
     return DynamicForm()
 
+def create_all_builtin_forms(script):
+    all_builtin_forms = {}
+    for logic_name in ['if', 'while', 'variable', 'wait', 'repeat']:
+        # signature = info.get('signature', {})
+        form_class = create_builtin_form(logic_name, script)
+        all_builtin_forms[logic_name] = form_class()
+    return all_builtin_forms
 
 def create_builtin_form(logic_type, script):
     """
@@ -379,14 +390,51 @@ def create_builtin_form(logic_type, script):
                                      render_kw=render_kwargs)
         type_field = SelectField(
             'Select Input Type',
-            choices=[('int', 'Integer'), ('float', 'Float'), ('str', 'String')],
+            choices=[('int', 'Integer'), ('float', 'Float'), ('str', 'String'), ('bool', 'Boolean')],
             default='str'  # Optional default value
         )
         setattr(BuiltinFunctionForm, "variable", variable_field)
         setattr(BuiltinFunctionForm, "type", type_field)
     hidden_field = HiddenField(name=f'builtin_name', render_kw={"value": f'{logic_type}'})
     setattr(BuiltinFunctionForm, "builtin_name", hidden_field)
-    return BuiltinFunctionForm()
+    return BuiltinFunctionForm
+
+
+def get_method_from_workflow(function_string):
+    """Creates a function from a string and assigns it a new name."""
+
+    namespace = {}
+    exec(function_string, globals(), namespace)  # Execute the string in a safe namespace
+    func_name = next(iter(namespace))
+    # Get the function name dynamically
+    return namespace[func_name]
+
+
+def create_workflow_forms(script, autofill: bool = False, design: bool = False):
+    workflow_forms = {}
+    functions = {}
+    class RegisteredWorkflows:
+        pass
+
+    deck_name = script.deck
+    workflows = Script.query.filter(Script.deck==deck_name, Script.name != script.name).all()
+    for workflow in workflows:
+        compiled_strs = workflow.compile().get('script', "")
+        method = get_method_from_workflow(compiled_strs)
+        functions[workflow.name] = dict(signature=inspect.signature(method), docstring=inspect.getdoc(method))
+        setattr(RegisteredWorkflows, workflow.name, method)
+
+        form_class = create_form_for_method(method, autofill, script, design)
+
+        hidden_method_name = HiddenField(name=f'hidden_name', description="",
+                                         render_kw={"value": f'{workflow.name}'})
+        if design:
+            return_value = StringField(label='Save value as', render_kw={"placeholder": "Optional"})
+            setattr(form_class, 'return', return_value)
+        setattr(form_class, 'workflow_name', hidden_method_name)
+        workflow_forms[workflow.name] = form_class()
+    global_config.registered_workflows = RegisteredWorkflows
+    return workflow_forms, functions
 
 
 def create_action_button(script, stype=None):

ivoryos/utils/global_config.py

@@ -8,6 +8,7 @@ class GlobalConfig:
         if cls._instance is None:
             cls._instance = super(GlobalConfig, cls).__new__(cls, *args, **kwargs)
             cls._instance._deck = None
+            cls._instance._registered_workflows = None
             cls._instance._agent = None
             cls._instance._defined_variables = {}
             cls._instance._api_variables = set()
@@ -24,6 +25,15 @@ class GlobalConfig:
         if self._deck is None:
             self._deck = value
 
+    @property
+    def registered_workflows(self):
+        return self._registered_workflows
+
+    @registered_workflows.setter
+    def registered_workflows(self, value):
+        if self._registered_workflows is None:
+            self._registered_workflows = value
+
 
     @property
     def deck_snapshot(self):

ivoryos/utils/script_runner.py

@@ -24,9 +24,11 @@ class ScriptRunner:
         self.stop_current_event = threading.Event()
         self.is_running = False
         self.lock = threading.Lock()
+        self.paused = False
 
     def toggle_pause(self):
         """Toggles between pausing and resuming the script"""
+        self.paused = not self.paused
         if self.pause_event.is_set():
             self.pause_event.clear()  # Pause the script
             return "Paused"
@@ -34,10 +36,15 @@ class ScriptRunner:
             self.pause_event.set()  # Resume the script
             return "Resumed"
 
+    def pause_status(self):
+        """Toggles between pausing and resuming the script"""
+        return self.paused
+
     def reset_stop_event(self):
         """Resets the stop event"""
         self.stop_pending_event.clear()
         self.stop_current_event.clear()
+        self.pause_event.set()
 
     def abort_pending(self):
         """Abort the pending iteration after the current is finished"""
@@ -68,7 +75,7 @@ class ScriptRunner:
         thread.start()
         return thread
 
-    def execute_function_line_by_line(self, lines:list, section_name, logger, socketio, **kwargs):
+    def exex_steps(self, script, section_name, logger, socketio, **kwargs):
         """
         Executes a function defined in a string line by line.
 
@@ -76,73 +83,89 @@ class ScriptRunner:
         :param kwargs: Arguments to pass to the function
         :return: The final result of the function execution
         """
+        _func_str = script.compile()
+        step_list: list = script.convert_to_lines(_func_str).get(section_name, [])
         global deck
         if deck is None:
             deck = global_config.deck
         # func_str = script.compile()
         # Parse function body from string
-
+        temp_connections = global_config.defined_variables
         # Prepare execution environment
-        exec_globals = {"deck": deck}  # Add required global objects
+        exec_globals = {"deck": deck, "time":time}  # Add required global objects
+        # exec_globals = {"deck": deck, "time": time, "registered_workflows":registered_workflows}  # Add required global objects
+        exec_globals.update(temp_connections)
         exec_locals = {}  # Local execution scope
 
         # Define function arguments manually in exec_locals
         exec_locals.update(kwargs)
+        index = 0
 
         # Execute each line dynamically
-        for index, line in enumerate(lines):
+        while index < len(step_list):
             if self.stop_current_event.is_set():
                 logger.info(f'Stopping execution during {section_name}')
                 break
+            line = step_list[index]
             logger.info(f"Executing: {line}")  # Debugging output
             socketio.emit('execution', {'section': f"{section_name}-{index}"})
             # self._emit_progress(socketio, 100)
-            exec(line, exec_globals, exec_locals)
+            try:
+                exec(line, exec_globals, exec_locals)
+            except Exception as e:
+                logger.error(f"Error during script execution: {e}")
+                socketio.emit('error', {'message': e.__str__()})
+                self.toggle_pause()
             self.pause_event.wait()
 
+            # todo update script during the run
+            # _func_str = script.compile()
+            # step_list: list = script.convert_to_lines(_func_str).get(section_name, [])
+            index += 1
         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):
         time.sleep(1)
-        func_str = script.compile()
-        func_str_lines = script.convert_to_lines(func_str)
+        # _func_str = script.compile()
+        # step_list_dict: dict = script.convert_to_lines(_func_str)
         self._emit_progress(socketio, 1)
-        try:
-            # Run "prep" section once
-            script_dict = script.script_dict
-            self._run_actions(script_dict.get("prep", []), func_str_lines.get("prep", []), section_name="prep", logger=logger, socketio=socketio)
-            output_list = []
-            _, arg_type = script.config("script")
-            _, return_list = script.config_return()
-            # Run "script" section multiple times
-            if repeat_count:
-                self._run_repeat_section(repeat_count, arg_type, bo_args, output_list, func_str_lines.get("script", []),
-                                         run_name, return_list, logger, socketio)
-            elif config:
-                self._run_config_section(config, arg_type, output_list, func_str_lines.get("script", []), run_name, logger,
-                                         socketio)
-            # Run "cleanup" section once
-            self._run_actions(script_dict.get("cleanup", []), func_str.get("cleanup", []), section_name="cleanup",
-                              logger=logger, socketio=socketio)
-            # Save results if necessary
-            if output_list:
-                self._save_results(run_name, arg_type, return_list, output_list, logger, output_path)
-        except Exception as e:
-            logger.error(f"Error during script execution: {e}")
-        finally:
-            with self.lock:
-                self.is_running = False  # Reset the running flag when done
-            self._emit_progress(socketio, 100)
-
-    def _run_actions(self, actions, func_str, section_name="", logger=None, socketio=None):
-        logger.info(f'Executing {section_name} steps') if actions else logger.info(f'No {section_name} steps')
+
+        # Run "prep" section once
+        script_dict = script.script_dict
+        self._run_actions(script, section_name="prep", logger=logger, socketio=socketio)
+        output_list = []
+        _, arg_type = script.config("script")
+        _, return_list = script.config_return()
+
+        # Run "script" section multiple times
+        if repeat_count:
+            self._run_repeat_section(repeat_count, arg_type, bo_args, output_list, script,
+                                     run_name, return_list, logger, socketio)
+        elif config:
+            self._run_config_section(config, arg_type, output_list, script, run_name, logger,
+                                     socketio)
+
+        # Run "cleanup" section once
+        self._run_actions(script, section_name="cleanup", logger=logger, socketio=socketio)
+        # Reset the running flag when done
+        with self.lock:
+            self.is_running = False
+        # Save results if necessary
+        if output_list:
+            self._save_results(run_name, arg_type, return_list, output_list, logger, output_path)
+        self._emit_progress(socketio, 100)
+
+    def _run_actions(self, script, section_name="", logger=None, socketio=None):
+        _func_str = script.compile()
+        step_list: list = script.convert_to_lines(_func_str).get(section_name, [])
+        logger.info(f'Executing {section_name} steps') if step_list else logger.info(f'No {section_name} steps')
         if self.stop_pending_event.is_set():
             logger.info(f"Stopping execution during {section_name} section.")
             return
-        self.execute_function_line_by_line(func_str, section_name, logger, socketio)
+        self.exex_steps(script, section_name, logger, socketio)
 
-    def _run_config_section(self, config, arg_type, output_list, func_str, run_name, logger, socketio):
+    def _run_config_section(self, config, arg_type, output_list, script, run_name, logger, socketio):
         compiled = True
         for i in config:
             try:
@@ -162,12 +185,12 @@ class ScriptRunner:
                 self._emit_progress(socketio, progress)
                 # fname = f"{run_name}_script"
                 # function = self.globals_dict[fname]
-                output = self.execute_function_line_by_line(func_str, "script", logger, socketio, **kwargs)
+                output = self.exex_steps(script, "script", logger, socketio, **kwargs)
                 if output:
                     # kwargs.update(output)
                     output_list.append(output)
 
-    def _run_repeat_section(self, repeat_count, arg_types, bo_args, output_list, func_str, run_name, return_list,
+    def _run_repeat_section(self, repeat_count, arg_types, bo_args, output_list, script, run_name, return_list,
                             logger, socketio):
         if bo_args:
             logger.info('Initializing optimizer...')
@@ -185,7 +208,7 @@ class ScriptRunner:
                     logger.info(f'Output value: {parameters}')
                     # fname = f"{run_name}_script"
                     # function = self.globals_dict[fname]
-                    output = self.execute_function_line_by_line(func_str, "script", logger, socketio, **parameters)
+                    output = self.exex_steps(script, "script", logger, socketio, **parameters)
 
                     _output = {key: value for key, value in output.items() if key in return_list}
                     ax_client.complete_trial(trial_index=trial_index, raw_data=_output)
@@ -196,7 +219,7 @@ class ScriptRunner:
             else:
                 # fname = f"{run_name}_script"
                 # function = self.globals_dict[fname]
-                output = self.execute_function_line_by_line(func_str, "script", logger, socketio)
+                output = self.exex_steps(script, "script", logger, socketio)
 
             if output:
                 output_list.append(output)

ivoryos/utils/utils.py

@@ -97,7 +97,7 @@ def _inspect_class(class_object=None, debug=False):
     under_score = "_"
     if debug:
         under_score = "__"
-    for function, method in inspect.getmembers(type(class_object), predicate=inspect.isfunction):
+    for function, method in inspect.getmembers(type(class_object), predicate=callable):
         if not function.startswith(under_score) and not function.isupper():
             try:
                 annotation = inspect.signature(method)

ivoryos/version.py

@@ -1 +1 @@
-__version__ = "0.1.20"
+__version__ = "0.1.21"