ivoryos 1.2.7__py3-none-any.whl → 1.3.0__py3-none-any.whl

ivoryos/server.py

@@ -0,0 +1,168 @@
+import os
+import sqlite3
+import sys
+from typing import Union
+
+from flask import Blueprint
+
+from sqlalchemy import Engine, event
+
+# from ivoryos import BUILDING_BLOCKS
+from ivoryos.app import create_app
+from ivoryos.config import Config, get_config
+from ivoryos.optimizer.registry import OPTIMIZER_REGISTRY
+from ivoryos.routes.auth.auth import login_manager
+from ivoryos.routes.control.control import global_config
+from ivoryos.socket_handlers import socketio
+from ivoryos.utils import utils
+from ivoryos.utils.db_models import db, User
+
+
+url_prefix = os.getenv('URL_PREFIX', "/ivoryos")
+
+@event.listens_for(Engine, "connect")
+def enforce_sqlite_foreign_keys(dbapi_connection, connection_record):
+    if isinstance(dbapi_connection, sqlite3.Connection):
+        cursor = dbapi_connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()
+
+
+
+@login_manager.user_loader
+def load_user(user_id):
+    """
+    This function is called by Flask-Login on every request to get the
+    current user object from the user ID stored in the session.
+    """
+    # The correct implementation is to fetch the user from the database.
+    return db.session.get(User, user_id)
+
+
+
+
+
+def run(module=None, host="0.0.0.0", port=None, debug=None, llm_server=None, model=None,
+        config: Config = None,
+        logger: Union[str, list] = None,
+        logger_output_name: str = None,
+        enable_design: bool = True,
+        blueprint_plugins: Union[list, Blueprint] = [],
+        exclude_names: list = [],
+        ):
+    """
+    Start ivoryOS app server.
+
+    :param module: module name, __name__ for current module
+    :param host: host address, defaults to 0.0.0.0
+    :param port: port, defaults to None, and will use 8000
+    :param debug: debug mode, defaults to None (True)
+    :param llm_server: llm server, defaults to None.
+    :param model: llm model, defaults to None. If None, app will run without text-to-code feature
+    :param config: config class, defaults to None
+    :param logger: logger name of list of logger names, defaults to None
+    :param logger_output_name: log file save name of logger, defaults to None, and will use "default.log"
+    :param enable_design: enable design canvas, database and workflow execution
+    :param blueprint_plugins: Union[list[Blueprint], Blueprint] custom Blueprint pages
+    :param exclude_names: list[str] module names to exclude from parsing
+    """
+    app = create_app(config_class=config or get_config())  # Create app instance using factory function
+
+    # plugins = load_installed_plugins(app, socketio)
+    plugins = []
+    if blueprint_plugins:
+        config_plugins = load_plugins(blueprint_plugins, app, socketio)
+        plugins.extend(config_plugins)
+
+    def inject_nav_config():
+        """Make NAV_CONFIG available globally to all templates."""
+        return dict(
+            enable_design=enable_design,
+            plugins=plugins,
+        )
+
+    app.context_processor(inject_nav_config)
+    port = port or int(os.environ.get("PORT", 8000))
+    debug = debug if debug is not None else app.config.get('DEBUG', True)
+
+    app.config["LOGGERS"] = logger
+    app.config["LOGGERS_PATH"] = logger_output_name or app.config["LOGGERS_PATH"]  # default.log
+    logger_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["LOGGERS_PATH"])
+    dummy_deck_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["DUMMY_DECK"])
+    global_config.optimizers = OPTIMIZER_REGISTRY
+    if module:
+        app.config["MODULE"] = module
+        app.config["OFF_LINE"] = False
+        global_config.deck = sys.modules[module]
+        global_config.building_blocks = utils.create_block_snapshot()
+        global_config.deck_snapshot = utils.create_deck_snapshot(global_config.deck,
+                                                                 output_path=dummy_deck_path,
+                                                                 save=True,
+                                                                 exclude_names=exclude_names
+                                                                 )
+
+    else:
+        app.config["OFF_LINE"] = True
+    if model:
+        app.config["ENABLE_LLM"] = True
+        app.config["LLM_MODEL"] = model
+        app.config["LLM_SERVER"] = llm_server
+        utils.install_and_import('openai')
+        from ivoryos.utils.llm_agent import LlmAgent
+        global_config.agent = LlmAgent(host=llm_server, model=model,
+                                       output_path=app.config["OUTPUT_FOLDER"] if module is not None else None)
+    else:
+        app.config["ENABLE_LLM"] = False
+    if logger and type(logger) is str:
+        utils.start_logger(socketio, log_filename=logger_path, logger_name=logger)
+    elif type(logger) is list:
+        for log in logger:
+            utils.start_logger(socketio, log_filename=logger_path, logger_name=log)
+
+    # TODO in case Python 3.12 or higher doesn't log URL
+    # if sys.version_info >= (3, 12):
+    #     ip = utils.get_local_ip()
+    #     print(f"Server running at http://localhost:{port}")
+    #     if not ip == "127.0.0.1":
+    #         print(f"Server running at http://{ip}:{port}")
+    socketio.run(app, host=host, port=port, debug=debug, use_reloader=False, allow_unsafe_werkzeug=True)
+    # return app
+
+
+# def load_installed_plugins(app, socketio):
+#     """
+#     Dynamically load installed plugins and attach Flask-SocketIO.
+#     """
+#     plugin_names = []
+#     for entry_point in entry_points().get("ivoryos.plugins", []):
+#         plugin = entry_point.load()
+#
+#         # If the plugin has an `init_socketio()` function, pass socketio
+#         if hasattr(plugin, 'init_socketio'):
+#             plugin.init_socketio(socketio)
+#
+#         plugin_names.append(entry_point.name)
+#         app.register_blueprint(getattr(plugin, entry_point.name), url_prefix=f"{url_prefix}/{entry_point.name}")
+#
+#     return plugin_names
+
+
+def load_plugins(blueprints: Union[list, Blueprint], app, socketio):
+    """
+    Dynamically load installed plugins and attach Flask-SocketIO.
+    :param blueprints: Union[list, Blueprint] list of Blueprint objects or a single Blueprint object
+    :param app: Flask application instance
+    :param socketio: Flask-SocketIO instance
+    :return: list of plugin names
+    """
+    plugin_names = []
+    if not isinstance(blueprints, list):
+        blueprints = [blueprints]
+    for blueprint in blueprints:
+        # If the plugin has an `init_socketio()` function, pass socketio
+        if hasattr(blueprint, 'init_socketio'):
+            blueprint.init_socketio(socketio)
+        plugin_names.append(blueprint.name)
+        app.register_blueprint(blueprint, url_prefix=f"{url_prefix}/{blueprint.name}")
+    return plugin_names
+

