ivoryos 1.2.4__py3-none-any.whl → 1.2.6__py3-none-any.whl

ivoryos/routes/api/api.py

@@ -37,7 +37,7 @@ def backend_control(instrument: str=None):
         forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
 
     if request.method == 'POST':
-        method_name = request.form.get("hidden_name", None)
+        method_name = request.json.get("hidden_name", None)
         form = forms.get(method_name, None)
         if form:
             kwargs = {field.name: field.data for field in form if field.name not in ['csrf_token', 'hidden_name']}

ivoryos/routes/control/control.py

@@ -21,7 +21,7 @@ control.register_blueprint(control_temp)
 @control.route("/", strict_slashes=False, methods=["GET", "POST"])
 @control.route("/<string:instrument>", strict_slashes=False, methods=["GET", "POST"])
 @login_required
-def deck_controllers():
+def deck_controllers(instrument: str = None):
     """
     .. :quickref: Direct Control; device (instruments) and methods
 
@@ -44,41 +44,56 @@ def deck_controllers():
     :status 200: render template with instruments and methods
 
     """
-    deck_variables = global_config.deck_snapshot.keys()
-    temp_variables = global_config.defined_variables.keys()
-    instrument = request.args.get('instrument')
+    instrument = instrument or request.args.get("instrument")
     forms = None
     if instrument:
         inst_object = find_instrument_by_name(instrument)
-        _forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
-        order = get_session_by_instrument('card_order', instrument)
-        hidden_functions = get_session_by_instrument('hidden_functions', instrument)
-        functions = list(_forms.keys())
-        for function in functions:
-            if function not in hidden_functions and function not in order:
-                order.append(function)
-        post_session_by_instrument('card_order', instrument, order)
-        forms = {name: _forms[name] for name in order if name in _forms}
-        # Handle POST for method execution
-        if request.method == 'POST':
-            all_kwargs = request.form.copy()
-            method_name = all_kwargs.pop("hidden_name", None)
-            form = forms.get(method_name)
-            kwargs = {field.name: field.data for field in form if field.name != 'csrf_token'} if form else {}
-            if form and form.validate_on_submit():
-                kwargs.pop("hidden_name", None)
-                output = runner.run_single_step(instrument, method_name, kwargs, wait=True, current_app=current_app._get_current_object())
-                if output["success"]:
-                    flash(f"\nRun Success! Output value: {output.get('output', 'None')}.")
-                else:
-                    flash(f"\nRun Error! {output.get('output', 'Unknown error occurred.')}", "error")
+        forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
+
+    if request.method == "POST":
+        if not forms:
+            return jsonify({"success": False, "error": "Instrument not found"}), 404
+
+        payload = request.get_json() if request.is_json else request.form.to_dict()
+        method_name = payload.pop("hidden_name", None)
+        form = forms.get(method_name)
+
+        if not form:
+            return jsonify({"success": False, "error": f"Method {method_name} not found"}), 404
+
+        # Extract kwargs
+        if request.is_json:
+            kwargs = {k: v for k, v in payload.items() if k not in ["csrf_token", "hidden_wait"]}
+        else:
+            kwargs = {field.name: field.data for field in form if field.name not in ["csrf_token", "hidden_name"]}
+
+        wait = str(payload.get("hidden_wait", "true")).lower() == "true"
+
+        output = runner.run_single_step(
+            component=instrument, method=method_name, kwargs=kwargs, wait=wait,
+            current_app=current_app._get_current_object()
+        )
+
+        if request.is_json:
+            return jsonify(output)
+        else:
+            if output.get("success"):
+                flash(f"Run Success! Output: {output.get('output', 'None')}")
             else:
