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

ivoryos/utils/db_models.py

@@ -27,6 +27,9 @@ class User(db.Model, UserMixin):
     # email = db.Column(db.String)
     hashPassword = db.Column(db.String(255))
 
+    # New columns for logo customization
+    settings = db.Column(JSONType, nullable=True)
+
     # password = db.Column()
     def __init__(self, username, password):
         # self.id = id
@@ -122,7 +125,7 @@ class Script(db.Model):
                 pass
         raise TypeError(f"Input type error: cannot convert '{args}' to {arg_type}.")
 
-    def update_by_uuid(self, uuid, args, output):
+    def update_by_uuid(self, uuid, args, output, batch_action=False):
         action = self.find_by_uuid(uuid)
         if not action:
             return
@@ -134,6 +137,7 @@ class Script(db.Model):
             pass
         action['args'] = args
         action['return'] = output
+        action['batch_action'] = batch_action
 
     @staticmethod
     def eval_list(args, arg_types):
@@ -265,11 +269,20 @@ class Script(db.Model):
         output_variables: Dict[str, str] = self.get_variables()
         # print(output_variables)
         for key, value in kwargs.items():
-            if type(value) is str and value in output_variables:
-                var_type = output_variables[value]
-                kwargs[key] = {value: var_type}
-            if isinstance(value, str) and value.startswith("#"):
-                kwargs[key] = f"#{self.validate_function_name(value[1:])}"
+            if isinstance(value, str):
+                if value in output_variables:
+                    var_type = output_variables[value]
+                    kwargs[key] = f"#{value}"
+                elif value.startswith("#"):
+                    kwargs[key] = f"#{self.validate_function_name(value[1:])}"
+                else:
+                    # attempt to convert to numerical or bool value for args with no type hint
+                    try:
+                        converted = ast.literal_eval(value)
+                        if isinstance(converted, (int, float, bool)):
+                            kwargs[key] = converted
+                    except (ValueError, SyntaxError):
+                        pass
         return kwargs
 
     def add_logic_action(self, logic_type: str, statement, insert_position=None):
@@ -309,6 +322,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)
@@ -355,28 +374,32 @@ class Script(db.Model):
         :return: list of variable that require input
         """
         configure = []
+        variables = self.get_variables()
+        # print(variables)
         config_type_dict = {}
         for action in self.script_dict[stype]:
             args = action['args']
             if args is not None:
                 if type(args) is not dict:
-                    if type(args) is str and args.startswith("#") and not args[1:] in configure:
-                        configure.append(args[1:])
-                        config_type_dict[args[1:]] = action['arg_types']
+                    if type(args) is str and args.startswith("#"):
+                        key = args[1:]
+                        if key not in (*variables, *configure):
+                            configure.append(key)
+                            config_type_dict[key] = action['arg_types']
 
                 else:
                     for arg in args:
-                        if type(args[arg]) is str \
-                                and args[arg].startswith("#") \
-                                and not args[arg][1:] in configure:
-                            configure.append(args[arg][1:])
-                            if arg in action['arg_types']:
-                                if action['arg_types'][arg] == '':
-                                    config_type_dict[args[arg][1:]] = "any"
+                        if type(args[arg]) is str and args[arg].startswith("#"):
+                            key = args[arg][1:]
+                            if key not in (*variables, *configure):
+                                configure.append(key)
+                                if arg in action['arg_types']:
+                                    if action['arg_types'][arg] == '':
+                                        config_type_dict[key] = "any"
+                                    else:
+                                        config_type_dict[key] = action['arg_types'][arg]
                                 else:
-                                    config_type_dict[args[arg][1:]] = action['arg_types'][arg]
-                            else:
-                                config_type_dict[args[arg][1:]] = "any"
+                                    config_type_dict[key] = "any"
         # todo
         return configure, config_type_dict
 
@@ -387,7 +410,7 @@ class Script(db.Model):
         """
 
         return_list = set([action['return'] for action in self.script_dict['script'] if not action['return'] == ''])