ivoryos/static/js/socket_handler.js

@@ -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

@@ -115,20 +115,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/utils/db_models.py

@@ -318,6 +318,12 @@ class Script(db.Model):
                     {"id": current_len + 2, "instrument": 'repeat', "action": 'endrepeat',
                      "args": {}, "return": '', "uuid": uid},
                 ],
+            "pause":
+                [
+                    {"id": current_len + 1, "instrument": 'pause', "action": "pause",
+                     "args": {"statement": 1 if statement == '' else statement}, "return": '', "uuid": uid,
+                     "arg_types": {"statement": "str"}}
+                ],
         }
         action_list = logic_dict[logic_type]
         self.currently_editing_script.extend(action_list)
@@ -443,6 +449,9 @@ class Script(db.Model):
         Compile the current script to a Python file.
         :return: String to write to a Python file.
         """
+        self.needs_call_human = False
+        self.blocks_included = False
+
         self.sort_actions()
         run_name = self.name if self.name else "untitled"
         run_name = self.validate_function_name(run_name)
@@ -524,6 +533,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)
+        elif instrument == 'pause':
+            self.needs_call_human = True
+            return f"{self.indent(indent_unit)}pause('{statement}')", indent_unit
         #todo
         # elif instrument == 'registered_workflows':
         #     return inspect.getsource(my_function)
@@ -592,14 +604,18 @@ class Script(db.Model):
         """
         Process actions related to instruments.
         """
+        function_call = f"{instrument}.{action}"
+        if instrument.startswith("blocks"):
+            self.blocks_included = True
+            function_call = action
 
-        if isinstance(args, dict):
+        if isinstance(args, dict) and args != {}:
             args_str = self._process_dict_args(args)
-            single_line = f"{instrument}.{action}(**{args_str})"
+            single_line = f"{function_call}(**{args_str})"
         elif isinstance(args, str):
-            single_line = f"{instrument}.{action} = {args}"
+            single_line = f"{function_call} = {args}"
         else:
-            single_line = f"{instrument}.{action}()"
+            single_line = f"{function_call}()"
 
         if save_data:
             save_data += " = "
@@ -640,7 +656,7 @@ class Script(db.Model):
         """
         return arg in self.script_dict and self.script_dict[arg].get("arg_types") == "variable"
 
