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

docs/source/conf.py

@@ -0,0 +1,84 @@
+# Configuration file for the Sphinx documentation builder.
+import os
+import sys
+import urllib
+
+import requests
+
+# -- General configuration
+sys.path.insert(0, os.path.abspath('../../'))
+from ivoryos.version import __version__
+
+
+# appending suite readme.rst to doc
+
+external_readme = [
+    {
+        "name": 'plugin.rst',
+        "url": "https://gitlab.com/heingroup/ivoryos-suite/ivoryos-plugin-template/-/raw/main/README.rst"
+    },
+    {
+        "name": 'client.rst',
+        "url": "https://gitlab.com/heingroup/ivoryos-suite/ivoryos-client/-/raw/main/README.rst"
+    },
+    {
+        "name": 'mcp.rst',
+        "url": "https://gitlab.com/heingroup/ivoryos-suite/ivoryos-mcp/-/raw/main/README.rst"
+    }
+]
+
+for item in external_readme:
+    readme_url = item['url']
+    name = item['name']
+    output_path = os.path.join(os.path.dirname(__file__), name)
+    r = requests.get(readme_url, verify=False)
+    if not os.path.exists(output_path):
+        with open(output_path, "wb") as f:
+            f.write(r.content)
+
+# -- Project information
+project = 'ivoryOS'
+copyright = '2024, Ivory Zhang'
+author = 'Ivory Zhang, Lucy Hao'
+version = __version__
+
+extensions = [
+    'sphinx.ext.duration',
+    'sphinx.ext.doctest',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.intersphinx',
+    'sphinxcontrib.httpdomain',
+    'sphinxcontrib.autohttp.flask',
+    'sphinxcontrib.autohttp.flaskqref'
+]
+
+install_requires = [
+    'sphinx-autodoc-typehints'
+]
+autodoc_mock_imports = ["flask_sqlalchemy", "another_hard_to_import_lib"]
+
+
+intersphinx_mapping = {
+    'python': ('https://docs.python.org/3/', None),
+    'sphinx': ('https://www.sphinx-doc.org/en/master/', None),
+}
+intersphinx_disabled_domains = ['std']
+
+templates_path = ['_templates']
+
+html_static_path = ['_static']
+html_css_files = [
+    'custom.css',
+]
+
+html_allow_raw_html = True
+
+# -- Options for HTML output
+
+html_theme = 'sphinx_rtd_theme'
+
+# -- Options for EPUB output
+epub_show_urls = 'footnote'
+
+# The master toctree document.
+master_doc = 'index'

ivoryos/__init__.py

@@ -1,208 +1,18 @@
-import os
-import sys
-from typing import Union
-
-from flask import Flask, redirect, url_for, g, Blueprint
-
-from ivoryos.config import Config, get_config
-from ivoryos.routes.auth.auth import auth, login_manager
-from ivoryos.routes.control.control import control
-from ivoryos.routes.database.database import database
-from ivoryos.routes.design.design import design, socketio
-from ivoryos.routes.main.main import main
-# from ivoryos.routes.monitor.monitor import monitor
-from ivoryos.utils import utils
-from ivoryos.utils.db_models import db, User
-from ivoryos.utils.global_config import GlobalConfig
-from ivoryos.utils.script_runner import ScriptRunner
+from ivoryos.server import run, global_config
+from ivoryos.optimizer.registry import OPTIMIZER_REGISTRY
 from ivoryos.version import __version__ as ivoryos_version