-        output_str = "return {"
+        output_str = "{"
         for i in return_list:
             output_str += "'" + i + "':" + i + ","
         output_str += "}"
@@ -419,21 +442,114 @@ class Script(db.Model):
         :return: A dict containing script types as keys and lists of function body lines as values.
         """
         line_collection = {}
+
         for stype, func_str in exec_str_collection.items():
             if func_str:
                 module = ast.parse(func_str)
-                func_def = next(node for node in module.body if isinstance(node, ast.FunctionDef))
 
-                # Extract function body as source lines
-                line_collection[stype] = [ast_unparse(node) for node in func_def.body if not isinstance(node, ast.Return)]
-                # print(line_collection[stype])
+                # Find the first function (regular or async)
+                func_def = next(
+                    node for node in module.body
+                    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+                )
+
+                # Extract function body as source lines, skipping 'return' nodes
+                line_collection[stype] = [
+                    ast_unparse(node) for node in func_def.body if not isinstance(node, ast.Return)
+                ]
         return line_collection
 
-    def compile(self, script_path=None):
+    def render_script_lines(self, script_dict):
+        """
+        Convert the script_dict structure into a dict of displayable Python-like lines,
+        keeping ID consistency for highlighting.
+        """
+
+        def render_args(args):
+            if not args:
+                return ""
+            return ", ".join(f"{k}={v}" for k, v in args.items())
+
+        def parse_block(block):
+            lines = []
+            indent = 0
+            stack = []
+
+            for action in block:
+                act = action["action"]
+                _id = action["id"]
+                instrument = action["instrument"]
+
+                # Handle control structures
+                if act == "if":
+                    stmt = action["args"].get("statement", "")
+                    lines.append("    " * indent + f"if {stmt}:")
+                    indent += 1
+                    stack.append("if")
+
+                elif act == "else":
+                    indent -= 1
+                    lines.append("    " * indent + f"else:")
+                    indent += 1
+
+                elif act in ("endif", "endwhile"):
+                    if stack:
+                        stack.pop()
+                    indent = max(indent - 1, 0)
+                    lines.append("    " * indent + f"# {act}")
+
+                elif act == "while":
+                    stmt = action["args"].get("statement", "")
+                    lines.append("    " * indent + f"while {stmt}:")
+                    indent += 1
+                    stack.append("while")
+
+                elif act == "wait":
+                    stmt = action["args"].get("statement", "")
+                    lines.append("    " * indent + f"time.sleep({stmt})")
+
+                elif instrument == "variable":
+                    stmt = action["args"].get("statement", "")
+                    lines.append("    " * indent + f"{act} = {stmt}")
+
+
+                else:
+                    # Regular function call
+                    instr = action["instrument"]
+                    args = render_args(action.get("args", {}))
+                    ret = action.get("return")
+                    line = "    " * indent
+                    if ret:
+                        line += f"{ret} = {instr}.{act}({args})"
+                    else:
+                        line += f"{instr}.{act}({args})"
+                    lines.append(line)
+
+            # Ensure empty control blocks get "pass"
+            final_lines = []
+            for i, line in enumerate(lines):
+                final_lines.append(line)
+                # if line.strip().startswith("else") and (
+                #         i == len(lines) - 1 or lines[i + 1].startswith("#") or "endif" in lines[i + 1]
+                # ):
+                    # final_lines.append("    " * (indent) + "pass")
+
+            return final_lines
+
+        return {
+            "prep": parse_block(script_dict.get("prep", [])),
+            "script": parse_block(script_dict.get("script", [])),
+            "cleanup": parse_block(script_dict.get("cleanup", []))
+        }
+
+    def compile(self, script_path=None, batch=False, mode="sample"):
         """
         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)
@@ -441,7 +557,8 @@ class Script(db.Model):
 
         for i in self.stypes:
             if self.script_dict[i]:
-                func_str = self._generate_function_header(run_name, i) + self._generate_function_body(i)
+                is_async = any(a.get("coroutine", False) for a in self.script_dict[i])
+                func_str = self._generate_function_header(run_name, i, is_async, batch) + self._generate_function_body(i, batch, mode)
                 exec_str_collection[i] = func_str
         if script_path:
             self._write_to_file(script_path, run_name, exec_str_collection)