-    def _write_to_file(self, script_path, run_name, exec_string):
+    def _write_to_file(self, script_path, run_name, exec_string, call_human=False):
         """
         Write the compiled script to a file.
         """
@@ -650,10 +666,30 @@ class Script(db.Model):
             else:
                 s.write("deck = None")
             s.write("\nimport time")
+            if self.blocks_included:
+                s.write(f"\n{self._create_block_import()}")
+            if self.needs_call_human:
+                s.write("""\n\ndef pause(reason="Manual intervention required"):\n\tprint(f"\\nHUMAN INTERVENTION REQUIRED: {reason}")\n\tinput("Press Enter to continue...\\n")""")
+
             for i in exec_string.values():
                 s.write(f"\n\n\n{i}")
 
+    def _create_block_import(self):
+        imports = {}
+        from ivoryos.utils.decorators import BUILDING_BLOCKS
+        for category, methods in BUILDING_BLOCKS.items():
+            for method_name, meta in methods.items():
+                func = meta["func"]
+                module = meta["path"]
+                name = func.__name__
+                imports.setdefault(module, set()).add(name)
+        lines = []
+        for module, funcs in imports.items():
+            lines.append(f"from {module} import {', '.join(sorted(funcs))}")
+        return "\n".join(lines)
+
 class WorkflowRun(db.Model):
+    """Represents the entire experiment"""
     __tablename__ = 'workflow_runs'
 
     id = db.Column(db.Integer, primary_key=True)
@@ -662,30 +698,65 @@ class WorkflowRun(db.Model):
     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',
+    repeat_mode = db.Column(db.String(64), default="none")  # static_repeat, sweep, optimizer
+
+    # A run contains multiple iterations
+    phases = db.relationship(
+        'WorkflowPhase',
+        backref='workflow_runs', # Clearer back-reference name
         cascade='all, delete-orphan',
-        passive_deletes=True
+        lazy='dynamic' # Good for handling many iterations
     )
     def as_dict(self):
         dict = self.__dict__
         dict.pop('_sa_instance_state', None)
         return dict
 
+class WorkflowPhase(db.Model):
+    """Represents a single function call within a WorkflowRun."""
+    __tablename__ = 'workflow_phases'
+
+    id = db.Column(db.Integer, primary_key=True)
+    # Foreign key to link this iteration to its parent run
+    run_id = db.Column(db.Integer, db.ForeignKey('workflow_runs.id', ondelete='CASCADE'), nullable=False)
+
+    # NEW: Store iteration-specific parameters here
+    name = db.Column(db.String(64), nullable=False)  # 'prep', 'main', 'cleanup'
+    repeat_index = db.Column(db.Integer, default=0)
+
+    parameters = db.Column(JSONType)  # Use db.JSON for general support
+    outputs = db.Column(JSONType)
+    start_time = db.Column(db.DateTime, default=datetime.now)
+    end_time = db.Column(db.DateTime)
+
+    # An iteration contains multiple steps
+    steps = db.relationship(
+        'WorkflowStep',
+        backref='workflow_phases',  # Clearer back-reference name
+        cascade='all, delete-orphan'
+    )
+
+    def as_dict(self):
+        dict = self.__dict__.copy()
+        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)
+    # workflow_id = db.Column(db.Integer, db.ForeignKey('workflow_runs.id', ondelete='CASCADE'), nullable=True)
+    phase_id = db.Column(db.Integer, db.ForeignKey('workflow_phases.id', ondelete='CASCADE'), nullable=True)
 
-    phase = db.Column(db.String(64), nullable=False)  # 'prep', 'main', 'cleanup'
-    repeat_index = db.Column(db.Integer, default=0)   # Only applies to 'main' phase
+    # 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)
+    output = db.Column(JSONType, default={})
+    # Using as_dict method from ModelBase
 
     def as_dict(self):
         dict = self.__dict__.copy()
