ivoryos 1.2.5__tar.gz → 1.2.6__tar.gz

{ivoryos-1.2.5 → ivoryos-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivoryos
-Version: 1.2.5
+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.5 → ivoryos-1.2.6}/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-1.2.5 → ivoryos-1.2.6}/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-1.2.6/ivoryos/routes/control/control_file.py

@@ -0,0 +1,33 @@
+import os
+from flask import Blueprint,  request,current_app, send_file
+from flask_login import login_required
+
+from ivoryos.utils.client_proxy import ProxyGenerator
+from ivoryos.utils.global_config import GlobalConfig
+
+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 Python interface
+
+    download proxy Python interface
+
+    .. http:get:: /files/proxy
+    """
+    generator = ProxyGenerator(request.url_root)
+    snapshot = global_config.deck_snapshot.copy()
+
+    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-1.2.5 → ivoryos-1.2.6}/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-1.2.6/ivoryos/utils/client_proxy.py

@@ -0,0 +1,288 @@
+import os
+import re
+from typing import Dict, Set, Any, Optional
+
+
+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.
+    """
+
+    # Common typing symbols to scan for in function signatures
+    TYPING_SYMBOLS = {
+        "Optional", "Union", "List", "Dict", "Tuple",
+        "Any", "Callable", "Iterable", "Sequence", "Set"
+    }
+
+    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"
+
+        if docstring:
+            method += f'        """{docstring}"""\n'
+
+        # 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"
+
+        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:
+            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
+
+    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.
+
+        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
+
+        Returns:
+            Path to the generated file
+        """
+        # Set the base URL from the request
+        self.base_url = request_url_root.rstrip('/')
+
+        # Generate the proxy file
+        return self.generate_proxy_file(snapshot, output_folder)
+
+    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-1.2.5 → ivoryos-1.2.6}/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-1.2.5 → ivoryos-1.2.6}/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-1.2.6/ivoryos/version.py

@@ -0,0 +1 @@
+__version__ = "1.2.6"

{ivoryos-1.2.5 → ivoryos-1.2.6}/ivoryos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivoryos
-Version: 1.2.5
+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.5/ivoryos/routes/control/control_file.py

@@ -1,36 +0,0 @@
-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.global_config import GlobalConfig
-
-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
-
-    download proxy Python interface
-
-    .. http:get:: /files/proxy
-    """
-    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)

ivoryos-1.2.5/ivoryos/utils/client_proxy.py

@@ -1,57 +0,0 @@
-# import argparse
-import os
-
-# import requests
-
-# session = requests.Session()
-
-
-# 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'
-
-    for function_name, details in functions.items():
-        signature = details['signature']
-        docstring = details.get('docstring', '')
-
-        # 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}"'
-
-        # 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 []
-
-        for param in params:
-            param_name = param.split(':')[0].strip()  # Split on ':' and get parameter name
-            method += f', "{param_name}": {param_name}'
-
-        method += '}).json()\n'
-        class_template += method + '\n'
-
-    return class_template
-
-# 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')
-
-        # Writing each class definition to the file
-        for class_name, class_def in class_definitions.items():
-            f.write(class_def)
-            f.write('\n')
-
-        # 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')
-
-
-

ivoryos-1.2.5/ivoryos/version.py

@@ -1 +0,0 @@
-__version__ = "1.2.5"