-                if form:
-                    flash(form.errors)
-                else:
-                    flash("Invalid method selected.")
+                flash(f"Run Error! {output.get('output', 'Unknown error occurred.')}", "error")
+
+    # GET request → render web form or return snapshot for API
+    if request.is_json or request.accept_mimetypes["application/json"]:
+        snapshot = global_config.deck_snapshot.copy()
+        for instrument_key, instrument_data in snapshot.items():
+            for function_key, function_data in instrument_data.items():
+                function_data["signature"] = str(function_data["signature"])
+        return jsonify(snapshot)
+
+    deck_variables = global_config.deck_snapshot.keys()
+    temp_variables = global_config.defined_variables.keys()
     return render_template(
-        'controllers.html',
+        "controllers.html",
         defined_variables=deck_variables,
         temp_variables=temp_variables,
         instrument=instrument,

ivoryos/routes/control/control_file.py

@@ -2,7 +2,7 @@ import os
 from flask import Blueprint,  request,current_app, send_file
 from flask_login import login_required
 
-from ivoryos.utils.client_proxy import export_to_python, create_function
+from ivoryos.utils.client_proxy import ProxyGenerator
 from ivoryos.utils.global_config import GlobalConfig
 
 global_config = GlobalConfig()
@@ -10,27 +10,24 @@ global_config = GlobalConfig()
 control_file = Blueprint('file', __name__)
 
 
+
 @control_file.route("/files/proxy", strict_slashes=False)
 @login_required
 def download_proxy():
     """
-    .. :quickref: Direct Control Files; download proxy interface
+    .. :quickref: Direct Control Files; Download proxy Python interface
 
     download proxy Python interface
 
     .. http:get:: /files/proxy
     """
+    generator = ProxyGenerator(request.url_root)
     snapshot = global_config.deck_snapshot.copy()
-    class_definitions = {}
-    # Iterate through each instrument in the snapshot
-    for instrument_key, instrument_data in snapshot.items():
-        # Iterate through each function associated with the current instrument
-        for function_key, function_data in instrument_data.items():
-            # Convert the function signature to a string representation
-            function_data['signature'] = str(function_data['signature'])
-        class_name = instrument_key.split('.')[-1]  # Extracting the class name from the path
-        class_definitions[class_name.capitalize()] = create_function(request.url_root, class_name, instrument_data)
-    # Export the generated class definitions to a .py script
-    export_to_python(class_definitions, current_app.config["OUTPUT_FOLDER"])
-    filepath = os.path.join(current_app.config["OUTPUT_FOLDER"], "generated_proxy.py")
-    return send_file(os.path.abspath(filepath), as_attachment=True)
+
+    filepath = generator.generate_from_flask_route(
+        snapshot,
+        request.url_root,
+        current_app.config["OUTPUT_FOLDER"]
+    )
+
+    return send_file(os.path.abspath(filepath), as_attachment=True)

ivoryos/static/js/action_handlers.js

@@ -15,7 +15,7 @@ function saveWorkflow(link) {
     .then(data => {
         if (data.success) {
             // flash a success message
-            flash("Workflow saved successfully", "success");
+            // flash("Workflow saved successfully", "success");
             window.location.reload();  // or update the UI dynamically
         } else {
             alert("Failed to save workflow: " + data.error);

ivoryos/utils/client_proxy.py

@@ -1,57 +1,288 @@
-# import argparse
 import os
+import re
+from typing import Dict, Set, Any, Optional
 
-# import requests
 
-# session = requests.Session()
+class ProxyGenerator:
+    """
+    A class to generate Python proxy interfaces for API clients.
 
+    This generator creates client classes that wrap API endpoints,
+    automatically handling request/response cycles and error handling.
+    """
 
-# Function to create class and methods dynamically
-def create_function(url, class_name, functions):
-    class_template = f'class {class_name.capitalize()}:\n    url = "{url}ivoryos/api/control/deck.{class_name}"\n'
+    # Common typing symbols to scan for in function signatures
+    TYPING_SYMBOLS = {
+        "Optional", "Union", "List", "Dict", "Tuple",
+        "Any", "Callable", "Iterable", "Sequence", "Set"
+    }
 
-    for function_name, details in functions.items():
-        signature = details['signature']
-        docstring = details.get('docstring', '')
+    def __init__(self, base_url: str, api_path_template: str = "ivoryos/instruments/deck.{class_name}"):
+        """
+        Initialize the ProxyGenerator.
+
+        Args:
+            base_url: The base URL for the API
+            api_path_template: Template for API paths, with {class_name} placeholder
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_path_template = api_path_template
+        self.used_typing_symbols: Set[str] = set()
+
+    def extract_typing_from_signatures(self, functions: Dict[str, Dict[str, Any]]) -> Set[str]:
+        """
+        Scan function signatures for typing symbols and track usage.
+
+        Args:
+            functions: Dictionary of function definitions with signatures
+
+        Returns:
+            Set of typing symbols found in the signatures
+        """
+        for function_data in functions.values():
+            signature = function_data.get("signature", "")
+            for symbol in self.TYPING_SYMBOLS:
+                if re.search(rf"\b{symbol}\b", signature):
+                    self.used_typing_symbols.add(symbol)
+        return self.used_typing_symbols
+
+    def create_class_definition(self, class_name: str, functions: Dict[str, Dict[str, Any]]) -> str:
+        """
+        Generate a class definition string for one API client class.
+
+        Args:
+            class_name: Name of the class to generate
+            functions: Dictionary of function definitions
+
+        Returns:
+            String containing the complete class definition
+        """
+        capitalized_name = class_name.capitalize()
+        api_url = f"{self.base_url}/{self.api_path_template.format(class_name=class_name)}"
+
+        class_template = f"class {capitalized_name}:\n"
+        class_template += f'    """Auto-generated API client for {class_name} operations."""\n'
+        class_template += f'    url = "{api_url}"\n\n'
+
+        # Add the __init__ with auth
+        class_template += self._generate_init()
+
+        # Add the _auth
+        class_template += self._generate_auth()
+
+        # Add the base _call method
+        class_template += self._generate_call_method()
+
+        # Add individual methods for each function
+        for function_name, details in functions.items():
+            method_def = self._generate_method(function_name, details)
+            class_template += method_def + "\n"
+
+        return class_template
+
+    def _generate_call_method(self) -> str:
+        """Generate the base _call method for API communication."""
+        return '''    def _call(self, payload):
+        """Make API call with error handling."""
+        res = session.post(self.url, json=payload, allow_redirects=False)
+            # Handle 302 redirect (likely auth issue)
+        if res.status_code == 302:
+            try:
+                self._auth()
+                res = session.post(self.url, json=payload, allow_redirects=False)
+            except Exception as e:
+                raise AuthenticationError(
+                    "Authentication failed during re-attempt. "
+                    "Please check your credentials or connection."
+                ) from e
+        res.raise_for_status()
+        data = res.json()
+        if not data.get('success'):
+            raise Exception(data.get('output', "Unknown API error."))
+        return data.get('output')
+
+'''
+
+    def _generate_method(self, function_name: str, details: Dict[str, Any]) -> str:
+        """
+        Generate a single method definition.
+
+        Args:
+            function_name: Name of the method
+            details: Function details including signature and docstring
+
+        Returns:
+            String containing the method definition
+        """
+        signature = details.get("signature", "(self)")
+        docstring = details.get("docstring", "")
+
+        # Build method header
+        method = f"    def {function_name}{signature}:\n"
 
-        # Creating the function definition
-        method = f'    def {function_name}{signature}:\n'
         if docstring:
             method += f'        """{docstring}"""\n'
 
-        # Generating the session.post code for sending data
-        method += '        return session.post(self.url, data={'
-        method += f'"hidden_name": "{function_name}"'
+        # Build payload
+        method += f'        payload = {{"hidden_name": "{function_name}"}}\n'
+
+        # Extract parameters from signature (excluding 'self')
+        params = self._extract_parameters(signature)
+
+        for param_name in params:
+            method += f'        payload["{param_name}"] = {param_name}\n'
+
+        method += "        return self._call(payload)\n"
 
-        # Extracting the parameters from the signature string for the data payload
-        param_str = signature[6:-1]  # Remove the "(self" and final ")"
-        params = [param.strip() for param in param_str.split(',')] if param_str else []
+        return method
+
+    def _extract_parameters(self, signature: str) -> list:
+        """
+        Extract parameter names from a function signature.
+
+        Args:
+            signature: Function signature string like "(self, param1, param2: int = 5)"
+
+        Returns:
+            List of parameter names (excluding 'self')
+        """
+        # Remove parentheses and split by comma
+        param_str = signature.strip("()").strip()
+        if not param_str or param_str == "self":
+            return []
+
+        params = [param.strip() for param in param_str.split(",")]
+        result = []
 
         for param in params:
-            param_name = param.split(':')[0].strip()  # Split on ':' and get parameter name
-            method += f', "{param_name}": {param_name}'
+            if param and param != "self":
+                # Extract parameter name (before : or = if present)
+                param_name = param.split(":")[0].split("=")[0].strip()
+                if param_name:
+                    result.append(param_name)
+
+        return result
+
+    def generate_proxy_file(self,
+                            snapshot: Dict[str, Dict[str, Any]],
+                            output_path: str,
+                            filename: str = "generated_proxy.py") -> str:
+        """
+        Generate the complete proxy file from a snapshot of instruments.
+
+        Args:
+            snapshot: Dictionary containing instrument data with functions
+            output_path: Directory to write the output file
+            filename: Name of the output file
+
+        Returns:
+            Path to the generated file
+        """
+        class_definitions = {}
+        self.used_typing_symbols.clear()
+
+        # Process each instrument in the snapshot
+        for instrument_key, instrument_data in snapshot.items():
+            # Convert function signatures to strings if needed
+            for function_key, function_data in instrument_data.items():
+                if 'signature' in function_data:
+                    function_data['signature'] = str(function_data['signature'])
+
+            # Extract class name from instrument path
+            class_name = instrument_key.split('.')[-1]
+
+            # Generate class definition
+            class_definitions[class_name] = self.create_class_definition(
+                class_name, instrument_data
+            )
+
+            # Track typing symbols used
+            self.extract_typing_from_signatures(instrument_data)
+
+        # Write the complete file
+        filepath = self._write_proxy_file(class_definitions, output_path, filename)
+        return filepath
+
+    def _write_proxy_file(self,
+                          class_definitions: Dict[str, str],
+                          output_path: str,
+                          filename: str) -> str:
+        """
+        Write the generated classes to a Python file.
+
+        Args:
+            class_definitions: Dictionary of class names to class definition strings
+            output_path: Directory to write the file
+            filename: Name of the file
+
+        Returns:
+            Full path to the written file
+        """
+        filepath = os.path.join(output_path, filename)
+
+        with open(filepath, "w") as f:
+            # Write imports
+            f.write("import requests\n")
+            if self.used_typing_symbols:
+                f.write(f"from typing import {', '.join(sorted(self.used_typing_symbols))}\n")
+            f.write("\n")
+
+            # Write session setup
+            f.write("session = requests.Session()\n\n")
+
+            # Write class definitions
+            for class_name, class_def in class_definitions.items():
+                f.write(class_def)
+                f.write("\n")
+
+            # Create default instances
+            f.write("# Default instances for convenience\n")
+            for class_name in class_definitions.keys():
+                instance_name = class_name.lower()
+                f.write(f"{instance_name} = {class_name.capitalize()}()\n")
+
+        return filepath
 
-        method += '}).json()\n'
-        class_template += method + '\n'
+    def generate_from_flask_route(self,
+                                  snapshot: Dict[str, Dict[str, Any]],
+                                  request_url_root: str,
+                                  output_folder: str) -> str:
+        """
+        Convenience method that matches the original Flask route behavior.
 
-    return class_template
+        Args:
+            snapshot: The deck snapshot from global_config
+            request_url_root: The URL root from Flask request
+            output_folder: Output folder path from app config
 
-# Function to export the generated classes to a Python script
-def export_to_python(class_definitions, path):
-    with open(os.path.join(path, "generated_proxy.py"), 'w') as f:
-        # Writing the imports at the top of the script
-        f.write('import requests\n\n')
-        f.write('session = requests.Session()\n\n')
+        Returns:
+            Path to the generated file
+        """
+        # Set the base URL from the request
+        self.base_url = request_url_root.rstrip('/')
 
-        # Writing each class definition to the file
-        for class_name, class_def in class_definitions.items():
-            f.write(class_def)
-            f.write('\n')
+        # Generate the proxy file
+        return self.generate_proxy_file(snapshot, output_folder)
 
-        # Creating instances of the dynamically generated classes
-        for class_name in class_definitions.keys():
-            instance_name = class_name.lower()  # Using lowercase for instance names
-            f.write(f'{instance_name} = {class_name.capitalize()}()\n')
+    def _generate_init(self):
+        return '''    def __init__(self, username=None, password=None):
+        """Initialize the client with authentication."""
+        self.username = username
+        self.password = password
+        self._auth()
 
+'''
 
 
+    def _generate_auth(self):
+        return f"""    def _auth(self):
+        username = self.username or 'admin'
+        password = self.password or 'admin'
+        res = session.post(
+            '{self.base_url}/ivoryos/auth/login',
+            data={{"username": username, "password": password}}
+        )
+        if res.status_code != 200:
+            raise Exception("Authentication failed")
+                    
+"""

ivoryos/utils/db_models.py

@@ -474,7 +474,7 @@ class Script(db.Model):
         """
         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 ""

ivoryos/utils/form.py

@@ -299,6 +299,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}
 

ivoryos/utils/task_runner.py

@@ -64,7 +64,7 @@ class TaskRunner:
 
         # with self.lock:
         with current_app.app_context():
-            step = SingleStep(method_name=method_name, kwargs=kwargs, run_error=False, start_time=datetime.now())
+            step = SingleStep(method_name=method_name, kwargs=kwargs, run_error=None, start_time=datetime.now())
             db.session.add(step)
             db.session.commit()
             global_config.runner_status = {"id":step.id, "type": "task"}
@@ -74,10 +74,10 @@ class TaskRunner:
                 step.end_time = datetime.now()
                 success = True
             except Exception as e:
-                step.run_error = e.__str__()
+                step.run_error = str(e)
                 step.end_time = datetime.now()
                 success = False
-                output = e.__str__()
+                output = str(e)
             finally:
                 db.session.commit()
                 self.lock.release()

ivoryos/version.py

@@ -1 +1 @@
-__version__ = "1.2.4"
+__version__ = "1.2.6"

{ivoryos-1.2.4.dist-info → ivoryos-1.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivoryos
-Version: 1.2.4
+Version: 1.2.6
 Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
 Author-email: Ivory Zhang <ivoryzhang@chem.ubc.ca>
 License: MIT

{ivoryos-1.2.4.dist-info → ivoryos-1.2.6.dist-info}/RECORD

@@ -1,20 +1,20 @@
 ivoryos/__init__.py,sha256=BAA7OPl3h_QdSc4na-7OWTKhaOq1LtHOrJHX3gGITrc,9863
 ivoryos/config.py,sha256=y3RxNjiIola9tK7jg-mHM8EzLMwiLwOzoisXkDvj0gA,2174
 ivoryos/socket_handlers.py,sha256=VWVWiIdm4jYAutwGu6R0t1nK5MuMyOCL0xAnFn06jWQ,1302
-ivoryos/version.py,sha256=XBKH8E1LmDxv06U39yqMBbXZapOERFgICEDYZs_kRso,22
+ivoryos/version.py,sha256=vMQK58X8_YZGKzRm0ThvPAKFtpfyejGmUnDrY9RQ13w,22
 ivoryos/optimizer/ax_optimizer.py,sha256=PoSu8hrDFFpqyhRBnaSMswIUsDfEX6sPWt8NEZ_sobs,7112
 ivoryos/optimizer/base_optimizer.py,sha256=JTbUharZKn0t8_BDbAFuwZIbT1VOnX1Xuog1pJuU8hY,1992
 ivoryos/optimizer/baybe_optimizer.py,sha256=EdrrRiYO-IOx610cPXiQhH4qG8knUP0uiZ0YoyaGIU8,7954
 ivoryos/optimizer/registry.py,sha256=lr0cqdI2iEjw227ZPRpVkvsdYdddjeJJRzawDv77cEc,219
 ivoryos/routes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivoryos/routes/api/api.py,sha256=X_aZMB_nCxW41pqZpJOiEEwGmlqLqJUArruevuy41v0,2284
+ivoryos/routes/api/api.py,sha256=1Hq4FOBtSEXqjataoPUdAWHvezw07xqhEI1fJdoSn5U,2284
 ivoryos/routes/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/auth/auth.py,sha256=CqoP9cM8BuXVGHGujX7-0sNAOdWILU9amyBrObOD6Ss,3283
 ivoryos/routes/auth/templates/login.html,sha256=WSRrKbdM_oobqSXFRTo-j9UlOgp6sYzS9tm7TqqPULI,1207
 ivoryos/routes/auth/templates/signup.html,sha256=b5LTXtpfTSkSS7X8u1ldwQbbgEFTk6UNMAediA5BwBY,1465
 ivoryos/routes/control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivoryos/routes/control/control.py,sha256=Vmy3GRZz8EbKmV9qslR8gsaYaYzb5HQTpukp42HfMow,5236
-ivoryos/routes/control/control_file.py,sha256=NIAzwhswvpl3u0mansy1ku-rPDybS5hVbmbnymOikWk,1548
+ivoryos/routes/control/control.py,sha256=d08xFo-7Fm7hdFPBxmcf_48UsxO4ctcApm0Wxo_oPQk,5530
+ivoryos/routes/control/control_file.py,sha256=3fQ9R8EcdqKs_hABn2EqRAB1xC2DHAT_q_pwsMIDDQI,864
 ivoryos/routes/control/control_new_device.py,sha256=mfJKg5JAOagIpUKbp2b5nRwvd2V3bzT3M0zIhIsEaFM,5456
 ivoryos/routes/control/utils.py,sha256=at11wA5HPAZN4BfMaymj1GKEvRTrqi4Wg6cTqUZJDjU,1155
 ivoryos/routes/control/templates/controllers.html,sha256=tgtTuns8S2Pf6XKeojinQZ1bz112ieRGLPF5-1cElfE,8030
@@ -72,7 +72,7 @@ ivoryos/static/logo.webp,sha256=lXgfQR-4mHTH83k7VV9iB54-oC2ipe6uZvbwdOnLETc,1497
 ivoryos/static/style.css,sha256=zQVx35A5g6JMJ-K84-6fSKtzXGjp_p5ZVG6KLHPM2IE,4021
 ivoryos/static/gui_annotation/Slide1.png,sha256=Lm4gdOkUF5HIUFaB94tl6koQVkzpitKj43GXV_XYMMc,121727
 ivoryos/static/gui_annotation/Slide2.PNG,sha256=z3wQ9oVgg4JTWVLQGKK_KhtepRHUYP1e05XUWGT2A0I,118761
-ivoryos/static/js/action_handlers.js,sha256=VEDox3gQvg0YXJ6WW6IthOsFqZKmvUGJ8pmQdfzHQFw,5122
+ivoryos/static/js/action_handlers.js,sha256=UJHKFhYRNQRBo0AHLCIxhWxt8OSgYeyLynzPIPNhbeY,5125
 ivoryos/static/js/db_delete.js,sha256=l67fqUaN_FVDaL7v91Hd7LyRbxnqXx9nyjF34-7aewY,561
 ivoryos/static/js/overlay.js,sha256=dPxop19es0E0ZUSY3d_4exIk7CJuQEnlW5uTt5fZfzI,483
 ivoryos/static/js/script_metadata.js,sha256=m8VYZ8OGT2oTx1kXMXq60bKQI9WCbJNkzcFDzLvRuGc,1188
@@ -83,18 +83,18 @@ ivoryos/static/js/ui_state.js,sha256=XYsOcfGlduqLlqHySvPrRrR50CiAsml51duqneigsRY
 ivoryos/templates/base.html,sha256=cl5w6E8yskbUzdiJFal6fZjnPuFNKEzc7BrrbRd6bMI,8581
 ivoryos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/utils/bo_campaign.py,sha256=Fil-zT7JexL_p9XqyWByjAk42XB1R9XUKN8CdV5bi6c,9714
-ivoryos/utils/client_proxy.py,sha256=0OT2xTMkqh_2ybgCxMV_71ZVUThWwrsnAhTIBY5vDR8,2095
-ivoryos/utils/db_models.py,sha256=baE4LJcSGUj10Tj6imfINXi4JQX_4oLv_kb9bd0rp-M,27920
-ivoryos/utils/form.py,sha256=8GSEhfY3cE-q9QxGSW_u-9dFNO72N6QOSGwfYyPTfM0,21912
+ivoryos/utils/client_proxy.py,sha256=74G3HAuq50iEHkSvlMZFmQaukm613FbRgOdzO_T3dMg,10191
+ivoryos/utils/db_models.py,sha256=EN0gNzYgCxKLxgceKEixWi17EKMObz0hLdDnpZ-ur5o,27923
+ivoryos/utils/form.py,sha256=A6juCWGtSbaTClgVc8rqufniPRWT7LjeDQs4r0gQs50,22207
 ivoryos/utils/global_config.py,sha256=zNO9GYhGn7El3msWoxJIm3S4Mzb3VMh2i5ZEsVtvb2Q,2463
 ivoryos/utils/llm_agent.py,sha256=-lVCkjPlpLues9sNTmaT7bT4sdhWvV2DiojNwzB2Lcw,6422
 ivoryos/utils/py_to_json.py,sha256=fyqjaxDHPh-sahgT6IHSn34ktwf6y51_x1qvhbNlH-U,7314
 ivoryos/utils/script_runner.py,sha256=MdLMSAeaVXxnbcQfzHJximeJ6W7uOCxqTQhFSpsEieg,17065
 ivoryos/utils/serilize.py,sha256=lkBhkz8r2bLmz2_xOb0c4ptSSOqjIu6krj5YYK4Nvj8,6784
-ivoryos/utils/task_runner.py,sha256=cDIcmDaqYh0vXoYaL_kO877pluAo2tyfsHl9OgZqJJE,3029
+ivoryos/utils/task_runner.py,sha256=qgHheE2rnhgRmWUeUQHgdS-Kl-yv-9uA-eM6lD9d0b4,3018
 ivoryos/utils/utils.py,sha256=-WiU0_brszB9yDsiQepf_7SzNgPTSpul2RSKDOY3pqo,13921
-ivoryos-1.2.4.dist-info/licenses/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
-ivoryos-1.2.4.dist-info/METADATA,sha256=V4lFZwkePsSRrYNShj0i2KM6u8_Z5F2omuHbYeAW5FU,7351
-ivoryos-1.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ivoryos-1.2.4.dist-info/top_level.txt,sha256=FRIWWdiEvRKqw-XfF_UK3XV0CrnNb6EmVbEgjaVazRM,8
-ivoryos-1.2.4.dist-info/RECORD,,
+ivoryos-1.2.6.dist-info/licenses/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
+ivoryos-1.2.6.dist-info/METADATA,sha256=Jf99DEqSEM-hGlQyIxilU021FEsX8W3Ztj_s6IHN1q0,7351
+ivoryos-1.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ivoryos-1.2.6.dist-info/top_level.txt,sha256=FRIWWdiEvRKqw-XfF_UK3XV0CrnNb6EmVbEgjaVazRM,8
+ivoryos-1.2.6.dist-info/RECORD,,