@@ -702,7 +773,7 @@ class SingleStep(db.Model):
     start_time = db.Column(db.DateTime)
     end_time = db.Column(db.DateTime)
     run_error = db.Column(db.String(128))
-    output = db.Column(JSONType)
+    output = db.Column(JSONType, nullable=True)
 
     def as_dict(self):
         dict = self.__dict__.copy()

ivoryos/utils/decorators.py

@@ -0,0 +1,33 @@
+import inspect
+import os
+
+BUILDING_BLOCKS = {}
+
+def block(_func=None, *, category="general"):
+    def decorator(func):
+        if category not in BUILDING_BLOCKS:
+            BUILDING_BLOCKS[category] = {}
+        if func.__module__ == "__main__":
+            file_path = inspect.getfile(func)  # e.g. /path/to/math_blocks.py
+            module = os.path.splitext(os.path.basename(file_path))[0]
+        else:
+            module = func.__module__
+        BUILDING_BLOCKS[category][func.__name__] = {
+            "func": func,
+            "signature": inspect.signature(func),
+            "docstring": inspect.getdoc(func),
+            "path": module
+        }
+        return func
+    if _func is None:
+        return decorator
+    else:
+        return decorator(_func)
+
+
+class BlockNamespace:
+    """[not in use] Expose methods for one block category as attributes."""
+
+    def __init__(self, methods):
+        for name, meta in methods.items():
+            setattr(self, name, meta["func"])

ivoryos/utils/form.py

@@ -210,10 +210,10 @@ class FlexibleEnumField(StringField):
             if key in self.choices:
                 # Convert the string key to Enum instance
                 self.data = self.enum_class[key].value
-            elif self.data.startswith("#"):
+            elif key.startswith("#"):
                 if not self.script.editing_type == "script":
                     raise ValueError(self.gettext("Variable is not supported in prep/cleanup"))
-                self.data = self.data
+                self.data = key
             else:
                 raise ValidationError(
                     f"Invalid choice: '{key}'. Must match one of {list(self.enum_class.__members__.keys())}")
@@ -286,7 +286,9 @@ def create_form_for_method(method, autofill, script=None, design=True):
             # enum_class = [(e.name, e.value) for e in param.annotation]
             field_class = FlexibleEnumField
             placeholder_text = f"Choose or type a value for {param.annotation.__name__} (start with # for custom)"
+
             extra_kwargs = {"choices": param.annotation}
+
         else:
             # print(param.annotation)
             annotation, optional = parse_annotation(param.annotation)
@@ -429,7 +431,7 @@ def create_form_from_action(action: dict, script=None, design=True):
 
 def create_all_builtin_forms(script):
     all_builtin_forms = {}
-    for logic_name in ['if', 'while', 'variable', 'wait', 'repeat']:
+    for logic_name in ['if', 'while', 'variable', 'wait', 'repeat', 'pause']:
         # signature = info.get('signature', {})
         form_class = create_builtin_form(logic_name, script)
         all_builtin_forms[logic_name] = form_class()
@@ -444,7 +446,8 @@ def create_builtin_form(logic_type, script):
 
     placeholder_text = {
         'wait': 'Enter second',
-        'repeat': 'Enter an integer'
+        'repeat': 'Enter an integer',
+        'pause': 'Human Intervention Message'
     }.get(logic_type, 'Enter statement')
     description_text = {
         'variable': 'Your variable can be numbers, boolean (True or False) or text ("text")',
@@ -536,6 +539,7 @@ def _action_button(action: dict, variables: dict):
         "repeat": "background-color: lightsteelblue",
         "if": "background-color: salmon",
         "while": "background-color: salmon",
+        "pause": "background-color: goldenrod",
     }.get(action['instrument'], "")
 
     if action['instrument'] in ['if', 'while', 'repeat']:

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._building_blocks = None
             cls._instance._registered_workflows = None
             cls._instance._agent = None
             cls._instance._defined_variables = {}
@@ -27,6 +28,15 @@ class GlobalConfig:
         if self._deck is None:
             self._deck = value
 
+    @property
+    def building_blocks(self):
+        return self._building_blocks
+
+    @building_blocks.setter
+    def building_blocks(self, value):
+        if self._building_blocks is None:
+            self._building_blocks = value
+
     @property
     def registered_workflows(self):
         return self._registered_workflows