-from importlib.metadata import entry_points
-
-global_config = GlobalConfig()
-from sqlalchemy import event
-from sqlalchemy.engine import Engine
-import sqlite3
-
-
-@event.listens_for(Engine, "connect")
-def enforce_sqlite_foreign_keys(dbapi_connection, connection_record):
-    if isinstance(dbapi_connection, sqlite3.Connection):
-        cursor = dbapi_connection.cursor()
-        cursor.execute("PRAGMA foreign_keys=ON")
-        cursor.close()
-
-
-url_prefix = os.getenv('URL_PREFIX', "/ivoryos")
-app = Flask(__name__, static_url_path=f'{url_prefix}/static', static_folder='static')
-app.register_blueprint(main, url_prefix=url_prefix)
-app.register_blueprint(auth, url_prefix=url_prefix)
-app.register_blueprint(control, url_prefix=url_prefix)
-app.register_blueprint(design, url_prefix=url_prefix)
-app.register_blueprint(database, url_prefix=url_prefix)
-
-@login_manager.user_loader
-def load_user(user_id):
-    """
-    This function is called by Flask-Login on every request to get the
-    current user object from the user ID stored in the session.
-    """
-    # The correct implementation is to fetch the user from the database.
-    return db.session.get(User, user_id)
-
-
-def create_app(config_class=None):
-    """
-    create app, init database
-    """
-    app.config.from_object(config_class or 'config.get_config()')
-    os.makedirs(app.config["OUTPUT_FOLDER"], exist_ok=True)
-    # Initialize extensions
-    socketio.init_app(app, cors_allowed_origins="*", cookie=None)
-    login_manager.init_app(app)
-    login_manager.login_view = "auth.login"
-    db.init_app(app)
-
-    # Create database tables
-    with app.app_context():
-        db.create_all()
-
-    # Additional setup
-    utils.create_gui_dir(app.config['OUTPUT_FOLDER'])
-
-    # logger_list = app.config["LOGGERS"]
-    logger_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["LOGGERS_PATH"])
-    logger = utils.start_logger(socketio, 'gui_logger', logger_path)
-
-    @app.before_request
-    def before_request():
-        """
-        Called before
-
-        """
-        g.logger = logger
-        g.socketio = socketio
-
-    @app.route('/')
-    def redirect_to_prefix():
-        return redirect(url_for('main.index', version=ivoryos_version))  # Assuming 'index' is a route in your blueprint
-
-    return app
-
-
-def run(module=None, host="0.0.0.0", port=None, debug=None, llm_server=None, model=None,
-        config: Config = None,
-        logger: Union[str, list] = None,
-        logger_output_name: str = None,
-        enable_design: bool = True,
-        blueprint_plugins: Union[list, Blueprint] = [],
-        exclude_names: list = [],
-        ):
-    """
-    Start ivoryOS app server.
-
-    :param module: module name, __name__ for current module
-    :param host: host address, defaults to 0.0.0.0
-    :param port: port, defaults to None, and will use 8000
-    :param debug: debug mode, defaults to None (True)
-    :param llm_server: llm server, defaults to None.
-    :param model: llm model, defaults to None. If None, app will run without text-to-code feature
-    :param config: config class, defaults to None
-    :param logger: logger name of list of logger names, defaults to None
-    :param logger_output_name: log file save name of logger, defaults to None, and will use "default.log"
-    :param enable_design: enable design canvas, database and workflow execution
-    :param blueprint_plugins: Union[list[Blueprint], Blueprint] custom Blueprint pages
-    :param exclude_names: list[str] module names to exclude from parsing
-    """
-    app = create_app(config_class=config or get_config())  # Create app instance using factory function
-
-    # plugins = load_installed_plugins(app, socketio)
-    plugins = []
-    if blueprint_plugins:
-        config_plugins = load_plugins(blueprint_plugins, app, socketio)
-        plugins.extend(config_plugins)
-
-    def inject_nav_config():
-        """Make NAV_CONFIG available globally to all templates."""
-        return dict(
-            enable_design=enable_design,
-            plugins=plugins,
-        )
-
-    app.context_processor(inject_nav_config)
-    port = port or int(os.environ.get("PORT", 8000))
-    debug = debug if debug is not None else app.config.get('DEBUG', True)
-
-    app.config["LOGGERS"] = logger
-    app.config["LOGGERS_PATH"] = logger_output_name or app.config["LOGGERS_PATH"]  # default.log
-    logger_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["LOGGERS_PATH"])
-    dummy_deck_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["DUMMY_DECK"])
-
-    if module:
-        app.config["MODULE"] = module
-        app.config["OFF_LINE"] = False
-        global_config.deck = sys.modules[module]
-        global_config.deck_snapshot = utils.create_deck_snapshot(global_config.deck,
-                                                                 output_path=dummy_deck_path,
-                                                                 save=True,
-                                                                 exclude_names=exclude_names
-                                                                 )
-    else:
-        app.config["OFF_LINE"] = True
-    if model:
-        app.config["ENABLE_LLM"] = True
-        app.config["LLM_MODEL"] = model
-        app.config["LLM_SERVER"] = llm_server
-        utils.install_and_import('openai')
-        from ivoryos.utils.llm_agent import LlmAgent
-        global_config.agent = LlmAgent(host=llm_server, model=model,
-                                       output_path=app.config["OUTPUT_FOLDER"] if module is not None else None)
-    else:
-        app.config["ENABLE_LLM"] = False
-    if logger and type(logger) is str:
-        utils.start_logger(socketio, log_filename=logger_path, logger_name=logger)
-    elif type(logger) is list:
-        for log in logger:
-            utils.start_logger(socketio, log_filename=logger_path, logger_name=log)
-
-    # in case Python 3.12 or higher doesn't log URL
-    if sys.version_info >= (3, 12):
-        ip = utils.get_local_ip()
-        print(f"Server running at http://localhost:{port}")
-        if not ip == "127.0.0.1":
-            print(f"Server running at http://{ip}:{port}")
-    socketio.run(app, host=host, port=port, debug=debug, use_reloader=False, allow_unsafe_werkzeug=True)
-    # return app
-
-
-def load_installed_plugins(app, socketio):
-    """
-    Dynamically load installed plugins and attach Flask-SocketIO.
-    """
-    plugin_names = []
-    for entry_point in entry_points().get("ivoryos.plugins", []):
-        plugin = entry_point.load()
-
-        # If the plugin has an `init_socketio()` function, pass socketio
-        if hasattr(plugin, 'init_socketio'):
-            plugin.init_socketio(socketio)
-
-        plugin_names.append(entry_point.name)
-        app.register_blueprint(getattr(plugin, entry_point.name), url_prefix=f"{url_prefix}/{entry_point.name}")
-
-    return plugin_names
-
-
-def load_plugins(blueprints: Union[list, Blueprint], app, socketio):
-    """
-    Dynamically load installed plugins and attach Flask-SocketIO.
-    """
-    plugin_names = []
-    if not isinstance(blueprints, list):
-        blueprints = [blueprints]
-    for blueprint in blueprints:
-        # If the plugin has an `init_socketio()` function, pass socketio
-        if hasattr(blueprint, 'init_socketio'):
-            blueprint.init_socketio(socketio)
-        plugin_names.append(blueprint.name)
-        app.register_blueprint(blueprint, url_prefix=f"{url_prefix}/{blueprint.name}")
-    return plugin_names
+from ivoryos.utils.decorators import block, BUILDING_BLOCKS
+from ivoryos.app import app, create_app, socketio, db
+
+__all__ = [
+    "block",
+    "BUILDING_BLOCKS",
+    "OPTIMIZER_REGISTRY",
+    "run",
+    "app",
+    "ivoryos_version",
+    "create_app",
+    "socketio",
+    "global_config",
+    "db"
+]

