ivoryos 1.2.0b1__py3-none-any.whl → 1.2.2__py3-none-any.whl

ivoryos/__init__.py

@@ -1,8 +1,11 @@
 import os
 import sys
+import uuid
 from typing import Union
 
-from flask import Flask, redirect, url_for, g, Blueprint
+from flask import Flask, redirect, url_for, g, Blueprint, session
+from flask_login import AnonymousUserMixin
+
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 
 from ivoryos.config import Config, get_config
@@ -90,6 +93,23 @@ def create_app(config_class=None):
         """
         g.logger = logger
         g.socketio = socketio
+        session.permanent = False
+        # DEMO_MODE: Simulate logged-in user per session
+        if app.config.get("DEMO_MODE", False):
+            if "demo_user_id" not in session:
+                session["demo_user_id"] = f"demo_{str(uuid.uuid4())[:8]}"
+
+            class SessionDemoUser(AnonymousUserMixin):
+                @property
+                def is_authenticated(self):
+                    return True
+
+                def get_id(self):
+                    return session.get("demo_user_id")
+
+            login_manager.anonymous_user = SessionDemoUser
+
+
 
     @app.route('/')
     def redirect_to_prefix():
@@ -101,6 +121,7 @@ def create_app(config_class=None):
         text = ' '.join(word for word in name.split('_'))
         return text.capitalize()
 
+    # app.config.setdefault("DEMO_MODE", False)
     return app
 
 

ivoryos/config.py

@@ -43,6 +43,7 @@ class TestingConfig(Config):
 
 class DemoConfig(Config):
     DEBUG = False
+    DEMO_MODE = True
     SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
     OUTPUT_FOLDER = os.path.join(os.path.abspath(os.curdir), '/tmp/ivoryos_data')
     CSV_FOLDER = os.path.join(OUTPUT_FOLDER, 'config_csv/')

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/auth/auth.py

@@ -5,6 +5,7 @@ import bcrypt
 from ivoryos.utils.db_models import Script, User, db
 from ivoryos.utils.utils import post_script_file
 login_manager = LoginManager()
+# from flask import g
 
 auth = Blueprint('auth', __name__, template_folder='templates')
 
@@ -37,7 +38,8 @@ def login():
             # password.encode("utf-8")
             # user = User(username, password.encode("utf-8"))
             login_user(user)
-            session['user'] = username
+            # g.user = user
+            # session['user'] = username
             script_file = Script(author=username)
             session["script"] = script_file.as_dict()
             session['hidden_functions'], session['card_order'], session['prompt'] = {}, {}, {}

ivoryos/routes/data/data.py

@@ -10,6 +10,7 @@ data = Blueprint('data', __name__, template_folder='templates')
 
 
 @data.route('/executions/records')
+@login_required
 def list_workflows():
     """
     .. :quickref: Workflow Execution Database; list all workflow execution records
@@ -113,6 +114,7 @@ def delete_workflow_record(workflow_id: int):
 
 
 @data.route('/files/execution-data/<string:filename>')
+@login_required
 def download_results(filename:str):
     """
     .. :quickref: Workflow data; download a workflow data file (.CSV)

ivoryos/routes/design/design.py

@@ -1,7 +1,7 @@
 import os
 
 from flask import Blueprint, redirect, url_for, flash, jsonify, request, render_template, session, current_app
-from flask_login import login_required
+from flask_login import login_required, current_user
 
 from ivoryos.routes.library.library import publish
 from ivoryos.utils import utils
@@ -64,7 +64,7 @@ def experiment_builder():
     if deck and script.deck is None:
         script.deck = os.path.splitext(os.path.basename(deck.__file__))[
             0] if deck.__name__ == "__main__" else deck.__name__
-
+        utils.post_script_file(script)
     pseudo_deck_name = session.get('pseudo_deck', '')
     pseudo_deck_path = os.path.join(current_app.config["DUMMY_DECK"], pseudo_deck_name)
     off_line = current_app.config["OFF_LINE"]
@@ -238,7 +238,7 @@ def clear_draft():
             0] if deck.__name__ == "__main__" else deck.__name__
     else:
         deck_name = session.get("pseudo_deck", "")
-    script = Script(deck=deck_name, author=session.get('username'))
+    script = Script(deck=deck_name, author=current_user.get_id())
     utils.post_script_file(script)
     exec_string = script.compile(current_app.config['SCRIPT_FOLDER'])
     session['python_code'] = exec_string
@@ -265,7 +265,7 @@ def submit_script():
     """
     deck = global_config.deck
     deck_name = os.path.splitext(os.path.basename(deck.__file__))[0] if deck.__name__ == "__main__" else deck.__name__
-    script = Script(author=session.get('user'), deck=deck_name)
+    script = Script(author=current_user.get_id(), deck=deck_name)
     script_collection = request.get_json()
     workflow_name = script_collection.pop("workflow_name")
     script.python_script = script_collection

ivoryos/routes/library/library.py

@@ -1,5 +1,5 @@
 from flask import Blueprint, redirect, url_for, flash, request, render_template, session, current_app, jsonify
-from flask_login import login_required
+from flask_login import login_required, current_user
 
 from ivoryos.utils.db_models import Script, db, WorkflowRun, WorkflowStep
 from ivoryos.utils.utils import get_script_file, post_script_file
@@ -66,14 +66,14 @@ def publish():
     script = get_script_file()
 
     if script.author is None:
-        script.author = session.get('user')
+        script.author = current_user.get_id()
     if not script.name or not script.deck:
         return {"success": False, "error": "Deck cannot be empty, try to re-submit deck configuration on the left panel"}
     row = Script.query.get(script.name)
     if row and row.status == "finalized":
         return {"success": False, "error": "This is a protected script, use save as to rename."}
 
-    elif row and session.get('user') != row.author:
+    elif row and current_user.get_id() != row.author:
         return {"success": False, "error": "You are not the author, use save as to rename."}
     else:
         db.session.merge(script)
@@ -145,7 +145,7 @@ def save_as():
         script = get_script_file()
         script.save_as(run_name)
         script.registered = register_workflow == "on"
-        script.author = session.get('user')
+        script.author = current_user.get_id()
         post_script_file(script)
         status = publish()
         if request.accept_mimetypes.best_match(['application/json', 'text/html']) == 'application/json':

ivoryos/utils/script_runner.py

@@ -66,7 +66,7 @@ class ScriptRunner:
         global deck
         if deck is None:
             deck = global_config.deck
-        print("history", history)
+        # print("history", history)
         if self.current_app is None:
             self.current_app = current_app
         # time.sleep(1)  # Optional: may help ensure deck readiness

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/utils/utils.py

@@ -11,6 +11,7 @@ from collections import Counter
 
 import flask
 from flask import session
+from flask_login import current_user
 from flask_socketio import SocketIO
 
 from ivoryos.utils.db_models import Script
@@ -24,7 +25,7 @@ def get_script_file():
         s.__dict__.update(**session_script)
         return s
     else:
-        return Script(author=session.get('user'))
+        return Script(author=current_user.get_id(),)
 
 
 def post_script_file(script, is_dict=False):

ivoryos/version.py

@@ -1 +1 @@
-__version__ = "1.2.0b1"
+__version__ = "1.2.2"