@@ -459,50 +576,70 @@ class Script(db.Model):
             name += '_'
         return name
 
-    def _generate_function_header(self, run_name, stype):
+    def _generate_function_header(self, run_name, stype, is_async, batch=False):
         """
         Generate the function header.
         """
         configure, config_type = self.config(stype)
-
-        configure = [param + f":{param_type}" if not param_type == "any" else "" for param, param_type in
+        configure = [param + f":{param_type}" if not param_type == "any" else param for param, param_type in
                      config_type.items()]
 
         script_type = f"_{stype}" if stype != "script" else ""
-        function_header = f"def {run_name}{script_type}("
+        async_str = "async " if is_async else ""
+        function_header = f"{async_str}def {run_name}{script_type}("
 
         if stype == "script":
-            function_header += ", ".join(configure)
-
+            if batch:
+                function_header += "param_list" if configure else "n: int"
+            else:
+                function_header += ", ".join(configure)
         function_header += "):"
-        # function_header += self.indent(1) + f"global {run_name}_{stype}"
+
+        if stype == "script" and batch:
+            function_header += self.indent(1) + f'"""Batch mode is experimental and may have bugs."""'
         return function_header
 
-    def _generate_function_body(self, stype):
+    def _generate_function_body(self, stype, batch=False, mode="sample"):
         """
         Generate the function body for each type in stypes.
         """
         body = ''
         indent_unit = 1
+        if batch and stype == "script":
+            return_str, return_list = self.config_return()
+            configure, config_type = self.config(stype)
+            if not configure:
+                body += self.indent(indent_unit) + "param_list = [{} for _ in range(n)]"
+            for index, action in enumerate(self.script_dict[stype]):
+                text, indent_unit = self._process_action(indent_unit, action, index, stype, batch)
+                body += text
+            if return_list:
+                # body += self.indent(indent_unit) + f"result_list.append({return_str})"
+                body += self.indent(indent_unit) + "return param_list"
 
-        for index, action in enumerate(self.script_dict[stype]):
-            text, indent_unit = self._process_action(indent_unit, action, index, stype)
-            body += text
-        return_str, return_list = self.config_return()
-        if return_list and stype == "script":
-            body += self.indent(indent_unit) + return_str
+        else:
+            for index, action in enumerate(self.script_dict[stype]):
+                text, indent_unit = self._process_action(indent_unit, action, index, stype)
+                body += text
+            return_str, return_list = self.config_return()
+            if return_list and stype == "script":
+                body += self.indent(indent_unit) + f"return {return_str}"
         return body
 
-    def _process_action(self, indent_unit, action, index, stype):
+    def _process_action(self, indent_unit, action, index, stype, batch=False, mode="sample"):
         """
         Process each action within the script dictionary.
         """
+        configure, config_type = self.config(stype)
+
         instrument = action['instrument']
         statement = action['args'].get('statement')
         args = self._process_args(action['args'])
 
         save_data = action['return']
         action_name = action['action']
+        batch_action = action.get("batch_action", False)
+
         next_action = self._get_next_action(stype, index)
         # print(args)
         if instrument == 'if':
@@ -510,16 +647,29 @@ class Script(db.Model):
         elif instrument == 'while':
             return self._process_while(indent_unit, action_name, statement, next_action)
         elif instrument == 'variable':
+            if batch:
+                return self.indent(indent_unit) + "for param in param_list:" + self.indent(indent_unit + 1) + f"param['{action_name}'] = {statement}", indent_unit
+
             return self.indent(indent_unit) + f"{action_name} = {statement}", indent_unit
         elif instrument == 'wait':
+            if batch:
+                return f"{self.indent(indent_unit)}for param in param_list:" + f"{self.indent(indent_unit+1)}time.sleep({statement})", indent_unit
             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 == 'pause':
+            self.needs_call_human = True
+            if batch:
+                return f"{self.indent(indent_unit)}for param in param_list:" + f"{self.indent(indent_unit+1)}pause('{statement}')", indent_unit
+            return f"{self.indent(indent_unit)}pause('{statement}')", indent_unit
+        # todo
         # elif instrument == 'registered_workflows':
         #     return inspect.getsource(my_function)
         else:
-            return self._process_instrument_action(indent_unit, instrument, action_name, args, save_data)
+            is_async = action.get("coroutine", False)
+            dynamic_arg = len(self.get_variables()) > 0
+            return self._process_instrument_action(indent_unit, instrument, action_name, args, save_data, is_async, dynamic_arg, batch, batch_action)
 
     def _process_args(self, args):
         """
@@ -579,23 +729,44 @@ class Script(db.Model):
             indent_unit -= 1
         return exec_string, indent_unit
 
-    def _process_instrument_action(self, indent_unit, instrument, action, args, save_data):
+    def _process_instrument_action(self, indent_unit, instrument, action, args, save_data, is_async=False, dynamic_arg=False,
+                                   batch=False, batch_action=False):
         """
         Process actions related to instruments.
         """
+        async_str = "await " if is_async else ""
 
-        if isinstance(args, dict):
+        function_call = f"{instrument}.{action}"
+        if instrument.startswith("blocks"):
+            self.blocks_included = True
+            function_call = action
+
+        if isinstance(args, dict) and args != {}:
             args_str = self._process_dict_args(args)
-            single_line = f"{instrument}.{action}(**{args_str})"
+            single_line = f"{async_str}{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"{async_str}{function_call}()"
+
 
-        if save_data:
-            save_data += " = "
+        save_data_str = save_data + " = " if save_data else ''
+
+        if batch and not batch_action:
+            arg_list = [args[arg][1:] for arg in args if isinstance(args[arg], str) and args[arg].startswith("#")]
+            param_str = [f"param['{arg_list}']" for arg_list in arg_list if arg_list]
+            args_str = self.indent(indent_unit + 1) +  ", ".join(arg_list) + " = " + ", ".join(param_str) if arg_list else ""
+            if dynamic_arg:
+                for_string = self.indent(indent_unit) + "for param in param_list:" + args_str
+            else:
+                for_string = self.indent(indent_unit) + "for i in range(n):"
+            output_code = for_string + self.indent(indent_unit + 1) + save_data_str + single_line
+            if save_data:
+                output_code = output_code + self.indent(indent_unit + 1) + f"param['{save_data}'] = {save_data}"
+        else:
+            output_code = self.indent(indent_unit) + save_data_str + single_line
 
-        return self.indent(indent_unit) + save_data + single_line, indent_unit
+        return output_code, indent_unit
 
     def _process_dict_args(self, args):
         """
@@ -607,12 +778,21 @@ class Script(db.Model):
                 args_str = args_str.replace(f"'#{args[arg][1:]}'", args[arg][1:])
             elif isinstance(args[arg], dict):
                 # print(args[arg])
-                variables = self.get_variables()
+                if not args[arg]:
+                    continue
+                # Extract the variable name (first key in the dict)
                 value = next(iter(args[arg]))
-                if value not in variables:
-                    raise ValueError(f"Variable ({value}) is not defined.")
-                args_str = args_str.replace(f"{args[arg]}", next(iter(args[arg])))
-            # elif self._is_variable(arg):
+                var_type = args[arg].get(value)
+
+                # Only process if it's a function_output variable reference
+                if var_type == "function_output":
+                    variables = self.get_variables()
+                    if value not in variables:
+                        raise ValueError(f"Variable ({value}) is not defined.")
+                    # Replace the dict string representation with just the variable name
+                    args_str = args_str.replace(f"{args[arg]}", value)
+
+        # elif self._is_variable(arg):
             #     print("is variable")
             #     args_str = args_str.replace(f"'{args[arg]}'", args[arg])
         return args_str
@@ -631,7 +811,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.
         """
@@ -641,10 +821,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)
@@ -653,30 +853,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()
@@ -693,7 +928,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,34 @@
+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),
+            "coroutine": inspect.iscoroutinefunction(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"])