ivoryos/app.py

@@ -0,0 +1,154 @@
+import os
+import uuid
+
+import bcrypt
+from flask import Flask, session, g, redirect, url_for
+from flask_login import AnonymousUserMixin
+
+from ivoryos.utils import utils
+from ivoryos.utils.db_models import db, User
+from ivoryos.routes.auth.auth import auth, login_manager
+from ivoryos.routes.control.control import control
+from ivoryos.routes.data.data import data
+from ivoryos.routes.library.library import library
+from ivoryos.routes.design.design import design
+from ivoryos.routes.execute.execute import execute
+from ivoryos.socket_handlers import socketio
+from ivoryos.routes.main.main import main
+from ivoryos.version import __version__ as ivoryos_version
+from sqlalchemy import inspect, text
+
+url_prefix = os.getenv('URL_PREFIX', "/ivoryos")
+app = Flask(__name__, static_url_path=f'{url_prefix}/static', static_folder='static')
+app.register_blueprint(main, url_prefix=url_prefix)
+app.register_blueprint(auth, url_prefix=f'{url_prefix}/{auth.name}')
+app.register_blueprint(library, url_prefix=f'{url_prefix}/{library.name}')
+app.register_blueprint(control, url_prefix=f'{url_prefix}/instruments')
+app.register_blueprint(design, url_prefix=f'{url_prefix}')
+app.register_blueprint(execute, url_prefix=f'{url_prefix}')
+app.register_blueprint(data, url_prefix=f'{url_prefix}')
+# app.register_blueprint(api, url_prefix=f'{url_prefix}/{api.name}')
+
+def reset_old_schema(engine, db_dir):
+    inspector = inspect(engine)
+    tables = inspector.get_table_names()
+
+
+    # Check if old tables exist (no workflow_phases table)
+    has_workflow_phase = 'workflow_phases' in tables
+    old_workflow_run = 'workflow_runs' in tables
+    old_workflow_step = 'workflow_steps' in tables
+
+    # v1.3.4 only delete and backup when there is runs but no phases
+    if not has_workflow_phase and old_workflow_run:
+        print("⚠️ Old workflow database detected! All previous workflows have been reset to support the new schema.")
+        # Backup old DB
+        db_path = os.path.join(db_dir, "ivoryos.db")
+        if os.path.exists(db_path):
+            # os.makedirs(backup_dir, exist_ok=True)
+            from datetime import datetime
+            import shutil
+            ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_path = os.path.join(db_dir, f"ivoryos_backup_{ts}.db")
+            shutil.copy(db_path, backup_path)
+            print(f"Backup created at {backup_path}")
+        with engine.begin() as conn:
+            # Drop old tables
+            if old_workflow_step:
+                conn.execute(text("DROP TABLE IF EXISTS workflow_steps"))
+            if old_workflow_run:
+                conn.execute(text("DROP TABLE IF EXISTS workflow_runs"))
+    with engine.begin() as conn:
+        try:
+            conn.execute(
+                text("ALTER TABLE user ADD COLUMN settings TEXT")
+            )
+        except Exception:
+            pass
+
+    # Recreate new schema
+    db.create_all()  # creates workflow_runs, workflow_phases, workflow_steps
+
+
+def create_admin():
+    """
+    Create an admin user with username 'admin' and password 'admin' if it doesn't exist.
+    """
+    with app.app_context():
+        admin_user = User.query.filter_by(username='admin').first()
+        if not admin_user:
+            print("Creating default admin user...")
+            admin_user = User(
+                username='admin',
+                password=bcrypt.hashpw("admin".encode('utf-8'), bcrypt.gensalt()),
+            )
+            db.session.add(admin_user)
+            db.session.commit()
+        else:
+            print("Admin user already exists.")
+
+
+def create_app(config_class=None):
+    """
+    create app, init database
+    """
+
+    app.config.from_object(config_class or 'config.get_config()')
+    os.makedirs(app.config["OUTPUT_FOLDER"], exist_ok=True)
+    # Initialize extensions
+    socketio.init_app(app, cors_allowed_origins="*", cookie=None)
+    login_manager.init_app(app)
+    login_manager.login_view = "auth.login"
+    db.init_app(app)
+
+    # Create database tables
+    with app.app_context():
+        # db.create_all()
+        reset_old_schema(db.engine, app.config['OUTPUT_FOLDER'])
+        create_admin()
+
+    # Additional setup
+    utils.create_gui_dir(app.config['OUTPUT_FOLDER'])
+
+    # logger_list = app.config["LOGGERS"]
+    logger_path = os.path.join(app.config["OUTPUT_FOLDER"], app.config["LOGGERS_PATH"])
+    logger = utils.start_logger(socketio, 'gui_logger', logger_path)
+
+    @app.before_request
+    def before_request():
+        """
+        Called before
+
+        """
+        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():
+        return redirect(url_for('main.index', version=ivoryos_version))  # Assuming 'index' is a route in your blueprint
+
+    @app.template_filter('format_name')
+    def format_name(name):
+        name = name.split(".")[-1]
+        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,191 @@
+# optimizers/ax_optimizer.py
+from typing import Dict
+
+from pandas import DataFrame
+
+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,
+                 parameter_constraints:list=None, datapath=None):
+        self.trial_index_list = 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, parameter_constraints, )
+
+        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),
+            parameter_constraints=parameter_constraints
+        )
+        # 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.adapter 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":
+                # if step is used here, convert to ChoiceParameterConfig
+                if  len(p["bounds"]) == 3:
+                    values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                    ax_params.append(ChoiceParameterConfig(name=p["name"], values=values, parameter_type="int", is_ordered=True))
+                else:
+                    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")
+
+            # # fixing unknown Ax "unsupported operand type(s) for *: 'One' and 'LazyFunction'" in v1.1.2, test is not allowed as objective name
+            if obj_name == "test":
+                raise ValueError("test is not allowed as objective 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(generator=generators.get(step_1_generator), num_trials=step_1.get("num_samples", 5))
+        generator_2 = GenerationStep(generator=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):
+        trials = self.client.get_next_trials(n)
+        trial_index_list = []
+        param_list = []
+        for trial_index, params in trials.items():
+            trial_index_list.append(trial_index)
+            param_list.append(params)
+        self.trial_index_list = trial_index_list
+        return param_list
+
+    def observe(self, results):
+        for trial_index, result in zip(self.trial_index_list, results):
+            obj_only_result = {k: v for k, v in result.items() if k in [obj["name"] for obj in self.objective_config]}
+            self.client.complete_trial(
+                trial_index=trial_index,
+                raw_data=obj_only_result
+            )
+
+    def get_plots(self, plot_type):
+        return None
+
+    @staticmethod
+    def get_schema():
+        return {
+            "parameter_types": ["range", "choice"],
+            "multiple_objectives": True,
+            # "objective_weights": True,
+            "supports_continuous": True,
+            "supports_constraints": 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:DataFrame):
+        """
+        Append existing data to the Ax experiment.
+        :param existing_data: A dictionary containing existing data.
+        """
+
+        if isinstance(existing_data, DataFrame):
+            if existing_data.empty:
+                return
+            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 entry in existing_data:
+            # for name, value in entry.items():
+                # First attach the trial and note the trial index
+            parameters = {name: value for name, value in entry.items() if name in parameter_names}
+            trial_index = self.client.attach_trial(parameters=parameters)
+            raw_data = {name: value for name, value in entry.items() 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())