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

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)
@@ -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}
 
@@ -325,7 +332,9 @@ def create_add_form(attr, attr_name, autofill: bool, script=None, design: bool =
     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
@@ -341,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
 
 
@@ -398,14 +410,24 @@ 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)
         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": name,
-            "default": f'{value}',
-            "validators": [InputRequired()],
+            "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,
@@ -418,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()
@@ -439,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")',
@@ -529,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', '')}"
@@ -547,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 = {}
@@ -16,6 +17,8 @@ class GlobalConfig:
             cls._instance._runner_lock = threading.Lock()
             cls._instance._runner_status = None
             cls._instance._optimizers = {}
+            cls._instance._notification_handlers = []
+
         return cls._instance
 
     @property
@@ -27,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

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

ivoryos/utils/py_to_json.py

@@ -2,6 +2,20 @@ import ast
 import json
 import uuid
 
+
+from ivoryos.utils.global_config import GlobalConfig
+
+global_config = GlobalConfig()
+
+if global_config.building_blocks:
+    building_blocks = {
+        inner_key: f"{block_key}.{inner_key}"
+        for block_key, block_value in global_config.building_blocks.items()
+        for inner_key in block_value.keys()
+    }
+else:
+    building_blocks = {}
+
 def generate_uuid():
     return int(str(uuid.uuid4().int)[:15])
 
@@ -37,10 +51,14 @@ def convert_to_cards(source_code: str):
     def is_supported_assignment(node):
         return (
             isinstance(node.targets[0], ast.Name) and
-            isinstance(node.value, (ast.Constant, ast.Num, ast.Str, ast.NameConstant))
+            isinstance(node.value, ast.Constant)
         )
 
     class CardVisitor(ast.NodeVisitor):
+        def __init__(self):
+            self.defined_types = {}  # <-- always exists
+
+
         def visit_FunctionDef(self, node):
             self.defined_types = {
                 arg.arg: ast.unparse(arg.annotation) if arg.annotation else "float"
@@ -128,14 +146,20 @@ def convert_to_cards(source_code: str):
                     "return": "",
                     "uuid": generate_uuid()
                 })
+            elif isinstance(node.value, ast.Await):
+                self.handle_call(node.value.value, ret_var=node.targets[0].id, awaited=True)
+
             elif isinstance(node.value, ast.Call):
                 self.handle_call(node.value, ret_var=node.targets[0].id)
 
         def visit_Expr(self, node):
-            if isinstance(node.value, ast.Call):
+            if isinstance(node.value, ast.Await):
+                # node.value is ast.Await
+                self.handle_call(node.value.value, awaited=True)
+            elif isinstance(node.value, ast.Call):
                 self.handle_call(node.value)
 
-        def handle_call(self, node, ret_var=""):
+        def handle_call(self, node, ret_var="", awaited=False):
             func_parts = []
             f = node.func
             while isinstance(f, ast.Attribute):
@@ -143,11 +167,48 @@ def convert_to_cards(source_code: str):
                 f = f.value
             if isinstance(f, ast.Name):
                 func_parts.insert(0, f.id)
-            if not func_parts or not func_parts[0].startswith("deck"):
+
+            full_func_name = ".".join(func_parts)
+
+            # Check if this is a deck call or a building block
+            if full_func_name.startswith("deck.") or full_func_name.startswith("blocks."):
+                instrument = ".".join(func_parts[:-1])
+                action = func_parts[-1]
+            # not starting with deck or block, check if it's a decorated function
+            # ["general", "action"] or ["action"]
+            elif func_parts[-1] in building_blocks.keys():
+                instrument = building_blocks.get(func_parts[-1])
+                action = func_parts[-1]
+            else:
+                # ignore other calls
+                return
+
+
+
+            # --- special case for time.sleep ---
+            if instrument == "time" and action == "sleep":
+                wait_value = None
+                if node.args:
+                    arg_node = node.args[0]
+                    if isinstance(arg_node, ast.Constant):
+                        wait_value = arg_node.value
+                    elif isinstance(arg_node, ast.Name):
+                        wait_value = f"#{arg_node.id}"
+                    else:
+                        wait_value = ast.unparse(arg_node)
+
+                add_card({
+                    "action": "wait",
+                    "arg_types": {"statement": infer_type(wait_value)},
+                    "args": {"statement": wait_value},
+                    "id": new_id(),
+                    "instrument": "wait",
+                    "return": ret_var,
+                    "uuid": generate_uuid()
+                })
                 return
+            # -----------------------------------
 
-            instrument = ".".join(func_parts[:-1])
-            action = func_parts[-1]
 
             args = {}
             arg_types = {}
@@ -155,7 +216,7 @@ def convert_to_cards(source_code: str):
             for kw in node.keywords:
                 if kw.arg is None and isinstance(kw.value, ast.Dict):
                     for k_node, v_node in zip(kw.value.keys, kw.value.values):
-                        key = k_node.s if isinstance(k_node, ast.Constant) else ast.unparse(k_node)
+                        key = k_node.value if isinstance(k_node, ast.Constant) else ast.unparse(k_node)
                         if isinstance(v_node, ast.Constant):
                             value = v_node.value
                         elif isinstance(v_node, ast.Name):
@@ -178,7 +239,7 @@ def convert_to_cards(source_code: str):
                         else infer_type(value)
                     )
 
-            add_card({
+            card = {
                 "action": action,
                 "arg_types": arg_types,
                 "args": args,
@@ -186,7 +247,12 @@ def convert_to_cards(source_code: str):
                 "instrument": instrument,
                 "return": ret_var,
                 "uuid": generate_uuid()
-            })
+            }
+
+            if awaited:
+                card["coroutine"] = True  # mark as coroutine if awaited
+
+            add_card(card)
 
     CardVisitor().visit(tree)
     return cards
@@ -216,10 +282,14 @@ if __name__ == "__main__":
     # Step 4: Analyze the sample
     analysis_results = deck.sdl.analyze(param_1=1, param_2=2)
     
+    # test block 
+    result = blocks.general.test(**{'a': 1, 'b': 2})
+    
     # Brief pause for system stability
     time.sleep(1.0)
     
     # Return only analysis results
     return {'analysis_results': analysis_results}
     '''
-    print(json.dumps(convert_to_cards(test)))
+    from pprint import pprint
+    pprint(json.dumps(convert_to_cards(test)))