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

ivoryos/optimizer/base_optimizer.py

@@ -5,7 +5,8 @@ from abc import ABC, abstractmethod
 
 
 class OptimizerBase(ABC):
-    def __init__(self, experiment_name:str, parameter_space: list, objective_config: dict, optimizer_config: dict):
+    def __init__(self, experiment_name:str, parameter_space: list, objective_config: dict, optimizer_config: dict,
+                 parameter_constraints:list=None, datapath:str=None):
         """
         :param experiment_name: arbitrary name
         :param parameter_space: list of parameter names
@@ -29,6 +30,7 @@ class OptimizerBase(ABC):
         self.parameter_space = parameter_space
         self.objective_config = objective_config
         self.optimizer_config = optimizer_config
+        self.datapath = datapath
 
     @abstractmethod
     def suggest(self, n=1):
@@ -46,6 +48,23 @@ class OptimizerBase(ABC):
     def append_existing_data(self, existing_data):
         pass
 
+    @abstractmethod
+    def get_plots(self, plot_type):
+        pass
+
+    @staticmethod
+    def _create_discrete_search_space(range_with_step=None, value_type ="float"):
+        if range_with_step is None:
+            range_with_step = []
+        import numpy as np
+        low, high, step = range_with_step
+        values = np.arange(low, high + 1e-9 * step, step).tolist()
+        if value_type == "float":
+            values = [float(v) for v in values]
+        if value_type == "int":
+            values = [int(v) for v in values]
+        return values
+
     @staticmethod
     def get_schema():
         """

ivoryos/optimizer/baybe_optimizer.py

@@ -1,19 +1,21 @@
 ### Directory: ivoryos/optimizers/baybe_optimizer.py
 from typing import Dict
 
+from pandas import DataFrame
 
 from ivoryos.utils.utils import install_and_import
 from ivoryos.optimizer.base_optimizer import OptimizerBase
 
 class BaybeOptimizer(OptimizerBase):
-    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config):
+    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config,
+                 parameter_constraints:list=None, datapath=None):
         try:
             from baybe import Campaign
         except ImportError:
             install_and_import("baybe")
             print("Please install Baybe with pip install baybe to before register BaybeOptimizer.")
 
-        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config)
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config, parameter_constraints, )
         self._trial_id = 0
         self._trials = {}
 
@@ -25,8 +27,8 @@ class BaybeOptimizer(OptimizerBase):
 
 
     def suggest(self, n=1):
-        self.df = self.experiment.recommend(batch_size=n)
-        return self.df.to_dict(orient="records")[0]
+        # self.df = self.experiment.recommend(batch_size=n)
+        return self.experiment.recommend(batch_size=n).to_dict(orient="records")
 
     def observe(self, results, index=None):
         """
@@ -35,21 +37,19 @@ class BaybeOptimizer(OptimizerBase):
         :param index: The index of the trial in the DataFrame, if applicable.
 
         """
-        for name, value in results.items():
-            self.df[name] = [value]
-        self.experiment.add_measurements(self.df)
+        df = DataFrame(results)
+        self.experiment.add_measurements(df)
 
-    def append_existing_data(self, existing_data: Dict):
+    def append_existing_data(self, existing_data: DataFrame):
         """
         Append existing data to the Ax experiment.
         :param existing_data: A dictionary containing existing data.
         """
-        import pandas as pd
-        if not existing_data:
+        if existing_data.empty:
             return
         # parameter_names = [i.get("name") for i in self.parameter_space]
         # objective_names = [i.get("name") for i in self.objective_config]
-        self.experiment.add_measurements(pd.DataFrame(existing_data))
+        self.experiment.add_measurements(existing_data)
         # for name, value in existing_data.items():
         #     # First attach the trial and note the trial index
         #     parameters = {name: value for name in existing_data if name in parameter_names}
