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

ivoryos/utils/form.py

@@ -1,5 +1,10 @@
 from enum import Enum
-from typing import get_origin, get_args, Union, Any
+from typing import Union, Any
+try:
+    from typing import get_origin, get_args
+except ImportError:
+    # For Python versions = 3.7, use typing_extensions
+    from typing_extensions import get_origin, get_args
 
 from wtforms.fields.choices import SelectField
 from wtforms.fields.core import Field
@@ -205,20 +210,15 @@ 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())}")
 
 
-def format_name(name):
-    """Converts 'example_name' to 'Example Name'."""
-    name = name.split(".")[-1]
-    text = ' '.join(word for word in name.split('_'))
-    return text.capitalize()
 
 def parse_annotation(annotation):
     """
@@ -264,7 +264,7 @@ def create_form_for_method(method, autofill, script=None, design=True):
     for param in sig.parameters.values():
         if param.name == 'self':
             continue
-        formatted_param_name = format_name(param.name)
+        # formatted_param_name = format_name(param.name)
 
         default_value = None
         if autofill:
@@ -277,7 +277,7 @@ def create_form_for_method(method, autofill, script=None, design=True):
                     default_value = param.default
 
         field_kwargs = {
-            "label": formatted_param_name,
+            "label": param.name,
             "default": default_value,
             "validators": [InputRequired()] if param.default is param.empty else [Optional()],
             **({"script": script} if (autofill or design) else {})
@@ -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)
@@ -299,6 +301,11 @@ def create_form_for_method(method, autofill, script=None, design=True):
             if optional:
                 field_kwargs["filters"] = [lambda x: x if x != '' else None]
 
+            if annotation is bool:
+                # Boolean fields should not use InputRequired
+                field_kwargs["validators"] = []  # or [Optional()]
+            else:
+                field_kwargs["validators"] = [InputRequired()] if param.default is param.empty else [Optional()]
 
         render_kwargs = {"placeholder": placeholder_text}
 
@@ -321,10 +328,13 @@ def create_add_form(attr, attr_name, autofill: bool, script=None, design: bool =
     """
     signature = attr.get('signature', {})
     docstring = attr.get('docstring', "")
+    # print(signature, docstring)
     dynamic_form = create_form_for_method(signature, autofill, script, design)
     if design:
         return_value = StringField(label='Save value as', render_kw={"placeholder": "Optional"})
+        batch_action = BooleanField(label='Batch Action', render_kw={"placeholder": "Optional"})
         setattr(dynamic_form, 'return', return_value)
+        setattr(dynamic_form, 'batch_action', batch_action)
     hidden_method_name = HiddenField(name=f'hidden_name', description=docstring, render_kw={"value": f'{attr_name}'})
     setattr(dynamic_form, 'hidden_name', hidden_method_name)
     return dynamic_form
