Update & rework dependencies

Author: thopkins32

.github/workflows/_testing.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       matrix:
         host-os: ["ubuntu-latest"]
-        python-version: ["py310-cpu", "py311-cpu", "py312-cpu", "py313-cpu"]
+        python-version: ["py311-cpu", "py312-cpu", "py313-cpu"]
       fail-fast: false
 
     defaults:

pixi.toml

@@ -6,10 +6,10 @@ authors = [
 channels = ["conda-forge"]
 name = "blop"
 platforms = ["linux-64", "osx-arm64"]
-version = "0.9.0"
+version = "1.0.0b1"
 
 [dependencies]
-python = ">=3.10.0,<3.14"
+python = ">=3.11.0,<3.14"
 
 [feature.dev.dependencies]
 
@@ -32,7 +32,7 @@ tests = "pytest src/blop/tests"
 graphviz = ">=14.1.2,<15"
 
 [feature.docs.pypi-dependencies]
-blop = { path = ".", editable = true, extras = ["cpu"] }
+blop = { path = ".", editable = true, extras = ["cpu", "ax", "qs"] }
 blop-sim = { path = "sim", editable = true }
 numpydoc = "*"
 sphinx-copybutton = "*"
@@ -46,9 +46,6 @@ bluesky-tiled-plugins = "*"
 ophyd-async = "*"
 opencv-python = "*"
 
-[feature.py310.dependencies]
-python = "3.10.*"
-
 [feature.py311.dependencies]
 python = "3.11.*"
 
@@ -58,10 +55,6 @@ python = "3.12.*"
 [feature.py313.dependencies]
 python = "3.13.*"
 
-[feature.dev.tasks]
-check = "pre-commit run --all-files"
-tests = "pytest src/blop/tests"
-
 [feature.docs.tasks]
 start-queueserver = "docker compose -f docs/source/tutorials/queueserver/docker-compose.yml up -d --build --wait"
 stop-queueserver = "docker compose -f docs/source/tutorials/queueserver/docker-compose.yml down"
@@ -78,7 +71,6 @@ convert-tutorials-to-ipynb = "jupytext --to notebook docs/source/tutorials/*.md"
 dev = ["dev"]
 dev-cpu = ["dev-cpu"]
 docs = ["docs"]
-py310-cpu = ["dev-cpu", "py310"]
 py311-cpu = ["dev-cpu", "py311"]
 py312-cpu = ["dev-cpu", "py312"]
 py313-cpu = ["dev-cpu", "py313"]

pyproject.toml

@@ -20,19 +20,8 @@ maintainers = [
   { name = "Jennefer Maldonado", email = "jmaldonad@bnl.gov" },
   { name = "Roman Chernikov", email = "rcherniko@bnl.gov" },
 ]
-requires-python = ">=3.10"
-dependencies = [
-  "ax-platform>=1.1.0,<1.3",
-  "bluesky>=1.14.2",
-  "bluesky-queueserver-api>=0.0.12",
-  "torch",
-  "botorch>=0.16.0",
-  "gpytorch",
-  "scipy",
-  "networkx>=3",
-  "numpy",
-  "rich>=13",
-]
+requires-python = ">=3.11"
+dependencies = ["bluesky>=1.14.2", "networkx>=3", "numpy", "rich>=13"]
 classifiers = [
   "Development Status :: 4 - Beta",
   "License :: OSI Approved :: BSD License",
@@ -45,6 +34,7 @@ classifiers = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
+ax = ["ax-platform>=1.3.0,<1.4", "botorch>=0.18.0,<0.19.0", "gpytorch", "torch"]
 qs = ["bluesky-queueserver-api"]
 dev = [
   "pytest",
@@ -53,10 +43,9 @@ dev = [
   "ruff",
   "nbstripout",
   "pre-commit",
-  "pandas-stubs",
   "coverage",
   "pyright",
-  "blop[qs]",
+  "blop[ax,qs]",
 ]
 cpu = [
   # Empty extra - the source configuration below routes to CPU-only index

sim/pyproject.toml

@@ -8,7 +8,7 @@ version = "0.0.0"
 description = "Example simulations and benchmarks for blop (not published to PyPI)"
 readme = "README.md"
 authors = [{ name = "Thomas Hopkins", email = "thopkins1@bnl.gov" }]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
   "blop",
   "ophyd-async",

src/blop/__init__.py

@@ -1,4 +1,3 @@
-from .ax import DOF, Agent, ChoiceDOF, DOFConstraint, Objective, OutcomeConstraint, RangeDOF, ScalarizedObjective
 from .plans import acquire_baseline, default_acquire, optimize, optimize_step, sample_suggestions
 
 try:
@@ -8,14 +7,6 @@
 
 __all__ = [
     "__version__",
-    "Agent",
-    "ChoiceDOF",
-    "DOF",
-    "DOFConstraint",
-    "Objective",
-    "OutcomeConstraint",
-    "RangeDOF",
-    "ScalarizedObjective",
     "acquire_baseline",
     "default_acquire",
     "optimize",

src/blop/ax/__init__.py

@@ -1,13 +1,13 @@
-from ..queueserver import OptimizationResult
-from .agent import Agent as Agent
-from .agent import QueueserverAgent as QueueserverAgent
-from .dof import DOF, ChoiceDOF, DOFConstraint, RangeDOF
-from .objective import Objective, OutcomeConstraint, ScalarizedObjective, to_ax_objective_str
-from .optimizer import AxOptimizer
+try:
+    from .agent import Agent as Agent
+    from .dof import DOF, ChoiceDOF, DOFConstraint, RangeDOF
+    from .objective import Objective, OutcomeConstraint, ScalarizedObjective, to_ax_objective_str
+    from .optimizer import AxOptimizer
+except ImportError as e:
+    raise ImportError("The ax integration requires additional dependencies. Install them with: pip install blop[ax]") from e
 
 __all__ = [
     "Agent",
-    "QueueserverAgent",
     "DOF",
     "RangeDOF",
     "ChoiceDOF",
@@ -17,5 +17,4 @@
     "ScalarizedObjective",
     "to_ax_objective_str",
     "AxOptimizer",
-    "OptimizationResult",
 ]

src/blop/ax/agent.py

@@ -1,25 +1,14 @@
-import importlib.util
 import logging
 from collections.abc import Mapping, Sequence
-from concurrent.futures import Future
 from typing import Any, cast
 
+import bluesky.preprocessors as bpp
 from ax import Client, TOutcome, TParameterization
 from ax.analysis.plotly.surface.contour import ContourPlot
+from ax.core.analysis_card import AnalysisCardBase
 from ax.core.types import TParamValue
-
-# ===============================
-# TODO: Remove when Python 3.10 is no longer supported
-if importlib.util.find_spec("ax.core.analysis_card") is not None:
-    from ax.core.analysis_card import AnalysisCardBase
-else:
-    from ax.analysis.analysis_card import AnalysisCardBase  # type: ignore[import-untyped]
-# ===============================
-import bluesky.preprocessors as bpp
 from bluesky.callbacks import CallbackBase
-from bluesky.callbacks.zmq import RemoteDispatcher
 from bluesky.utils import MsgGenerator
-from bluesky_queueserver_api.zmq import REManagerAPI
 
 from ..callbacks.logger import OptimizationLogger
 from ..callbacks.router import OptimizationCallbackRouter
@@ -30,10 +19,8 @@
     Actuator,
     EvaluationFunction,
     OptimizationProblem,
-    QueueserverOptimizationProblem,
     Sensor,
 )
-from ..queueserver import OptimizationResult, QueueserverClient, QueueserverOptimizationRunner
 from ..utils import InferredReadable
 from .dof import DOF, DOFConstraint
 from .objective import Objective, OutcomeConstraint, ScalarizedObjective, to_ax_objective_str
@@ -561,182 +548,3 @@ def navigate_to_best(self, parameterization: Mapping | None = None) -> MsgGenera
                 parameterization,
             )
         )
-
-
-class QueueserverAgent(_AxAgentMixin):
-    """
-    An asynchronous interface that uses Ax as the backend for optimization and experiment tracking
-    and the bluesky-queueserver-api for scheduling plan execution.
-
-    .. warning::
-
-        This class is **experimental**. The API is not yet stable and may change
-        in future releases without a deprecation period. It is not recommended for
-        production use.
-
-    Parameters
-    ----------
-    re_manager_api : REManagerAPI
-        The manager API for interaction with Bluesky queueserver.
-    document_dispatcher : RemoteDispatcher
-        Dispatcher for consuming Bluesky documents from the remote server.
-    sensors : Sequence[str]
-        The sensors to use for acquisition. These should be the minimal set
-        of sensors that are needed to compute the objectives.
-    dofs : Sequence[DOF]
-        The degrees of freedom that the agent can control, which determine the search space.
-    objectives : Sequence[Objective]
-        The objectives which the agent will try to optimize.
-    evaluation_function : EvaluationFunction
-        The function to evaluate acquired data and produce outcomes.
-    acquisition_plan : str | None, optional
-        The acquisition plan to use for acquiring data from the beamline. If not provided,
-        :func:`blop.plans.default_acquire` will be assumed.
-    dof_constraints : Sequence[DOFConstraint] | None, optional
-        Constraints on DOFs to refine the search space.
-    outcome_constraints : Sequence[OutcomeConstraint] | None, optional
-        Constraints on outcomes to be satisfied during optimization.
-    checkpoint_path : str | None, optional
-        The path to the checkpoint file to save the optimizer's state to.
-    **kwargs : Any
-        Additional keyword arguments to configure the Ax experiment.
-
-    See Also
-    --------
-    blop.protocols.Sensor : The protocol for sensors.
-    blop.ax.dof.RangeDOF : For continuous parameters.
-    blop.ax.dof.ChoiceDOF : For discrete parameters.
-    blop.ax.objective.Objective : For defining objectives.
-    blop.ax.optimizer.AxOptimizer : The optimizer used internally.
-    blop.queueserver.QueueserverOptimizatonRunner : Runner that handles interaction with bluesky-queueserver.
-    """
-
-    def __init__(
-        self,
-        re_manager_api: REManagerAPI,
-        document_dispatcher: RemoteDispatcher,
-        sensors: Sequence[str],
-        dofs: Sequence[DOF],
-        objectives: Sequence[Objective],
-        evaluation_function: EvaluationFunction,
-        acquisition_plan: str | None = None,
-        dof_constraints: Sequence[DOFConstraint] | None = None,
-        outcome_constraints: Sequence[OutcomeConstraint] | None = None,
-        checkpoint_path: str | None = None,
-        acquisition_plan_kwargs: Mapping[str, Any] | None = None,
-        **kwargs: Any,
-    ):
-        self._sensors = sensors
-        self._actuators: Sequence[str] = []
-        for dof in dofs:
-            if dof.actuator is not None:
-                if isinstance(dof.actuator, Actuator):
-                    self._actuators.append(dof.actuator.name)
-                else:
-                    self._actuators.append(dof.actuator)
-        self._evaluation_function = evaluation_function
-        self._acquisition_plan = acquisition_plan
-        self._acquisition_plan_kwargs = acquisition_plan_kwargs or {}
-        self._optimizer = AxOptimizer(
-            parameters=[dof.to_ax_parameter_config() for dof in dofs],
-            objective=to_ax_objective_str(objectives),
-            parameter_constraints=[constraint.ax_constraint for constraint in dof_constraints] if dof_constraints else None,
-            outcome_constraints=[constraint.ax_constraint for constraint in outcome_constraints]
-            if outcome_constraints
-            else None,
-            checkpoint_path=checkpoint_path,
-            **kwargs,
-        )
-        self._runner = QueueserverOptimizationRunner(
-            self.to_optimization_problem(),
-            QueueserverClient(re_manager_api, document_dispatcher),
-        )
-
-    @property
-    def evaluation_function(self) -> EvaluationFunction:
-        return self._evaluation_function
-
-    @property
-    def actuators(self) -> Sequence[str]:
-        return self._actuators
-
-    @property
-    def sensors(self) -> Sequence[str]:
-        return self._sensors
-
-    @property
-    def acquisition_plan(self) -> str | None:
-        return self._acquisition_plan
-
-    def stop(self) -> None:
-        self._runner.stop()
-
-    @property
-    def current_iteration(self) -> int:
-        return self._runner.current_iteration
-
-    def to_optimization_problem(self) -> QueueserverOptimizationProblem:
-        return QueueserverOptimizationProblem(
-            optimizer=self._optimizer,
-            actuators=self._actuators,
-            sensors=self._sensors,
-            evaluation_function=self._evaluation_function,
-            acquisition_plan=self._acquisition_plan,
-            acquisition_plan_kwargs=self._acquisition_plan_kwargs,
-        )
-
-    def run(self, iterations: int = 1, n_points: int = 1) -> Future[OptimizationResult]:
-        """
-        Start the optimization loop.
-
-        Validates the queueserver state, then begins the suggest -> acquire -> ingest
-        cycle. This method returns immediately; the optimization runs asynchronously
-        via callbacks.
-
-        Parameters
-        ----------
-        iterations : int
-            Number of optimization iterations to run.
-        n_points : int
-            Number of points to suggest per iteration.
-
-        Returns
-        -------
-        concurrent.futures.Future[OptimizationResult]
-            A future that resolves to an :class:`~blop.queueserver.OptimizationResult`
-            when all iterations complete or when :meth:`stop` is called. If an
-            unhandled exception occurs the future will hold it and re-raise on
-            ``.result()``.
-
-        Raises
-        ------
-        RuntimeError
-            If the queueserver environment is not ready.
-        ValueError
-            If required devices or plans are not available.
-        """
-        return self._runner.run(iterations, n_points)
-
-    def submit_suggestions(self, suggestions: list[dict]) -> Future[OptimizationResult]:
-        """
-        Evaluate specific parameter combinations.
-
-        Acquires data for given suggestions and ingests results. Supports both
-        optimizer suggestions and manual points.
-
-        Parameters
-        ----------
-        suggestions : list[dict]
-            Either optimizer suggestions (with "_id") or manual points (without "_id").
-
-        Returns
-        -------
-        concurrent.futures.Future[OptimizationResult]
-            A future that resolves to an :class:`~blop.queueserver.OptimizationResult`
-            when the acquisition completes.
-
-        See Also
-        --------
-        run : Run the full optimization loop.
-        """
-        return self._runner.submit_suggestions(suggestions)