ivoryos 1.2.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

ivoryos/optimizer/ax_optimizer.py

@@ -0,0 +1,164 @@
+# optimizers/ax_optimizer.py
+from typing import Dict
+
+
+
+from ivoryos.optimizer.base_optimizer import OptimizerBase
+from ivoryos.utils.utils import install_and_import
+
+class AxOptimizer(OptimizerBase):
+    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config=None):
+        try:
+            from ax.api.client import Client
+        except ImportError as e:
+            install_and_import("ax", "ax-platform")
+            raise ImportError("Please install Ax with pip install ax-platform to use AxOptimizer. Attempting to install Ax...")
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config)
+
+        self.client = Client()
+        # 2. Configure where Ax will search.
+        self.client.configure_experiment(
+            name=experiment_name,
+            parameters=self._convert_parameter_to_ax_format(parameter_space)
+        )
+        # 3. Configure the objective function.
+        self.client.configure_optimization(objective=self._convert_objective_to_ax_format(objective_config))
+        if optimizer_config:
+            self.client.set_generation_strategy(self._convert_generator_to_ax_format(optimizer_config))
+        self.generators = self._create_generator_mapping()
+
+    @staticmethod
+    def _create_generator_mapping():
+        """Create a mapping from string values to Generator enum members."""
+        from ax.modelbridge import Generators
+        return {member.value: member for member in Generators}
+
+    def _convert_parameter_to_ax_format(self, parameter_space):
+        """
+        Converts the parameter space configuration to Baybe format.
+        :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"},
+        ]
+        :return: A list of Baybe parameters.
+        """
+        from ax import RangeParameterConfig, ChoiceParameterConfig
+        ax_params = []
+        for p in parameter_space:
+            if p["type"] == "range":
+                ax_params.append(
+                    RangeParameterConfig(
+                        name=p["name"],
+                        bounds=tuple(p["bounds"]),
+                        parameter_type=p["value_type"]
+                    ))
+            elif p["type"] == "choice":
+                ax_params.append(
+                    ChoiceParameterConfig(
+                        name=p["name"],
+                        values=p["bounds"],
+                        parameter_type=p["value_type"],
+                    )
+                )
+        return ax_params
+
+    def _convert_objective_to_ax_format(self, objective_config: list):
+        """
+        Converts the objective configuration to Baybe format.
+        :param parameter_space: The parameter space configuration.
+        [
+            {"name": "obj_1", "minimize": True, "weight": 1},
+            {"name": "obj_2", "minimize": False, "weight": 2}
+        ]
+        :return: Ax objective configuration. "-cost, utility"
+        """
+        objectives = []
+        for obj in objective_config:
+            obj_name = obj.get("name")
+            minimize = obj.get("minimize", True)
+            weight = obj.get("weight", 1)
+            sign = "-" if minimize else ""
+            objectives.append(f"{sign}{weight} * {obj_name}")
+        return ", ".join(objectives)
+
+    def _convert_generator_to_ax_format(self, optimizer_config):
+        """
+        Converts the optimizer configuration to Ax format.
+        :param optimizer_config: The optimizer configuration.
+        :return: Ax generator configuration.
+        """
+        from ax.generation_strategy.generation_node import GenerationStep
+        from ax.generation_strategy.generation_strategy import GenerationStrategy
+        generators = self._create_generator_mapping()
+        step_1 = optimizer_config.get("step_1", {})
+        step_2 = optimizer_config.get("step_2", {})
+        step_1_generator = step_1.get("model", "Sobol")
+        step_2_generator = step_2.get("model", "BOTorch")
+        generator_1 = GenerationStep(model=generators.get(step_1_generator), num_trials=step_1.get("num_samples", 5))
+        generator_2 = GenerationStep(model=generators.get(step_2_generator), num_trials=step_2.get("num_samples", -1))
+        return GenerationStrategy(steps=[generator_1, generator_2])
+
+    def suggest(self, n=1):
+        trial_index, params = self.client.get_next_trials(1).popitem()
+        self.trial_index = trial_index
+        return params
+
+    def observe(self, results):
+        self.client.complete_trial(
+            trial_index=self.trial_index,
+            raw_data=results
+        )
+
+    @staticmethod
+    def get_schema():
+        return {
+            "parameter_types": ["range", "choice"],
+            "multiple_objectives": True,
+            # "objective_weights": True,
+            "optimizer_config": {
+                "step_1": {"model": ["Sobol", "Uniform", "Factorial", "Thompson"], "num_samples": 5},
+                "step_2": {"model": ["BoTorch", "SAASBO", "SAAS_MTGP", "Legacy_GPEI", "EB", "EB_Ashr", "ST_MTGP", "BO_MIXED", "Contextual_SACBO"]}
+            },
+        }
+
+    def append_existing_data(self, existing_data):
+        """
+        Append existing data to the Ax experiment.
+        :param existing_data: A dictionary containing existing data.
+        """
+        from pandas import DataFrame
+        if not existing_data:
+            return
+        if isinstance(existing_data, DataFrame):
+            existing_data = existing_data.to_dict(orient="records")
+        parameter_names = [i.get("name") for i in self.parameter_space]
+        objective_names = [i.get("name") for i in self.objective_config]
+        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}
+            trial_index = self.client.attach_trial(parameters=parameters)
+            raw_data = {name: value for name in existing_data if name in objective_names}
+            # Then complete the trial with the existing data
+            self.client.complete_trial(trial_index=trial_index, raw_data=raw_data)
+
+
+if __name__ == "__main__":
+    # Example usage
+    optimizer = AxOptimizer(
+        experiment_name="example_experiment",
+        parameter_space=[
+            {"name": "param_1", "type": "range", "bounds": [0.0, 1.0], "value_type": "float"},
+            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"}
+        ],
+        objective_config=[
+            {"name": "objective_1", "minimize": True},
+            {"name": "objective_2", "minimize": False}
+        ],
+        optimizer_config={
+            "step_1": {"model": "Sobol", "num_samples": 5},
+            "step_2": {"model": "BoTorch"}
+        }
+    )
+    print(optimizer._create_generator_mapping())