@@ -340,13 +350,16 @@ def create_form_from_module(sdl_module, autofill: bool = False, script=None, des
     """
     method_forms = {}
     for attr_name in dir(sdl_module):
-        method = getattr(sdl_module, attr_name)
-        if inspect.ismethod(method) and not attr_name.startswith('_'):
-            signature = inspect.signature(method)
-            docstring = inspect.getdoc(method)
-            attr = dict(signature=signature, docstring=docstring)
-            form_class = create_add_form(attr, attr_name, autofill, script, design)
-            method_forms[attr_name] = form_class()
+        try:
+            method = getattr(sdl_module, attr_name)
+            if inspect.ismethod(method) and not attr_name.startswith('_'):
+                signature = inspect.signature(method)
+                docstring = inspect.getdoc(method)
+                attr = dict(signature=signature, docstring=docstring)
+                form_class = create_add_form(attr, attr_name, autofill, script, design)
+                method_forms[attr_name] = form_class()
+        except Exception as e:
+            print(f"Error creating form for {attr_name}: {e}")
     return method_forms
 
 
@@ -395,16 +408,26 @@ def create_form_from_action(action: dict, script=None, design=True):
     }
 
     for name, param_type in arg_types.items():
-        formatted_param_name = format_name(name)
+        # formatted_param_name = format_name(name)
         value = args.get(name, "")
-        if type(value) is dict:
+        if type(value) is dict and value:
             value = next(iter(value))
+        if not value or value == "None":
+            value = None
+        else:
+            value = f'{value}'
+
         field_kwargs = {
-            "label": formatted_param_name,
-            "default": f'{value}',
-            "validators": [InputRequired()],
+            "label": name,
+            "default": f'{value}' if value else None,
+            # todo get optional/required from snapshot
+            "validators": [Optional()],
             **({"script": script})
         }
+        if type(param_type) is list:
+            none_type = param_type[1]
+            if none_type == "NoneType":
+                param_type = param_type[0]
         param_type = param_type if type(param_type) is str else f"{param_type}"
         field_class, placeholder_text = annotation_mapping.get(
             param_type,
@@ -417,13 +440,16 @@ def create_form_from_action(action: dict, script=None, design=True):
         setattr(DynamicForm, name, field)
 
     if design:
+        if "batch_action" in action:
+            batch_action = BooleanField(label='Batch Action', default=bool(action["batch_action"]))
+            setattr(DynamicForm, 'batch_action', batch_action)
         return_value = StringField(label='Save value as', default=f"{save_as}", render_kw={"placeholder": "Optional"})
         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']:
+    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()
@@ -438,7 +464,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")',
@@ -528,9 +555,12 @@ def _action_button(action: dict, variables: dict):
     """
     style = {
         "repeat": "background-color: lightsteelblue",
-        "if": "background-color: salmon",
-        "while": "background-color: salmon",
+        "if": "background-color: mistyrose",
+        "while": "background-color: #a8b5a2",
+        "pause": "background-color: palegoldenrod",
     }.get(action['instrument'], "")
+    if not style:
+        style = "background-color: thistle" if 'batch_action' in action and action["batch_action"] else ""
 
     if action['instrument'] in ['if', 'while', 'repeat']:
         text = f"{action['action']} {action['args'].get('statement', '')}"
@@ -546,9 +576,13 @@ def _action_button(action: dict, variables: dict):
                 arg_list = []
                 for k, v in action['args'].items():
                     if isinstance(v, dict):
-                        value = next(iter(v))  # Extract the first key if it's a dict
-                        # show warning color for variable calling when there is no definition
-                        style = "background-color: khaki" if value not in variables.keys() else ""
+                        if not v:
+                            value = v  # Keep the original value if not a dict
+                        else:
+                            value = next(iter(v))  # Extract the first key if it's a dict
+                            # show warning color for variable calling when there is no definition
+
+                            style = "background-color: khaki" if v.get(value) == "function_output" and value not in variables.keys() else ""
                     else:
                         value = v  # Keep the original value if not a dict
                     arg_list.append(f"{k} = {value}")  # Format the key-value pair

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 = {}
@@ -15,6 +16,9 @@ class GlobalConfig:
             cls._instance._deck_snapshot = {}
             cls._instance._runner_lock = threading.Lock()
             cls._instance._runner_status = None
+            cls._instance._optimizers = {}
+            cls._instance._notification_handlers = []
+
         return cls._instance
 
     @property
@@ -26,6 +30,24 @@ class GlobalConfig:
         if self._deck is None:
             self._deck = value
 
+    def register_notification(self, handler):
+        if not callable(handler):
+            raise ValueError("Handler must be callable")
+        self._notification_handlers.append(handler)
+
+    @property
+    def notification_handlers(self):
+        return self._notification_handlers
+
+    @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
@@ -84,4 +106,15 @@ class GlobalConfig:
 
     @runner_status.setter
     def runner_status(self, value):
-        self._runner_status = value
+        self._runner_status = value
+
+    @property
+    def optimizers(self):
+        return self._optimizers
+
+    @optimizers.setter
+    def optimizers(self, value):
+        if isinstance(value, dict):
+            self._optimizers = value
+        else:
+            raise ValueError("Optimizers must be a dictionary.")

ivoryos/utils/nest_script.py

@@ -0,0 +1,314 @@
+class ConditionalStructureError(Exception):
+    """Raised when conditional structure is invalid"""
+    pass
+
+
+class ConditionalStructureError(Exception):
+    """Raised when control flow structure is invalid"""
+    pass
+
+
+class ConditionalStructureError(Exception):
+    """Raised when control flow structure is invalid"""
+    pass
+
+
+def validate_and_nest_control_flow(flat_steps):
+    """
+    Validates and converts flat control flow structures to nested blocks.
+
+    Handles:
+    - if/else/endif -> if_block/else_block
+    - repeat/endrepeat -> repeat_block
+    - while/endwhile -> while_block
+
+    Raises:
+        ConditionalStructureError: If the control flow structure is invalid
+    """
+    nested_steps = []
+    i = 0
+
+    while i < len(flat_steps):
+        step = flat_steps[i]
+        action = step["action"]
+
+        # Check for misplaced closing/middle statements
+        if action in ["else", "endif", "endrepeat", "endwhile"]:
+            raise ConditionalStructureError(
+                f"Found '{action}' at position {i} without matching opening statement. "
+                f"UUID: {step.get('uuid')}"
+            )
+
+        # Handle IF statements
+        if action == "if":
+            nested_step, steps_consumed = process_if_block(flat_steps, i)
+            nested_steps.append(nested_step)
+            i += steps_consumed
+
+        # Handle REPEAT statements
+        elif action == "repeat":
+            nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+            nested_steps.append(nested_step)
+            i += steps_consumed
+
+        # Handle WHILE statements
+        elif action == "while":
+            nested_step, steps_consumed = process_while_block(flat_steps, i)
+            nested_steps.append(nested_step)
+            i += steps_consumed
+
+        else:
+            # Regular step - add as-is
+            nested_steps.append(step)
+            i += 1
+
+    return nested_steps
+
+
+def process_if_block(flat_steps, start_index):
+    """
+    Process an if/else/endif block starting at start_index.
+
+    Returns:
+        tuple: (nested_step_with_blocks, total_steps_consumed)
+    """
+    step = flat_steps[start_index].copy()
+    if_uuid = step["uuid"]
+    if_block = []
+    else_block = []
+    current_block = if_block
+    found_else = False
+    found_endif = False
+    i = start_index + 1
+
+    while i < len(flat_steps):
+        current_step = flat_steps[i]
+        current_action = current_step["action"]
+
+        if current_action == "else":
+            if current_step["uuid"] == if_uuid:
+                if found_else:
+                    raise ConditionalStructureError(
+                        f"Multiple 'else' blocks found for if statement with UUID {if_uuid}. "
+                        f"Second 'else' at position {i}"
+                    )
+                current_block = else_block
+                found_else = True
+                i += 1
+                continue
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'else' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endif for if with UUID {if_uuid}"
+                )
+
+        elif current_action == "endif":
+            if current_step["uuid"] == if_uuid:
+                found_endif = True
+                i += 1
+                break
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'endif' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endif for if with UUID {if_uuid}"
+                )
+
+        elif current_action == "if":
+            # Nested if - process it
+            try:
+                nested_step, steps_consumed = process_if_block(flat_steps, i)
+                current_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested if starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "repeat":
+            # Nested repeat - process it
+            try:
+                nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+                current_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested repeat starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "while":
+            # Nested while - process it
+            try:
+                nested_step, steps_consumed = process_while_block(flat_steps, i)
+                current_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested while starting at position {i}: {str(e)}"
+                )
+
+        else:
+            # Regular step
+            current_block.append(current_step)
+            i += 1
+
+    if not found_endif:
+        raise ConditionalStructureError(
+            f"Missing 'endif' for if statement with UUID {if_uuid} starting at position {start_index}"
+        )
+
+    step["if_block"] = if_block
+    step["else_block"] = else_block
+
+    return step, i - start_index
+
+
+def process_repeat_block(flat_steps, start_index):
+    """
+    Process a repeat/endrepeat block starting at start_index.
+
+    Returns:
+        tuple: (nested_step_with_block, total_steps_consumed)
+    """
+    step = flat_steps[start_index].copy()
+    repeat_uuid = step["uuid"]
+    repeat_block = []
+    found_endrepeat = False
+    i = start_index + 1
+
+    while i < len(flat_steps):
+        current_step = flat_steps[i]
+        current_action = current_step["action"]
+
+        if current_action == "endrepeat":
+            if current_step["uuid"] == repeat_uuid:
+                found_endrepeat = True
+                i += 1
+                break
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'endrepeat' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endrepeat for repeat with UUID {repeat_uuid}"
+                )
+
+        elif current_action == "if":
+            # Nested if - process it
+            try:
+                nested_step, steps_consumed = process_if_block(flat_steps, i)
+                repeat_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested if starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "repeat":
+            # Nested repeat - process it
+            try:
+                nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+                repeat_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested repeat starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "while":
+            # Nested while - process it
+            try:
+                nested_step, steps_consumed = process_while_block(flat_steps, i)
+                repeat_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested while starting at position {i}: {str(e)}"
+                )
+
+        else:
+            # Regular step
+            repeat_block.append(current_step)
+            i += 1
+
+    if not found_endrepeat:
+        raise ConditionalStructureError(
+            f"Missing 'endrepeat' for repeat statement with UUID {repeat_uuid} starting at position {start_index}"
+        )
+
+    step["repeat_block"] = repeat_block
+
+    return step, i - start_index
+
+
+def process_while_block(flat_steps, start_index):
+    """
+    Process a while/endwhile block starting at start_index.
+
+    Returns:
+        tuple: (nested_step_with_block, total_steps_consumed)
+    """
+    step = flat_steps[start_index].copy()
+    while_uuid = step["uuid"]
+    while_block = []
+    found_endwhile = False
+    i = start_index + 1
+
+    while i < len(flat_steps):
+        current_step = flat_steps[i]
+        current_action = current_step["action"]
+
+        if current_action == "endwhile":
+            if current_step["uuid"] == while_uuid:
+                found_endwhile = True
+                i += 1
+                break
+            else:
+                raise ConditionalStructureError(
+                    f"Found 'endwhile' with UUID {current_step['uuid']} at position {i}, "
+                    f"but expecting endwhile for while with UUID {while_uuid}"
+                )
+
+        elif current_action == "if":
+            # Nested if - process it
+            try:
+                nested_step, steps_consumed = process_if_block(flat_steps, i)
+                while_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested if starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "repeat":
+            # Nested repeat - process it
+            try:
+                nested_step, steps_consumed = process_repeat_block(flat_steps, i)
+                while_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested repeat starting at position {i}: {str(e)}"
+                )
+
+        elif current_action == "while":
+            # Nested while - process it
+            try:
+                nested_step, steps_consumed = process_while_block(flat_steps, i)
+                while_block.append(nested_step)
+                i += steps_consumed
+            except ConditionalStructureError as e:
+                raise ConditionalStructureError(
+                    f"Error in nested while starting at position {i}: {str(e)}"
+                )
+
+        else:
+            # Regular step
+            while_block.append(current_step)
+            i += 1
+
+    if not found_endwhile:
+        raise ConditionalStructureError(
+            f"Missing 'endwhile' for while statement with UUID {while_uuid} starting at position {start_index}"
+        )
+
+    step["while_block"] = while_block
+
+    return step, i - start_index