@@ -65,9 +65,11 @@ class BaybeOptimizer(OptimizerBase):
         :param parameter_space: The parameter space configuration.
         [
             {"name": "param_1", "type": "range", "bounds": [1.0, 2.0], "value_type": "float"},
-            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
-            {"name": "param_3", "type": "range", "bounds": [0 10], "value_type": "int"},
-            {"name": "param_4", "type": "substance", "bounds": ["methanol", "water", "toluene"], "value_type": "str"} #TODO
+            {"name": "param_2", "type": "range", "bounds": [1.0, 2.0, 0.5], "value_type": "float"},
+
+            {"name": "param_3", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_4", "type": "range", "bounds": [0 10], "value_type": "int"},
+            {"name": "param_5", "type": "substance", "bounds": ["methanol", "water", "toluene"], "value_type": "str"} #TODO
         ]
         :return: A list of Baybe parameters.
         """
@@ -77,7 +79,10 @@ class BaybeOptimizer(OptimizerBase):
         parameters = []
         for p in parameter_space:
             if p["type"] == "range":
-                if p["value_type"] == "float":
+                if len(p["bounds"]) == 3:
+                    values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                    parameters.append(NumericalDiscreteParameter(name=p["name"], values=values))
+                elif p["value_type"] == "float":
                     parameters.append(NumericalContinuousParameter(name=p["name"], bounds=p["bounds"]))
                 elif p["value_type"] == "int":
                     values = tuple([int(v) for v in range(p["bounds"][0], p["bounds"][1] + 1)])
@@ -106,10 +111,10 @@ class BaybeOptimizer(OptimizerBase):
         weights = []
         for obj in objective_config:
             obj_name = obj.get("name")
-            minimize = obj.get("minimize", False)
+            minimize = obj.get("minimize", True)
             weight = obj.get("weight", 1)
             weights.append(weight)
-            targets.append(NumericalTarget(name=obj_name, mode="MAX" if minimize else "MIN"))
+            targets.append(NumericalTarget(name=obj_name, minimize=minimize))
 
         if len(targets) == 1:
             return SingleTargetObjective(target=targets[0])
@@ -148,6 +153,9 @@ class BaybeOptimizer(OptimizerBase):
             recommender=step_2_recommender
         )
 
+    def get_plots(self, plot_type):
+        return None
+
     @staticmethod
     def get_schema():
         """
@@ -156,6 +164,8 @@ class BaybeOptimizer(OptimizerBase):
         return {
             "parameter_types": ["range", "choice", "substance"],
             "multiple_objectives": True,
+            "supports_continuous": True,
+            "supports_constraints": False,
             "optimizer_config": {
                 "step_1": {"model": ["Random", "FPS"], "num_samples": 10},
                 "step_2": {"model": ["BOTorch", "Naive Hybrid Space"]}

ivoryos/optimizer/nimo_optimizer.py

@@ -0,0 +1,173 @@
+### ivoryos/optimizers/nimo_optimizer.py
+import glob
+import itertools
+import os
+
+
+from ivoryos.optimizer.base_optimizer import OptimizerBase
+
+
+class NIMOOptimizer(OptimizerBase):
+    def __init__(self, experiment_name:str, parameter_space: list, objective_config: list, optimizer_config: dict,
+                 parameter_constraints:list=None, datapath:str=None):
+        """
+        :param experiment_name: arbitrary name
+        :param parameter_space: list of parameter names
+        [
+            {"name": "param_1", "type": "range", "bounds": [1.0, 2.0], "value_type": "float"},
+            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_3", "type": "range", "bounds": [0 10], "value_type": "int"},
+        ]
+        :param objective_config: objective configuration
+        [
+            {"name": "obj_1", "minimize": True, "weight": 1},
+            {"name": "obj_2", "minimize": False, "weight": 1}
+        ]
+        :param optimizer_config: optimizer configuration
+        {
+            "step_1": {"model": "RE", "num_samples": 10},
+            "step_2": {"model": "PDC"}
+        }
+        """
+        self.current_step = 0
+        self.experiment_name = experiment_name
+        self.parameter_space = parameter_space
+        self.objective_config = objective_config
+        self.optimizer_config = optimizer_config
+
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config, parameter_constraints, datapath)
+
+        os.makedirs(os.path.join(self.datapath, "nimo_data"), exist_ok=True)
+
+        step_1 = optimizer_config.get("step_1", {})
+        step_2 = optimizer_config.get("step_2", {})
+        self.step_1_generator = step_1.get("model", "RE")
+        self.step_1_batch_num = step_1.get("num_samples", 1)
+        self.step_2_generator = step_2.get("model", "PDC")
+        self.candidates = os.path.join(self.datapath, "nimo_data", f"{self.experiment_name}_candidates.csv")
+        self.proposals = os.path.join(self.datapath, "nimo_data", f"{self.experiment_name}_proposals.csv")
+        self.n_objectives = len(self.objective_config)
+        self._create_candidates_csv()
+
+
+    def _create_candidates_csv(self):
+        # Extract parameter names and their possible values
+        import pandas as pd
+        import nimo
+        import numpy as np
+        if os.path.exists(self.candidates) and nimo.history(self.candidates, self.n_objectives):
+            return
+        param_names = [p["name"] for p in self.parameter_space]
+
+        param_values = []
+        for p in self.parameter_space:
+            if p["type"] == "choice" and isinstance(p["bounds"], list):
+                param_values.append(p["bounds"])
+            elif p["type"] == "range" and len(p["bounds"]) == 3:
+                values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                param_values.append(values)
+            else:
+                raise ValueError(f"Unsupported parameter format: {p}")
+
+        # Generate all possible combinations
+        combos = list(itertools.product(*param_values))
+
+        # Create a DataFrame with parameter columns
+        df = pd.DataFrame(combos, columns=param_names)
+        # Add empty objective columns
+        for obj in self.objective_config:
+            df[obj["name"]] = ""
+
+        # Save to CSV
+        df.to_csv(self.candidates, index=False)
+
+
+    def suggest(self, n=1):
+        import pandas as pd
+        import nimo
+        method = self.step_1_generator if self.current_step <= self.step_1_batch_num else self.step_2_generator
+        nimo.selection(method = method,
+                       input_file = self.candidates,
+                       output_file = self.proposals,
+                       num_objectives = self.n_objectives,
+                       num_proposals = n)
+        self.current_step += 1
+        # Read proposals from CSV file
+        proposals_df = pd.read_csv(self.proposals)
+        # Get parameter names
+        param_names = [p["name"] for p in self.parameter_space]
+        # Convert proposals to list of parameter dictionaries
+        proposals = []
+        for _, row in proposals_df.iterrows():
+            proposal = {name: row[name] for name in param_names}
+            proposals.append(proposal)
+        return proposals
+
+    def _convert_observation_to_list(self, obs: dict) -> list:
+        obj_names = [o["name"] for o in self.objective_config]
+        return [obs.get(name, None) for name in obj_names]
+
+    def observe(self, results: list):
+        """
+        observe single output, nimo obj input is [1,2,3] or [[1, 2], [1, 2], [1, 2]] for MO
+        :param results: [{"objective_name": "value"}, {"objective_name": "value"}]]
+        """
+        import nimo
+        nimo_objective_values = [self._convert_observation_to_list(result) for result in results]
+        nimo.output_update(input_file=self.proposals,
+                           output_file=self.candidates,
+                           num_objectives=self.n_objectives,
+                           objective_values=nimo_objective_values)
+
+    def append_existing_data(self, existing_data):
+        # TODO, history is part of the candidate file, we probably won't need this
+        pass
+
+    def get_plots(self, plot_type):
+        import nimo
+        nimo.visualization.plot_phase_diagram.plot(input_file=self.candidates,
+                                                   fig_folder=os.path.join(self.datapath, "nimo_data"))
+        files = sorted(glob.glob(os.path.join(os.path.join(self.datapath, "nimo_data"), "phase_diagram_*.png")))
+        if not files:
+            return None
+        return files[-1]
+
+    @staticmethod
+    def get_schema():
+        return {
+            "parameter_types": ["choice", "range"],
+            "multiple_objectives": True,
+            "supports_continuous": False,
+            "supports_constraints": False,
+            "optimizer_config": {
+                "step_1": {"model": ["RE", "ES"], "num_samples": 5},
+                "step_2": {"model": ["PHYSBO", "PDC", "BLOX", "PTR", "SLESA", "BOMP", "COMBI"]}
+            },
+        }
+
+
+
+
+if __name__ == "__main__":
+    parameter_space = [
+        {"name": "silica", "type": "choice", "bounds": [100], "value_type": "float"},
+        {"name": "water", "type": "range", "bounds": [500, 900, 50], "value_type": "float"},
+        {"name": "PVA", "type": "choice", "bounds": [0, 0.005, 0.0075, 0.01, 0.05, 0.075, 0.1], "value_type": "float"},
+        {"name": "SDS", "type": "choice", "bounds": [0], "value_type": "float"},
+        {"name": "DTAB", "type": "choice", "bounds": [0, 0.005, 0.0075, 0.01, 0.05, 0.075, 0.1], "value_type": "float"},
+        {"name": "PVP", "type": "choice", "bounds": [0], "value_type": "float"},
+    ]
+    objective_config = [
+        {"name": "objective", "minimize": False, "weight": 1},
+
+    ]
+    optimizer_config = {
+        "step_1": {"model": "RE", "num_samples": 10},
+        "step_2": {"model": "PDC"}
+    }
+
+    nimo_optimizer = NIMOOptimizer(experiment_name="example_experiment", optimizer_config=optimizer_config, parameter_space=parameter_space, objective_config=objective_config)
+    nimo_optimizer.suggest(n=1)
+    nimo_optimizer.observe(
+        results=[{"objective": 1.0}]
+    )

ivoryos/optimizer/registry.py

@@ -2,8 +2,10 @@
 
 from ivoryos.optimizer.ax_optimizer import AxOptimizer
 from ivoryos.optimizer.baybe_optimizer import BaybeOptimizer
+from ivoryos.optimizer.nimo_optimizer import NIMOOptimizer
 
 OPTIMIZER_REGISTRY = {
     "ax": AxOptimizer,
-    "baybe": BaybeOptimizer
+    "baybe": BaybeOptimizer,
+    "nimo": NIMOOptimizer,
 }

ivoryos/routes/auth/auth.py

@@ -1,6 +1,7 @@
 from flask import Blueprint, redirect, url_for, flash, request, render_template, session
-from flask_login import login_required, login_user, logout_user, LoginManager
+from flask_login import login_required, login_user, logout_user, LoginManager, current_user
 import bcrypt
+from sqlalchemy_utils.types import password
 
 from ivoryos.utils.db_models import Script, User, db
 from ivoryos.utils.utils import post_script_file
@@ -15,16 +16,16 @@ def login():
     """
     .. :quickref: User; login user
 
-    .. http:get:: /login
+    .. http:get:: /auth/login
 
     load user login form.
 
-    .. http:post:: /login
+    .. http:post:: /auth/login
 
     :form username: username
     :form password: password
     :status 302: and then redirects to homepage
-    :status 401: incorrect password, redirects to :http:get:`/ivoryos/login`
+    :status 401: incorrect password, redirects to :http:get:`/ivoryos/auth/login`
     """
     if request.method == 'POST':
         username = request.form.get('username')
@@ -57,16 +58,16 @@ def signup():
     """
     .. :quickref: User; signup for a new account
 
-    .. http:get:: /signup
+    .. http:get:: /auth/signup
 
     load user sighup
 
-    .. http:post:: /signup
+    .. http:post:: /auth/signup
 
     :form username: username
     :form password: password
-    :status 302: and then redirects to :http:get:`/ivoryos/login`
-    :status 409: when user already exists, redirects to :http:get:`/ivoryos/signup`
+    :status 302: and then redirects to :http:get:`/ivoryos/auth/login`
+    :status 409: when user already exists, redirects to :http:get:`/ivoryos/auth/signup`
     """
     if request.method == 'POST':
         username = request.form.get('username')
@@ -85,6 +86,30 @@ def signup():
         return redirect(url_for('auth.login'))
     return render_template('signup.html')
 
+@auth.route("/change-password", methods=['GET', 'POST'])
+@login_required
+def change_password():
+    """
+    .. :quickref: User; change password
+
+    .. http:get:: /auth/change-password
+
+    .. http:post:: /auth/change-password
+
+    change password
+    """
+    if request.method == "POST":
+        old_password = request.form.get("old_password")
+        new_password = request.form.get("new_password")
+        # confirm_password = request.form.get("confirm_password")
+        user = User.query.filter_by(username=current_user.get_id()).first()
+        if not bcrypt.checkpw(old_password.encode('utf-8'), user.hashPassword):
+            flash("Incorrect password")
+            return redirect(url_for("auth.change_password"))
+        user.hashPassword = bcrypt.hashpw(new_password.encode('utf-8'), bcrypt.gensalt())
+        db.session.commit()
+        return redirect(url_for("main.index"))
+    return render_template("change_password.html")
 
 @auth.route("/logout")
 @login_required
@@ -92,6 +117,8 @@ def logout():
     """
     .. :quickref: User; logout the user
 
+    .. http:get:: /auth/logout
+
     logout the current user, clear session info, and redirect to the login page.
     """
     logout_user()

ivoryos/routes/auth/templates/change_password.html

@@ -0,0 +1,32 @@
+{% extends 'base.html' %}
+{% block title %}IvoryOS | Change Password{% endblock %}
+
+
+{% block body %}
+<div class= "login">
+    <div class="bg-white rounded shadow-sm flex-fill">
+        <div class="p-4" style="align: center">
+            <h5>Change Password</h5>
+            <form role="form" method='POST' name="signup" action="{{ url_for('auth.change_password') }}">
+
+                <div class="input-group mb-3">
+                    <label class="input-group-text" for="old_password">Old Password</label>
+                    <input class="form-control" type="password" id="old_password" name="old_password" required>
+                </div>
+                <div class="input-group mb-3">
+                    <label class="input-group-text" for="new_password">New Password</label>
+                    <input class="form-control" type="password" id="new_password" name="new_password" required>
+                </div>
+{#                <div class="input-group mb-3">#}
+{#                    <label class="input-group-text" for="confirm_password">Confirm Password</label>#}
+{#                    <input class="form-control" type="confirm_password" id="confirm_password" name="confirm_password">#}
+{#                </div>#}
+
+                <button type="submit" class="btn btn-secondary" name="login" style="width: 100%;">Confirm</button>
+            </form>
+            <p class="message" >Need another account? <a href="{{ url_for('auth.signup') }}">Sign up</a></p>
+        </div>
+    </div>
+</div>
+
+{% endblock %}

ivoryos/routes/control/control.py

@@ -1,3 +1,5 @@
+import copy
+
 from flask import Blueprint, redirect, flash, request, render_template, session, current_app, jsonify
 from flask_login import login_required
 
@@ -5,7 +7,7 @@ from ivoryos.routes.control.control_file import control_file
 from ivoryos.routes.control.control_new_device import control_temp
 from ivoryos.routes.control.utils import post_session_by_instrument, get_session_by_instrument, find_instrument_by_name
 from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils.form import create_form_from_module
+from ivoryos.utils.form import create_form_from_module, create_form_from_pseudo
 from ivoryos.utils.task_runner import TaskRunner
 
 global_config = GlobalConfig()
@@ -21,7 +23,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():
+async def deck_controllers(instrument: str = None):
     """
     .. :quickref: Direct Control; device (instruments) and methods
 
@@ -44,43 +46,71 @@ 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)
+        if instrument.startswith("blocks"):
+            forms = create_form_from_pseudo(pseudo=inst_object, autofill=False, design=False)
+        else:
+            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())
+        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 = {name: forms[name] for name in order if name in forms}
+
+    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 = await 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.best_match(['application/json', 'text/html']) == 'application/json':
+        # 1.3.2 fix snapshot copy, add building blocks to snapshots
+        snapshot = copy.deepcopy(global_config.deck_snapshot)
+        building_blocks = copy.deepcopy(global_config.building_blocks)
+        snapshot.update(building_blocks)
+        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)
+
     return render_template(
-        'controllers.html',
-        defined_variables=deck_variables,
-        temp_variables=temp_variables,
+        "controllers.html",
+        defined_variables=global_config.deck_snapshot.keys(),
+        block_variables=global_config.building_blocks.keys(),
+        temp_variables=global_config.defined_variables.keys(),
         instrument=instrument,
         forms=forms,
         session=session

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)