ivoryos/optimizer/base_optimizer.py

@@ -0,0 +1,65 @@
+### ivoryos/optimizers/base.py
+
+from abc import ABC, abstractmethod
+
+
+
+class OptimizerBase(ABC):
+    def __init__(self, experiment_name:str, parameter_space: list, objective_config: dict, optimizer_config: dict):
+        """
+        :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
+        optimizer_config={
+            "step_1": {"model": "Random", "num_samples": 10},
+            "step_2": {"model": "BOTorch"}
+        }
+        """
+        self.experiment_name = experiment_name
+        self.parameter_space = parameter_space
+        self.objective_config = objective_config
+        self.optimizer_config = optimizer_config
+
+    @abstractmethod
+    def suggest(self, n=1):
+        pass
+
+    @abstractmethod
+    def observe(self, results: dict):
+        """
+        observe
+        :param results: {"objective_name": "value"}
+        """
+        pass
+
+    @abstractmethod
+    def append_existing_data(self, existing_data):
+        pass
+
+    @staticmethod
+    def get_schema():
+        """
+        Returns a template for the optimizer configuration.
+        """
+        return {
+            "parameter_types": ["range", "choice"],
+            "multiple_objectives": True,
+            # "objective_weights": True,
+            "optimizer_config": {
+                "step_1": {"model": [], "num_samples": 10},
+                "step_2": {"model": []}
+            },
+        }
+
+
+

ivoryos/optimizer/baybe_optimizer.py

