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

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

@@ -46,17 +46,20 @@
                         <li class="nav-item">
                             <a class="nav-link" href="{{ url_for('design.experiment_run') }}">Compile/Run</a>
                         </li>
+                        <li class="nav-item">
+                            <a class="nav-link" href="{{ url_for('database.list_workflows') }}">Data</a>
+                        </li>
                     {% endif %}
 
                     <li class="nav-item">
                         <a class="nav-link" href="{{ url_for('control.deck_controllers') }}">Devices</a></li>
                     </li>
-                    <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('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>#}
                     {% if plugins %}
                         {% for plugin in plugins %}
                             <li class="nav-item">

ivoryos/utils/client_proxy.py

@@ -0,0 +1,57 @@
+# import argparse
+import os
+
+# import requests
+
+# session = requests.Session()
+
+
+# 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/backend_control/deck.{class_name}"\n'
+
+    for function_name, details in functions.items():
+        signature = details['signature']
+        docstring = details.get('docstring', '')
+
+        # 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}"'
+
+        # 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 []
+
+        for param in params:
+            param_name = param.split(':')[0].strip()  # Split on ':' and get parameter name
+            method += f', "{param_name}": {param_name}'
+
+        method += '}).json()\n'
+        class_template += method + '\n'
+
+    return class_template
+
+# 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')
+
+        # Writing each class definition to the file
+        for class_name, class_def in class_definitions.items():
+            f.write(class_def)
+            f.write('\n')
+
+        # 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')
+
+
+

ivoryos/utils/db_models.py

@@ -44,9 +44,12 @@ class Script(db.Model):
     id_order = db.Column(JSONType, nullable=True)
     editing_type = db.Column(db.String(50), nullable=True)
     author = db.Column(db.String(50), nullable=False)
+    # registered = db.Column(db.Boolean, nullable=True, default=False)
 
     def __init__(self, name=None, deck=None, status=None, script_dict: dict = None, id_order: dict = None,
-                 time_created=None, last_modified=None, editing_type=None, author: str = None):
+                 time_created=None, last_modified=None, editing_type=None, author: str = None,
+                 registered:bool=False,
+                 ):
         if script_dict is None:
             script_dict = {"prep": [], "script": [], "cleanup": []}
         elif type(script_dict) is not dict:
@@ -73,6 +76,7 @@ class Script(db.Model):
         self.id_order = id_order
         self.editing_type = editing_type
         self.author = author
+        # self.r = registered
 
     def as_dict(self):
         dict = self.__dict__
@@ -196,28 +200,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 +264,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 +304,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 +459,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 +506,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)
 
@@ -618,6 +635,44 @@ class Script(db.Model):
             for i in exec_string.values():
                 s.write(f"\n\n\n{i}")
 
+class WorkflowRun(db.Model):
+    __tablename__ = 'workflow_runs'
+
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(128), nullable=False)
+    platform = db.Column(db.String(128), nullable=False)
+    start_time = db.Column(db.DateTime, default=datetime.now())
+    end_time = db.Column(db.DateTime)
+    data_path = db.Column(db.String(256))
+    steps = db.relationship(
+        'WorkflowStep',
+        backref='workflow_runs',
+        cascade='all, delete-orphan',
+        passive_deletes=True
+    )
+    def as_dict(self):
+        dict = self.__dict__
+        dict.pop('_sa_instance_state', None)
+        return dict
+
+class WorkflowStep(db.Model):
+    __tablename__ = 'workflow_steps'
+
+    id = db.Column(db.Integer, primary_key=True)
+    workflow_id = db.Column(db.Integer, db.ForeignKey('workflow_runs.id', ondelete='CASCADE'), nullable=False)
+
+    phase = db.Column(db.String(64), nullable=False)  # 'prep', 'main', 'cleanup'
+    repeat_index = db.Column(db.Integer, default=0)   # Only applies to 'main' phase
+    step_index = db.Column(db.Integer, default=0)
+    method_name = db.Column(db.String(128), nullable=False)
+    start_time = db.Column(db.DateTime)
+    end_time = db.Column(db.DateTime)
+    run_error = db.Column(db.Boolean, default=False)
+
+    def as_dict(self):
+        dict = self.__dict__
+        dict.pop('_sa_instance_state', None)
+        return dict
 
 if __name__ == "__main__":
     a = Script()

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/llm_agent.py

@@ -162,7 +162,7 @@ can you also help find the default value you can't find the info from my request
 
 if __name__ == "__main__":
     from pprint import pprint
-    from example.sdl_example.abstract_sdl import deck
+    from example.abstract_sdl_example.abstract_sdl import deck
 
     from utils import parse_functions