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

ivoryos/utils/bo_campaign.py

@@ -1,7 +1,9 @@
+from typing import Dict, Any
+import re
 from ivoryos.utils.utils import install_and_import
 
 
-def ax_init_form(data, arg_types):
+def ax_init_form(data, arg_types, previous_data_len=0):
     """
     create Ax campaign from the web form input
     :param data:
@@ -9,7 +11,11 @@ def ax_init_form(data, arg_types):
     install_and_import("ax", "ax-platform")
     parameter, objectives = ax_wrapper(data, arg_types)
     from ax.service.ax_client import AxClient
-    ax_client = AxClient()
+    if previous_data_len > 0:
+        gs = exisitng_data_gs(previous_data_len)
+        ax_client = AxClient(generation_strategy=gs)
+    else:
+        ax_client = AxClient()
     ax_client.create_experiment(parameter, objectives=objectives)
     return ax_client
 
@@ -84,4 +90,174 @@ def ax_init_opc(bo_args):
     bo_args["objectives"] = objectives_formatted
     ax_client.create_experiment(**bo_args)
 
-    return ax_client
+    return ax_client
+
+
+def exisitng_data_gs(data_len):
+    """
+    temporal generation strategy for existing data
+    """
+    from ax.generation_strategy.generation_node import GenerationStep
+    from ax.generation_strategy.generation_strategy import GenerationStrategy
+    from ax.modelbridge.registry import Generators
+    if data_len > 4:
+        gs = GenerationStrategy(
+            steps=[
+                GenerationStep(
+                    model=Generators.BOTORCH_MODULAR,
+                    num_trials=-1,
+                    max_parallelism=3,
+                ),
+            ]
+        )
+    else:
+        gs = GenerationStrategy(
+            steps=[
+                GenerationStep(
+                    model=Generators.SOBOL,
+                    num_trials=5-data_len,  # how many sobol trials to perform (rule of thumb: 2 * number of params)
+                    max_parallelism=5,
+                    model_kwargs={"seed": 999},
+                ),
+                GenerationStep(
+                    model=Generators.BOTORCH_MODULAR,
+                    num_trials=-1,
+                    max_parallelism=3,
+                ),
+            ]
+        )
+    return gs
+
+
+def parse_optimization_form(form_data: Dict[str, str]):
+    """
+    Parse dynamic form data into structured optimization configuration.
+
+    Expected form field patterns:
+    - Objectives: {name}_min, {name}_weight
+    - Parameters: {name}_type, {name}_min, {name}_max, {name}_choices, {name}_value_type
+    - Config: step{n}_model, step{n}_num_samples
+    """
+
+    objectives = []
+    parameters = []
+    config = {}
+
+    # Track processed field names to avoid duplicates
+    processed_objectives = set()
+    processed_parameters = set()
+
+    # Parse objectives
+    for field_name, value in form_data.items():
+        if field_name.endswith('_min') and value:
+            # Extract objective name
+            obj_name = field_name.replace('_min', '')
+            if obj_name in processed_objectives:
+                continue
+
+            # Check if corresponding weight exists
+            weight_field = f"{obj_name}_weight"
+            if weight_field in form_data and form_data[weight_field]:
+                objectives.append({
+                    "name": obj_name,
+                    "minimize": value == "minimize",
+                    "weight": float(form_data[weight_field])
+                })
+            else:
+                objectives.append({
+                    "name": obj_name,
+                    "minimize": value == "minimize",
+                })
+            processed_objectives.add(obj_name)
+
+    # Parse parameters
+    for field_name, value in form_data.items():
+        if field_name.endswith('_type') and value:
+            # Extract parameter name
+            param_name = field_name.replace('_type', '')
+            if param_name in processed_parameters:
+                continue
+
+            parameter = {
+                "name": param_name,
+                "type": value
+            }
+
+            # Get value type (default to float)
+            value_type_field = f"{param_name}_value_type"
+            value_type = form_data.get(value_type_field, "float")
+            parameter["value_type"] = value_type
+
+            # Handle different parameter types
+            if value == "range":
+                min_field = f"{param_name}_min"
+                max_field = f"{param_name}_max"
+
+                if min_field in form_data and max_field in form_data:
+                    min_val = form_data[min_field]
+                    max_val = form_data[max_field]
+
+                    if min_val and max_val:
+                        # Convert based on value_type
+                        if value_type == "int":
+                            bounds = [int(min_val), int(max_val)]
+                        elif value_type == "float":
+                            bounds = [float(min_val), float(max_val)]
+                        else:  # string
+                            bounds = [str(min_val), str(max_val)]
+
+                        parameter["bounds"] = bounds
+
+            elif value == "choice":
+                choices_field = f"{param_name}_choices"
+                if choices_field in form_data and form_data[choices_field]:
+                    # Split choices by comma and clean whitespace
+                    choices = [choice.strip() for choice in form_data[choices_field].split(',')]
+
+                    # Convert choices based on value_type
+                    if value_type == "int":
+                        choices = [int(choice) for choice in choices if choice.isdigit()]
+                    elif value_type == "float":
+                        choices = [float(choice) for choice in choices if
+                                   choice.replace('.', '').replace('-', '').isdigit()]
+                    # For string, keep as is
+
+                    parameter["bounds"] = choices
+
+            elif value == "fixed":
+                fixed_field = f"{param_name}_value"
+                if fixed_field in form_data and form_data[fixed_field]:
+                    fixed_val = form_data[fixed_field]
+
+                    # Convert based on value_type
+                    if value_type == "int":
+                        parameter["value"] = int(fixed_val)
+                    elif value_type == "float":
+                        parameter["value"] = float(fixed_val)
+                    else:
+                        parameter["value"] = str(fixed_val)
+
+            parameters.append(parameter)
+            processed_parameters.add(param_name)
+
+    # Parse configuration steps
+    step_pattern = re.compile(r'step(\d+)_(.+)')
+    steps = {}
+
+    for field_name, value in form_data.items():
+        match = step_pattern.match(field_name)
+        if match and value:
+            step_num = int(match.group(1))
+            step_attr = match.group(2)
+            step_key = f"step_{step_num}"
+
+            if step_key not in steps:
+                steps[step_key] = {}
+
+            # Convert num_samples to int if it's a number field
+            if step_attr == "num_samples":
+                steps[step_key][step_attr] = int(value)
+            else:
+                steps[step_key][step_attr] = value
+
+    return parameters, objectives, steps

ivoryos/utils/db_models.py

@@ -265,11 +265,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] = {value: var_type}
+                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):

ivoryos/utils/form.py

@@ -214,11 +214,6 @@ class FlexibleEnumField(StringField):
                     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 +259,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 +272,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 {})
@@ -321,6 +316,7 @@ 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"})
@@ -395,12 +391,12 @@ 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:
             value = next(iter(value))
         field_kwargs = {
-            "label": formatted_param_name,
+            "label": name,
             "default": f'{value}',
             "validators": [InputRequired()],
             **({"script": script})

ivoryos/utils/global_config.py

@@ -15,6 +15,7 @@ class GlobalConfig:
             cls._instance._deck_snapshot = {}
             cls._instance._runner_lock = threading.Lock()
             cls._instance._runner_status = None
+            cls._instance._optimizers = {}
         return cls._instance
 
     @property
@@ -84,4 +85,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/py_to_json.py

@@ -0,0 +1,225 @@
+import ast
+import json
+import uuid
+
+def generate_uuid():
+    return int(str(uuid.uuid4().int)[:15])
+
+def infer_type(value):
+    if isinstance(value, bool):
+        return "bool"
+    elif isinstance(value, int):
+        return "int"
+    elif isinstance(value, float):
+        return "float"
+    elif isinstance(value, str):
+        return "str"
+    elif isinstance(value, (ast.Name, str)) and str(value).startswith("#"):
+        return "float"  # default fallback for variables
+    else:
+        return "unknown"
+
+def convert_to_cards(source_code: str):
+    tree = ast.parse(source_code)
+    cards = []
+    card_id = 1
+    block_stack = []  # to track control flow UUIDs
+
+    def new_id():
+        nonlocal card_id
+        val = card_id
+        card_id += 1
+        return val
+
+    def add_card(card):
+        cards.append(card)
+
+    def is_supported_assignment(node):
+        return (
+            isinstance(node.targets[0], ast.Name) and
+            isinstance(node.value, (ast.Constant, ast.Num, ast.Str, ast.NameConstant))
+        )
+
+    class CardVisitor(ast.NodeVisitor):
+        def visit_FunctionDef(self, node):
+            self.defined_types = {
+                arg.arg: ast.unparse(arg.annotation) if arg.annotation else "float"
+                for arg in node.args.args
+            }
+            for stmt in node.body:
+                self.visit(stmt)
+
+        def visit_If(self, node):
+            uuid_ = generate_uuid()
+            block_stack.append(("if", uuid_))
+
+            add_card({
+                "action": "if",
+                "arg_types": {"statement": ""},
+                "args": {"statement": ast.unparse(node.test)},
+                "id": new_id(),
+                "instrument": "if",
+                "return": "",
+                "uuid": uuid_
+            })
+
+            for stmt in node.body:
+                self.visit(stmt)
+
+            if node.orelse:
+                add_card({
+                    "action": "else",
+                    "args": {},
+                    "id": new_id(),
+                    "instrument": "if",
+                    "return": "",
+                    "uuid": uuid_
+                })
+                for stmt in node.orelse:
+                    self.visit(stmt)
+
+            _, block_uuid = block_stack.pop()
+            add_card({
+                "action": "endif",
+                "args": {},
+                "id": new_id(),
+                "instrument": "if",
+                "return": "",
+                "uuid": block_uuid
+            })
+
+        def visit_While(self, node):
+            uuid_ = generate_uuid()
+            block_stack.append(("while", uuid_))
+
+            add_card({
+                "action": "while",
+                "arg_types": {"statement": ""},
+                "args": {"statement": ast.unparse(node.test)},
+                "id": new_id(),
+                "instrument": "while",
+                "return": "",
+                "uuid": uuid_
+            })
+
+            for stmt in node.body:
+                self.visit(stmt)
+
+            _, block_uuid = block_stack.pop()
+            add_card({
+                "action": "endwhile",
+                "args": {},
+                "id": new_id(),
+                "instrument": "while",
+                "return": "",
+                "uuid": block_uuid
+            })
+
+        def visit_Assign(self, node):
+            if is_supported_assignment(node):
+                var_name = node.targets[0].id
+                value = node.value.value
+                add_card({
+                    "action": var_name,
+                    "arg_types": {"statement": infer_type(value)},
+                    "args": {"statement": value},
+                    "id": new_id(),
+                    "instrument": "variable",
+                    "return": "",
+                    "uuid": generate_uuid()
+                })
+            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):
+                self.handle_call(node.value)
+
+        def handle_call(self, node, ret_var=""):
+            func_parts = []
+            f = node.func
+            while isinstance(f, ast.Attribute):
+                func_parts.insert(0, f.attr)
+                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"):
+                return
+
+            instrument = ".".join(func_parts[:-1])
+            action = func_parts[-1]
+
+            args = {}
+            arg_types = {}
+
+            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)
+                        if isinstance(v_node, ast.Constant):
+                            value = v_node.value
+                        elif isinstance(v_node, ast.Name):
+                            value = f"#{v_node.id}"
+                        else:
+                            value = ast.unparse(v_node)
+                        args[key] = value
+                        arg_types[key] = infer_type(value)
+                else:
+                    if isinstance(kw.value, ast.Constant):
+                        value = kw.value.value
+                    elif isinstance(kw.value, ast.Name):
+                        value = f"#{kw.value.id}"
+                    else:
+                        value = ast.unparse(kw.value)
+                    args[kw.arg] = value
+                    arg_types[kw.arg] = (
+                        self.defined_types.get(kw.value.id, "float")
+                        if isinstance(kw.value, ast.Name)
+                        else infer_type(value)
+                    )
+
+            add_card({
+                "action": action,
+                "arg_types": arg_types,
+                "args": args,
+                "id": new_id(),
+                "instrument": instrument,
+                "return": ret_var,
+                "uuid": generate_uuid()
+            })
+
+    CardVisitor().visit(tree)
+    return cards
+
+
+if __name__ == "__main__":
+    test = '''def workflow_dynamic(solid_amount_mg, methanol_amount_ml):
+    """
+    SDL workflow: dose solid, add methanol, equilibrate, and analyze
+    
+    Args:
+        solid_amount_mg (float): Amount of solid to dose in mg
+        methanol_amount_ml (float): Amount of methanol to dose in ml
+    
+    Returns:
+        dict: Results containing analysis data
+    """
+    # Step 1: Dose solid material
+    deck.sdl.dose_solid(amount_in_mg=solid_amount_mg)
+    
+    # Step 2: Add methanol solvent
+    deck.sdl.dose_solvent(solvent_name='Methanol', amount_in_ml=methanol_amount_ml)
+    
+    # Step 3: Equilibrate at room temperature (assuming ~23°C) for 20 seconds
+    deck.sdl.equilibrate(temp=23.0, duration=20.0)
+    
+    # Step 4: Analyze the sample
+    analysis_results = deck.sdl.analyze(param_1=1, param_2=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)))

ivoryos/utils/script_runner.py

@@ -62,11 +62,11 @@ class ScriptRunner:
 
 
     def run_script(self, script, repeat_count=1, run_name=None, logger=None, socketio=None, config=None, bo_args=None,
-                   output_path="", compiled=False, current_app=None):
+                   output_path="", compiled=False, current_app=None, history=None, optimizer=None):
         global deck
         if deck is None:
             deck = global_config.deck
-
+        print("history", history)
         if self.current_app is None:
             self.current_app = current_app
         # time.sleep(1)  # Optional: may help ensure deck readiness
@@ -81,7 +81,8 @@ class ScriptRunner:
 
         thread = threading.Thread(
             target=self._run_with_stop_check,
-            args=(script, repeat_count, run_name, logger, socketio, config, bo_args, output_path, current_app, compiled)
+            args=(script, repeat_count, run_name, logger, socketio, config, bo_args, output_path, current_app, compiled,
+                  history, optimizer)
         )
         thread.start()
         return thread
@@ -182,7 +183,7 @@ class ScriptRunner:
         return exec_locals  # Return the 'results' variable
 
     def _run_with_stop_check(self, script: Script, repeat_count: int, run_name: str, logger, socketio, config, bo_args,
-                             output_path, current_app, compiled):
+                             output_path, current_app, compiled, history=None, optimizer=None):
         time.sleep(1)
         # _func_str = script.compile()
         # step_list_dict: dict = script.convert_to_lines(_func_str)
@@ -205,7 +206,8 @@ class ScriptRunner:
             # Run "script" section multiple times
             if repeat_count:
                 self._run_repeat_section(repeat_count, arg_type, bo_args, output_list, script,
-                                         run_name, return_list, compiled, logger, socketio, run_id=run_id)
+                                         run_name, return_list, compiled, logger, socketio,
+                                         history, output_path, run_id=run_id, optimizer=optimizer)
             elif config:
                 self._run_config_section(config, arg_type, output_list, script, run_name, logger,
                                          socketio, run_id=run_id, compiled=compiled)
@@ -262,13 +264,36 @@ class ScriptRunner:
                     output_list.append(output)
 
     def _run_repeat_section(self, repeat_count, arg_types, bo_args, output_list, script, run_name, return_list, compiled,
-                            logger, socketio, run_id):
+                            logger, socketio, history, output_path, run_id, optimizer=None):
         if bo_args:
             logger.info('Initializing optimizer...')
             if compiled:
                 ax_client = bo_campaign.ax_init_opc(bo_args)
             else:
-                ax_client = bo_campaign.ax_init_form(bo_args, arg_types)
+                if history:
+                    import pandas as pd
+                    file_path = os.path.join(output_path, history)
+                    previous_runs = pd.read_csv(file_path).to_dict(orient='records')
+                    ax_client = bo_campaign.ax_init_form(bo_args, arg_types, len(previous_runs))
+                    for row in previous_runs:
+                        parameter = {key: value for key, value in row.items() if key in arg_types.keys()}
+                        raw_data = {key: value for key, value in row.items() if key in return_list}
+                        _, trial_index = ax_client.attach_trial(parameter)
+                        ax_client.complete_trial(trial_index=trial_index, raw_data=raw_data)
+                        output_list.append(row)
+                else:
+                    ax_client = bo_campaign.ax_init_form(bo_args, arg_types)
+        elif optimizer and history:
+            import pandas as pd
+            file_path = os.path.join(output_path, history)
+
+            previous_runs = pd.read_csv(file_path)
+            optimizer.append_existing_data(previous_runs)
+            for row in previous_runs:
+                output_list.append(row)
+
+
+
         for i_progress in range(int(repeat_count)):
             if self.stop_pending_event.is_set():
                 logger.info(f'Stopping execution during {run_name}: {i_progress + 1}/{int(repeat_count)}')
@@ -290,6 +315,17 @@ class ScriptRunner:
                 except Exception as e:
                     logger.info(f'Optimization error: {e}')
                     break
+            elif optimizer:
+                try:
+                    parameters = optimizer.suggest(1)
+                    logger.info(f'Output value: {parameters}')
+                    output = self.exec_steps(script, "script", logger, socketio, run_id, i_progress, **parameters)
+                    if output:
+                        optimizer.observe(output)
+                        output.update(parameters)
+                except Exception as e:
+                    logger.info(f'Optimization error: {e}')
+                    break
             else:
                 # fname = f"{run_name}_script"
                 # function = self.globals_dict[fname]
@@ -298,6 +334,12 @@ class ScriptRunner:
             if output:
                 output_list.append(output)
                 logger.info(f'Output value: {output}')
+
+        if bo_args:
+            ax_client.save_to_json_file(os.path.join(output_path, f"{run_name}_ax_client.json"))
+        logger.info(
+            f'Optimization complete. Results saved to {os.path.join(output_path, f"{run_name}_ax_client.json")}'
+        )
         return output_list
 
     @staticmethod