@@ -0,0 +1,183 @@
+### Directory: ivoryos/optimizers/baybe_optimizer.py
+from typing import Dict
+
+
+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):
+        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)
+        self._trial_id = 0
+        self._trials = {}
+
+        self.experiment = Campaign(
+            searchspace=self._convert_parameter_to_searchspace(parameter_space),
+            objective=self._convert_objective_to_baybe_format(objective_config),
+            recommender=self._convert_recommender_to_baybe_format(optimizer_config),
+        )
+
+
+    def suggest(self, n=1):
+        self.df = self.experiment.recommend(batch_size=n)
+        return self.df.to_dict(orient="records")[0]
+
+    def observe(self, results, index=None):
+        """
+        Observes the results of a trial and updates the experiment.
+        :param results: A dictionary containing the results of the trial.
+        :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)
+
+    def append_existing_data(self, existing_data: Dict):
+        """
+        Append existing data to the Ax experiment.
+        :param existing_data: A dictionary containing existing data.
+        """
+        import pandas as pd
+        if not existing_data:
+            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))
+        # 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}
+        #     trial_index = self.client.attach_trial(parameters=parameters)
+        #     raw_data = {name: value for name in existing_data if name in objective_names}
+        #     # Then complete the trial with the existing data
+        #     self.client.complete_trial(trial_index=trial_index, raw_data=raw_data)
+
+
+    def _convert_parameter_to_searchspace(self, parameter_space):
+        """
+        Converts the parameter space configuration to Baybe format.
+        :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
+        ]
+        :return: A list of Baybe parameters.
+        """
+        from baybe.parameters.categorical import CategoricalParameter
+        from baybe.parameters.numerical import NumericalContinuousParameter, NumericalDiscreteParameter
+        from baybe.searchspace import SearchSpace
+        parameters = []
+        for p in parameter_space:
+            if p["type"] == "range":
+                if 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)])
+                    parameters.append(NumericalDiscreteParameter(name=p["name"], values=values))
+
+            elif p["type"] == "choice":
+                if p["value_type"] == "str":
+                    parameters.append(CategoricalParameter(name=p["name"], values=p["bounds"]))
+                elif p["value_type"] in ["int", "float"]:
+                    parameters.append(NumericalDiscreteParameter(name=p["name"], values=p["bounds"]))
+        return SearchSpace.from_product(parameters)
+
+    def _convert_objective_to_baybe_format(self, objective_config):
+        """
+        Converts the objective configuration to Baybe format.
+        :param parameter_space: The parameter space configuration.
+        [
+            {"name": "obj_1", "minimize": True},
+            {"name": "obj_2", "minimize": False}
+        ]
+        :return: A Baybe objective configuration.
+        """
+        from baybe.targets import NumericalTarget
+        from baybe.objectives import SingleTargetObjective, DesirabilityObjective, ParetoObjective
+        targets = []
+        weights = []
+        for obj in objective_config:
+            obj_name = obj.get("name")
+            minimize = obj.get("minimize", False)
+            weight = obj.get("weight", 1)
+            weights.append(weight)
+            targets.append(NumericalTarget(name=obj_name, mode="MAX" if minimize else "MIN"))
+
+        if len(targets) == 1:
+            return SingleTargetObjective(target=targets[0])
+        else:
+            # Handle multiple objectives
+            return ParetoObjective(targets=targets)
+
+
+    def _convert_recommender_to_baybe_format(self, recommender_config):
+        """
+        Converts the recommender configuration to Baybe format.
+        :param recommender_config: The recommender configuration.
+        :return: A Baybe recommender configuration.
+        """
+        from baybe.recommenders import (
+            BotorchRecommender,
+            FPSRecommender,
+            TwoPhaseMetaRecommender,
+            RandomRecommender,
+            NaiveHybridSpaceRecommender
+        )
+        step_1 = recommender_config.get("step_1", {})
+        step_2 = recommender_config.get("step_2", {})
+        step_1_recommender = step_1.get("model", "Random")
+        step_2_recommender = step_2.get("model", "BOTorch")
+        if step_1.get("model") == "Random":
+            step_1_recommender = RandomRecommender()
+        elif step_1.get("model") == "FPS":
+            step_1_recommender = FPSRecommender()
+        if step_2.get("model") == "Naive Hybrid Space":
+            step_2_recommender = NaiveHybridSpaceRecommender()
+        elif step_2.get("model") == "BOTorch":
+            step_2_recommender = BotorchRecommender()
+        return TwoPhaseMetaRecommender(
+            initial_recommender=step_1_recommender,
+            recommender=step_2_recommender
+        )
+
+    @staticmethod
+    def get_schema():
+        """
+        Returns a template for the optimizer configuration.
+        """
+        return {
+            "parameter_types": ["range", "choice", "substance"],
+            "multiple_objectives": True,
+            "optimizer_config": {
+                "step_1": {"model": ["Random", "FPS"], "num_samples": 10},
+                "step_2": {"model": ["BOTorch", "Naive Hybrid Space"]}
+            },
+        }
+
+if __name__ == "__main__":
+    # Example usage
+    baybe_optimizer = BaybeOptimizer(
+        experiment_name="example_experiment",
+        parameter_space=[
+            {"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"}
+        ],
+        objective_config=[
+            {"name": "obj_1", "minimize": True},
+            {"name": "obj_2", "minimize": False}
+        ],
+        optimizer_config={
+            "step_1": {"model": "Random", "num_samples": 10},
+            "step_2": {"model": "BOTorch"}
+        }
+    )
+    print(baybe_optimizer.suggest(5))

ivoryos/optimizer/registry.py

@@ -0,0 +1,9 @@
+# optimizers/registry.py
+
+from ivoryos.optimizer.ax_optimizer import AxOptimizer
+from ivoryos.optimizer.baybe_optimizer import BaybeOptimizer
+
+OPTIMIZER_REGISTRY = {
+    "ax": AxOptimizer,
+    "baybe": BaybeOptimizer
+}

ivoryos/routes/api/api.py

@@ -0,0 +1,56 @@
+import os
+from flask import Blueprint, jsonify, request, current_app
+
+from ivoryos.routes.control.control import find_instrument_by_name
+from ivoryos.utils.form import create_form_from_module
+from ivoryos.utils.global_config import GlobalConfig
+from ivoryos.utils.db_models import Script, WorkflowRun, SingleStep, WorkflowStep
+
+from ivoryos.socket_handlers import abort_pending, abort_current, pause, retry, runner
+from ivoryos.utils.task_runner import TaskRunner
+
+api = Blueprint('api', __name__)
+global_config = GlobalConfig()
+task_runner = TaskRunner()
+
+#TODO: add authentication and authorization to the API endpoints
+
+
+@api.route("/control/", strict_slashes=False, methods=['GET'])
+@api.route("/control/<string:instrument>", methods=['POST'])
+def backend_control(instrument: str=None):
+    """
+    .. :quickref: Backend Control; backend control
+
+    backend control through http requests
+
+    .. http:get:: /api/control/
+
+    :param instrument: instrument name
+    :type instrument: str
+
+    .. http:post:: /api/control/
+
+    """
+    if instrument:
+        inst_object = find_instrument_by_name(instrument)
+        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)
+        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']}
+            wait = request.form.get("hidden_wait", "true") == "true"
+            output = task_runner.run_single_step(component=instrument, method=method_name, kwargs=kwargs, wait=wait,
+                                            current_app=current_app._get_current_object())
+            return jsonify(output), 200
+
+    snapshot = global_config.deck_snapshot.copy()
+    # 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'])
+    return jsonify(snapshot), 200

ivoryos/utils/serilize.py

@@ -7,8 +7,8 @@ import sys
 
 import flask
 
-from example.abstract_sdl_example.abstract_balance import AbstractBalance
-from example.abstract_sdl_example.abstract_pump import AbstractPump
+from example.abstract_sdl_example import abstract_sdl as deck
+
 
 
 class ScriptAnalyzer:
@@ -179,14 +179,12 @@ class ScriptAnalyzer:
                 print(f"  {name}: {error}")
 
 if __name__ == "__main__":
-    balance = AbstractBalance("re")
-    pump = AbstractPump("re")
 
     _analyzer = ScriptAnalyzer()
-    module = sys.modules[__name__]
+    # module = sys.modules[deck]
     try:
 
-        result, with_warnings, failed, _ = _analyzer.analyze_module(module)
+        result, with_warnings, failed, _ = _analyzer.analyze_module(deck)
 
         output_path = f"analysis.json"
         _analyzer.save_to_json(result, output_path)

ivoryos/version.py

@@ -1 +1 @@
-__version__ = "1.2.1"
+__version__ = "1.2.2"

{ivoryos-1.2.1.dist-info → ivoryos-1.2.2.dist-info}/METADATA

@@ -1,11 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ivoryos
-Version: 1.2.1
+Version: 1.2.2
 Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
-Home-page: https://gitlab.com/heingroup/ivoryos
-Author: Ivory Zhang
-Author-email: ivoryzhang@chem.ubc.ca
+Author-email: Ivory Zhang <ivoryzhang@chem.ubc.ca>
 License: MIT
+Project-URL: Homepage, https://gitlab.com/heingroup/ivoryos
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: bcrypt
@@ -17,6 +17,10 @@ Requires-Dist: Flask-WTF
 Requires-Dist: SQLAlchemy-Utils
 Requires-Dist: python-dotenv
 Requires-Dist: astor; python_version < "3.9"
+Provides-Extra: optimizer
+Requires-Dist: ax-platform; extra == "optimizer"
+Requires-Dist: baybe; extra == "optimizer"
+Dynamic: license-file
 
 [![Documentation Status](https://readthedocs.org/projects/ivoryos/badge/?version=latest)](https://ivoryos.readthedocs.io/en/latest/?badge=latest)
 [![PyPI version](https://img.shields.io/pypi/v/ivoryos)](https://pypi.org/project/ivoryos/)

{ivoryos-1.2.1.dist-info → ivoryos-1.2.2.dist-info}/RECORD

@@ -1,8 +1,13 @@
 ivoryos/__init__.py,sha256=x4PnDTbhx1ZTugfuclGQ03GO3yidAfiUFU7vuGyKD8M,9830
 ivoryos/config.py,sha256=y3RxNjiIola9tK7jg-mHM8EzLMwiLwOzoisXkDvj0gA,2174
 ivoryos/socket_handlers.py,sha256=VWVWiIdm4jYAutwGu6R0t1nK5MuMyOCL0xAnFn06jWQ,1302
-ivoryos/version.py,sha256=Mlm4Gvmb_6yQxwUbv2Ksc-BJFXLPg9H1Vt2iV7wXrA4,22
+ivoryos/version.py,sha256=uuf4VNtTNA93fMhoAur9YafzaKJFnczY-H1SSCSuRVQ,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/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ivoryos/routes/auth/auth.py,sha256=CqoP9cM8BuXVGHGujX7-0sNAOdWILU9amyBrObOD6Ss,3283
 ivoryos/routes/control/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,20 +37,11 @@ ivoryos/utils/global_config.py,sha256=zNO9GYhGn7El3msWoxJIm3S4Mzb3VMh2i5ZEsVtvb2
 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=g3_pLYcu6gF9sPjhW9WRlwMH7ScDpz_MqMJzxNayfyg,16725
-ivoryos/utils/serilize.py,sha256=Ded3Vbicl4KYN8GJ_gY7HJMuInAeFZEPk5ZtuEtHPns,6933
+ivoryos/utils/serilize.py,sha256=lkBhkz8r2bLmz2_xOb0c4ptSSOqjIu6krj5YYK4Nvj8,6784
 ivoryos/utils/task_runner.py,sha256=cDIcmDaqYh0vXoYaL_kO877pluAo2tyfsHl9OgZqJJE,3029
 ivoryos/utils/utils.py,sha256=-WiU0_brszB9yDsiQepf_7SzNgPTSpul2RSKDOY3pqo,13921
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=u2sQ6U-Lghyl7et1Oz6J2E5VZ47VINKcjRM_2leAE2s,3627
-tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/integration/test_route_auth.py,sha256=l3ZDqr0oiCWS3yYSXGK5yMP6qI2t7Sv5I9zoYTkiyQU,2754
-tests/integration/test_route_control.py,sha256=YYIll84bTUEKiAxFiFSz6LF3fTldPNfCtHs0IR3mSdM,3935
-tests/integration/test_route_database.py,sha256=mS026W_hEuCTMpSkdRWvM-f4MYykK_6nRDJ4K5a7QA0,2342
-tests/integration/test_route_design.py,sha256=PJAvGRiCY6B53Pu1v5vPAVHHsuaqRmRKk2eesSNshLU,1157
-tests/integration/test_route_main.py,sha256=bmuf8Y_9CRWhiLLf4up11ltEd5YCdsLx6I-o26VGDEw,1228
-tests/integration/test_sockets.py,sha256=4ZyFyExm7a-DYzVqpzEONpWeb1a0IT68wyFaQu0rY_Y,925
-ivoryos-1.2.1.dist-info/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
-ivoryos-1.2.1.dist-info/METADATA,sha256=AiQqfIiig_KOYF5ths0jGNMbax1YV44deM6wKwHwnAY,9247
-ivoryos-1.2.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-ivoryos-1.2.1.dist-info/top_level.txt,sha256=mIOiZkdpSwxFJt1R5fsyOff8mNprXHq1nMGNKNULIyE,14
-ivoryos-1.2.1.dist-info/RECORD,,
+ivoryos-1.2.2.dist-info/licenses/LICENSE,sha256=p2c8S8i-8YqMpZCJnadLz1-ofxnRMILzz6NCMIypRag,1084
+ivoryos-1.2.2.dist-info/METADATA,sha256=vvueQx-kWo57d7AvBCDtUp28Ot_DBmgeTaZ6HVNS3ec,9416
+ivoryos-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ivoryos-1.2.2.dist-info/top_level.txt,sha256=FRIWWdiEvRKqw-XfF_UK3XV0CrnNb6EmVbEgjaVazRM,8
+ivoryos-1.2.2.dist-info/RECORD,,

{ivoryos-1.2.1.dist-info → ivoryos-1.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{ivoryos-1.2.1.dist-info → ivoryos-1.2.2.dist-info}/top_level.txt

@@ -1,2 +1 @@
 ivoryos
-tests

tests/conftest.py

@@ -1,133 +0,0 @@
-from enum import Enum
-
-import bcrypt
-import pytest
-from ivoryos.config import get_config
-
-from ivoryos import create_app, socketio, db as _db, utils, global_config
-from ivoryos.utils.db_models import User
-
-
-@pytest.fixture(scope='session')
-def app():
-    """Create a new app instance for the test session."""
-    _app = create_app(get_config('testing'))
-    return _app
-
-@pytest.fixture
-def client(app):
-    """A test client for the app."""
-    with app.test_client() as client:
-        with app.app_context():
-            _db.create_all()
-        yield client
-        with app.app_context():
-            _db.drop_all()
-
-# @pytest.fixture(scope='session')
-# def db(app):
-#     """Session-wide test database."""
-#     with app.app_context():
-#         _db.create_all()
-#         yield _db
-#         _db.drop_all()
-
-@pytest.fixture(scope='module')
-def init_database(app):
-    """
-    Creates the database tables and seeds it with a default test user.
-    This runs once per test module.
-    """
-    with app.app_context():
-        # Drop everything first to ensure a clean slate
-        _db.drop_all()
-        # Create the database tables
-        _db.create_all()
-
-        # Insert a default user for authentication tests
-        # Note: In a real app with password hashing, you'd call a hash function here.
-        password = 'password'
-        bcrypt_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
-        default_user = User(username='testuser', password=bcrypt_password)
-        _db.session.add(default_user)
-        _db.session.commit()
-
-        yield _db  # this is where the testing happens!
-
-        # Teardown: drop all tables after the tests in the module are done
-        _db.drop_all()
-
-
-# ---------------------
-# Authentication Fixture
-# ---------------------
-
-@pytest.fixture(scope='function')
-def auth(client, init_database):
-    """
-    Logs in the default user for a single test function.
-    Depends on `init_database` to ensure the user exists.
-    Handles logout as part of teardown.
-    """
-    # Log in the default user
-    client.post('/ivoryos/auth/login', data={
-        'username': 'testuser',
-        'password': 'password'
-    }, follow_redirects=True)
-
-    yield client  # this is where the testing happens!
-
-    # Log out the user after the test is done
-    client.get('/ivoryos/auth/logout', follow_redirects=True)
-
-
-@pytest.fixture
-def socketio_client(app):
-    """A test client for Socket.IO."""
-    return socketio.test_client(app)
-
-
-class TestEnum(Enum):
-    """An example Enum for testing type conversion."""
-    OPTION_A = 'A'
-    OPTION_B = 'B'
-
-class DummyModule:
-    """A more comprehensive dummy instrument for testing."""
-    def int_method(self, arg: int = 1):
-        return arg
-
-    def float_method(self, arg: float = 1.0):
-        return arg
-
-    def bool_method(self, arg: bool = False):
-        return arg
-
-    def list_method(self, arg: list = None):
-        return arg or []
-
-    def enum_method(self, arg: TestEnum = TestEnum.OPTION_A):
-        return arg
-
-    def str_method(self) -> dict:
-        return {'status': 'OK'}
-
-
-@pytest.fixture
-def test_deck(app):
-    """
-    A fixture that creates and loads a predictable 'deck' of dummy instruments
-    for testing the dynamic control routes.
-    """
-    dummy_module = DummyModule()
-    snapshot = utils.create_deck_snapshot(dummy_module)
-
-    with app.app_context():
-        global_config.deck_snapshot = snapshot
-        global_config.deck = dummy_module # instantiate the class
-
-    yield DummyModule
-
-    with app.app_context():
-        global_config.deck_snapshot = {}
-        global_config.deck = {}

tests/integration/test_route_auth.py

@@ -1,80 +0,0 @@
-from ivoryos.utils.db_models import User, db
-
-
-def test_get_signup(client):
-    """
-    GIVEN a client
-    WHEN a GET request is made to /ivoryos/auth/signup
-    THEN check that signup page loads with 200 status and contains "Signup" text
-    """
-    response = client.get("/ivoryos/auth/signup", follow_redirects=True)
-    assert response.status_code == 200
-    assert b"Signup" in response.data
-
-
-def test_route_auth_signup(client):
-    """
-    GIVEN a client
-    WHEN a POST request is made to /ivoryos/auth/signup with valid credentials
-    THEN check that signup succeeds with 200 status and the user is created in database
-    """
-    response = client.post("/ivoryos/auth/signup",
-                           data={
-                               "username": "second_testuser",
-                               "password": "password"
-                           },
-                           follow_redirects=True
-                           )
-    assert response.status_code == 200
-    assert b"Login" in response.data
-
-    # Verify user was created
-    with client.application.app_context():
-        user = db.session.query(User).filter(User.username == 'second_testuser').first()
-        assert user is not None
-
-
-def test_duplicate_user_signup(client, init_database):
-    """
-    GIVEN a client and init_database fixture
-    WHEN a POST request is made to signup with an existing username
-    THEN check that signup fails with 409 status and appropriate error message
-    """
-    client.post('/ivoryos/auth/signup', data={
-        'username': 'existinguser',
-        'password': 'anotherpass'
-    })
-    # Try to create duplicate
-    response = client.post('/ivoryos/auth/signup', data={
-        'username': 'existinguser',
-        'password': 'anotherpass'
-    })
-    assert response.status_code == 409
-    assert b"Signup" in response.data
-    assert b"User already exists" in response.data
-
-    # Verify user was created
-    users = db.session.query(User).filter(User.username == 'existinguser').all()
-    assert len(users) == 1
-
-
-def test_failed_login(client):
-    """
-    GIVEN a client and invalid login credentials
-    WHEN a POST request is made to /ivoryos/auth/login
-    THEN check that login fails with 401 status and the appropriate error message
-    """
-    response = client.post('/ivoryos/auth/login', data={
-        'username': 'nonexistent',
-        'password': 'wrongpass'
-    })
-    assert response.status_code == 401
-
-def test_logout(auth):
-    """
-    GIVEN an authenticated client
-    WHEN a GET request is made to /ivoryos/auth/logout
-    THEN check that logout succeeds with 302 status and redirects to login
-    """
-    response = auth.get('/ivoryos/auth/logout')
-    assert response.status_code == 302  # Redirect to login

tests/integration/test_route_control.py

@@ -1,94 +0,0 @@
-from unittest.mock import patch, Mock
-
-from ivoryos.utils.db_models import Script
-from ivoryos import db
-
-def test_control_panel_redirects_anonymous(client):
-    """
-    GIVEN an anonymous user
-    WHEN the control panel is accessed
-    THEN they should be redirected to the login page
-    """
-    response = client.get('/ivoryos/control/home/deck', follow_redirects=True)
-    assert response.status_code == 200
-    assert b'Login' in response.data
-
-def test_deck_control_for_auth_user(auth):
-    """
-    GIVEN an authenticated user
-    WHEN the control panel is accessed
-    THEN the page should load successfully
-    """
-    response = auth.get('/ivoryos/control/home/deck', follow_redirects=True)
-    assert response.status_code == 200
-    assert b'<title>IvoryOS | Devices</title>' in response.data # Assuming this text exists on the page
-
-def test_temp_control_for_auth_user(auth):
-    """
-    GIVEN an authenticated user
-    WHEN the control panel is accessed
-    THEN the page should load successfully
-    """
-    response = auth.get('/ivoryos/control/home/temp', follow_redirects=True)
-    assert response.status_code == 200
-    # assert b'<title>IvoryOS | Devices</title>' in response.data # Assuming this text exists on the page
-
-def test_new_controller_page(auth):
-    """Test new controller page loads"""
-    response = auth.get('/ivoryos/control/new/')
-    assert response.status_code == 200
-
-def test_download_proxy(self, auth_headers):
-    """Test proxy download functionality"""
-    with patch('ivoryos.routes.control.control.global_config') as mock_config:
-        mock_config.deck_snapshot = {'test_instrument': {'test_method': {'signature': 'test()'}}}
-        response = auth_headers.get('/ivoryos/control/download')
-        assert response.status_code == 200
-        assert response.headers['Content-Disposition'].startswith('attachment')
-
-def test_backend_control_get(self, auth_headers):
-    """Test backend control GET endpoint"""
-    with patch('ivoryos.routes.control.control.global_config') as mock_config:
-        mock_config.deck_snapshot = {'test_instrument': {'test_method': {'signature': 'test()'}}}
-        response = auth_headers.get('/ivoryos/api/control/')
-        assert response.status_code == 200
-        assert response.is_json
-
-@patch('ivoryos.routes.control.control.runner')
-@patch('ivoryos.routes.control.control.find_instrument_by_name')
-@patch('ivoryos.routes.control.control.create_form_from_module')
-def test_backend_control_post(self, mock_form, mock_find, mock_runner, auth_headers):
-    """Test backend control POST endpoint"""
-    # Setup mocks
-    mock_instrument = Mock()
-    mock_find.return_value = mock_instrument
-    mock_field = Mock()
-    mock_field.name = 'test_param'
-    mock_field.data = 'test_value'
-    mock_form_instance = Mock()
-    mock_form_instance.__iter__ = Mock(return_value=iter([mock_field]))
-    mock_form.return_value = {'test_method': mock_form_instance}
-    mock_runner.run_single_step.return_value = 'success'
-    response = auth_headers.post('/ivoryos/api/control/test_instrument', data={
-        'hidden_name': 'test_method',
-        'hidden_wait': 'true'
-    })
-    assert response.status_code == 200
-
-# def test_control(auth, app):
-#     """
-#     GIVEN an authenticated user and an existing script
-#     WHEN a POST request is made to run the script
-#     THEN the user should be redirected and a success message shown
-#     """
-#     # We need to create a script in the database first
-#     with app.app_context():
-#         script = Script(name='My Test Script', author='testuser', content='print("hello")')
-#         db.session.add(script)
-#         db.session.commit()
-#         script_id = script.id
-#
-#     # Simulate running the script
-#     response = auth.post(f'/ivoryos/control/run/{script_id}', follow_redirects=True)
-#     assert response.status_code == 200
-#     assert b'has been initiated' in response.data # Check for a flash message

tests/integration/test_route_database.py

@@ -1,61 +0,0 @@
-from datetime import datetime
-
-from ivoryos.utils.db_models import Script, WorkflowRun, WorkflowStep
-from ivoryos import db
-
-def test_database_scripts_page(auth):
-    """
-    GIVEN an authenticated user
-    WHEN they access the script database page
-    THEN the page should load and show their scripts
-    """
-    # First, create a script so the page has something to render
-    with auth.application.app_context():
-        script = Script(name='test_script', author='testuser')
-        db.session.add(script)
-        db.session.commit()
-
-    response = auth.get('/ivoryos/database/scripts/', follow_redirects=True)
-    assert response.status_code == 200
-    # assert b'Scripts Database' in response.data
-    assert b'<title>IvoryOS | Design Database</title>' in response.data
-
-def test_database_workflows_page(auth):
-    """
-    GIVEN an authenticated user
-    WHEN they access the workflow database page
-    THEN the page should load and show past workflow runs
-    """
-    # Create a workflow run to display
-    with auth.application.app_context():
-        run = WorkflowRun(name="untitled", platform="deck",start_time=datetime.now())
-        db.session.add(run)
-        db.session.commit()
-        run_id = run.id
-
-    response = auth.get('/ivoryos/database/workflows/', follow_redirects=True)
-    assert response.status_code == 200
-    assert b'Workflow ID' in response.data
-    # assert b'run_id' in response.data
-
-def test_view_specific_workflow(auth):
-    """
-    GIVEN an authenticated user and an existing workflow run
-    WHEN they access the specific URL for that workflow
-    THEN the detailed view for that run should be displayed
-    """
-    with auth.application.app_context():
-        run = WorkflowRun(name='test_workflow', platform='test_platform', start_time=datetime.now())
-        db.session.add(run)
-        db.session.commit()
-        run_id = run.id
-
-        step = WorkflowStep(method_name='test_step', workflow_id=run_id, phase="main", run_error=False, start_time=datetime.now())
-        db.session.add(step)
-        db.session.commit()
-        # run_id = run.id
-
-    response = auth.get(f'/ivoryos/database/workflows/{run_id}', follow_redirects=True)
-    assert response.status_code == 200
-    # assert b'test_step' in response.data # Check for a title on the view page
-    assert b'test_workflow' in response.data

tests/integration/test_route_design.py

@@ -1,36 +0,0 @@
-def test_design_page_loads_for_auth_user(auth):
-    """
-    GIVEN an authenticated user
-    WHEN the design page is accessed
-    THEN the page should load successfully
-    """
-    response = auth.get('/ivoryos/design/script/', follow_redirects=True)
-    assert response.status_code == 200
-    assert b'<title>IvoryOS | Design</title>' in response.data # Assuming this text exists
-
-
-def test_clear_canvas(auth):
-    """
-    Tests clearing the design canvas.
-    """
-    response = auth.get('/ivoryos/design/clear', follow_redirects=True)
-    assert response.status_code == 200
-    # assert b'Operations' in response.data
-
-# def test_add_action(auth, test_deck):
-#     """
-#     Tests adding an action to the design canvas.
-#     """
-#     response = auth.post('/ivoryos/design/script/deck.dummy/', data={
-#         'hidden_name': 'int_method',
-#         'arg': '10'
-#     }, follow_redirects=True)
-#     assert response.status_code == 200
-
-def test_experiment_run_page(auth):
-    """
-    Tests the experiment run page.
-    """
-    response = auth.get('/ivoryos/design/campaign')
-    assert response.status_code == 200
-    assert b'Run Panel' in response.data

tests/integration/test_route_main.py

@@ -1,35 +0,0 @@
-from flask_login import current_user
-
-
-def test_home_page_authenticated(auth, app):
-    """
-    GIVEN an authenticated user (using the 'auth' fixture)
-    WHEN the home page is accessed
-    THEN check that they see the main application page
-    """
-    with auth.application.test_request_context('/ivoryos/'):
-        # Manually trigger the before_request functions that Flask-Login uses
-        app.preprocess_request()
-
-        # Assert that the `current_user` proxy is now populated and authenticated
-        assert current_user.is_authenticated
-        assert current_user.username == 'testuser'
-
-def test_help_page(client):
-    """
-    GIVEN an unauthenticated user
-    WHEN they access the help page
-    THEN check that the page loads successfully and contains documentation content
-    """
-    response = client.get('/ivoryos/help')
-    assert response.status_code == 200
-    assert b'Documentations' in response.data
-
-def test_prefix_redirect(auth):
-    """
-    GIVEN an authenticated user (using the 'auth' fixture)
-    WHEN the home page is accessed without prefix
-    THEN check that they see the main application page
-    """
-    response = auth.get('/', follow_redirects=True)
-    assert response.status_code == 200

tests/integration/test_sockets.py

@@ -1,26 +0,0 @@
-def test_socket_connection(socketio_client):
-    """
-    Test that a client can successfully connect to the Socket.IO server.
-    """
-    assert socketio_client.is_connected()
-    socketio_client.disconnect()
-    assert not socketio_client.is_connected()
-
-
-# def test_logger_socket_event(socketio_client):
-#     """
-#     Test the custom logging event handler.
-#     (This assumes you have a handler like `@socketio.on('start_log')`)
-#     """
-#     # Connect the client
-#     socketio_client.connect()
-#
-#     # Emit an event from the client to the server
-#     socketio_client.emit('start_log', {'logger_name': 'my_test_logger'})
-#
-#     # Check what the server sent back to the client
-#     received = socketio_client.get_received()
-#
-#     assert len(received) > 0
-#     assert received[0]['name'] == 'log_message'  # Check for the event name
-#     assert 'Logger my_test_logger started' in received[0]['args'][0]['data']