update tests for new logging system

Author: adrianmolzon

tests/test_bayesian_optimization.py

@@ -10,7 +10,6 @@
 from bayes_opt import BayesianOptimization, acquisition
 from bayes_opt.acquisition import AcquisitionFunction
 from bayes_opt.domain_reduction import SequentialDomainReductionTransformer
-from bayes_opt.event import DEFAULT_EVENTS, Events
 from bayes_opt.exception import NotUniqueError
 from bayes_opt.logger import ScreenLogger
 from bayes_opt.parameter import BayesParameter
@@ -161,38 +160,6 @@ def test_prime_queue_with_register_and_init():
     assert len(optimizer.space) == 1
 
 
-def test_prime_subscriptions():
-    optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    optimizer._prime_subscriptions()
-
-    # Test that the default observer is correctly subscribed
-    for event in DEFAULT_EVENTS:
-        assert all([isinstance(k, ScreenLogger) for k in optimizer._events[event]])
-        assert all([hasattr(k, "update") for k in optimizer._events[event]])
-
-    test_subscriber = "test_subscriber"
-
-    def test_callback(event, instance):
-        pass
-
-    optimizer = BayesianOptimization(target_func, PBOUNDS, random_state=1)
-    optimizer.subscribe(event=Events.OPTIMIZATION_START, subscriber=test_subscriber, callback=test_callback)
-    # Test that the desired observer is subscribed
-    assert all([k == test_subscriber for k in optimizer._events[Events.OPTIMIZATION_START]])
-    assert all([v == test_callback for v in optimizer._events[Events.OPTIMIZATION_START].values()])
-
-    # Check that prime subscriptions won't overwrite manual subscriptions
-    optimizer._prime_subscriptions()
-    assert all([k == test_subscriber for k in optimizer._events[Events.OPTIMIZATION_START]])
-    assert all([v == test_callback for v in optimizer._events[Events.OPTIMIZATION_START].values()])
-
-    assert optimizer._events[Events.OPTIMIZATION_STEP] == {}
-    assert optimizer._events[Events.OPTIMIZATION_END] == {}
-
-    with pytest.raises(KeyError):
-        optimizer._events["other"]
-
-
 def test_set_bounds():
     pbounds = {"p1": (0, 1), "p3": (0, 3), "p2": (0, 2), "p4": (0, 4)}
     optimizer = BayesianOptimization(target_func, pbounds, random_state=1)
@@ -223,56 +190,27 @@ def test_set_gp_params():
 
 
 def test_maximize():
-    class Tracker:
-        def __init__(self):
-            self.start_count = 0
-            self.step_count = 0
-            self.end_count = 0
-
-        def update_start(self, event, instance):
-            self.start_count += 1
-
-        def update_step(self, event, instance):
-            self.step_count += 1
-
-        def update_end(self, event, instance):
-            self.end_count += 1
-
-        def reset(self):
-            self.__init__()
-
     acq = acquisition.UpperConfidenceBound()
     optimizer = BayesianOptimization(
         target_func, PBOUNDS, acq, random_state=np.random.RandomState(1), allow_duplicate_points=True
     )
 
-    tracker = Tracker()
-    optimizer.subscribe(event=Events.OPTIMIZATION_START, subscriber=tracker, callback=tracker.update_start)
-    optimizer.subscribe(event=Events.OPTIMIZATION_STEP, subscriber=tracker, callback=tracker.update_step)
-    optimizer.subscribe(event=Events.OPTIMIZATION_END, subscriber=tracker, callback=tracker.update_end)
-
+    # Test initial maximize with no init_points and n_iter
     optimizer.maximize(init_points=0, n_iter=0)
     assert not optimizer._queue
-    assert len(optimizer.space) == 1
-    assert tracker.start_count == 1
-    assert tracker.step_count == 1
-    assert tracker.end_count == 1
+    assert len(optimizer.space) == 1  # Even with no init_points, we should have at least one point
 
+    # Test after setting GP parameters
     optimizer.set_gp_params(alpha=1e-2)
     optimizer.maximize(init_points=2, n_iter=0)
     assert not optimizer._queue
-    assert len(optimizer.space) == 3
+    assert len(optimizer.space) == 3  # Previously had 1, add 2 more from init_points
     assert optimizer._gp.alpha == 1e-2
-    assert tracker.start_count == 2
-    assert tracker.step_count == 3
-    assert tracker.end_count == 2
 
+    # Test with additional iterations
     optimizer.maximize(init_points=0, n_iter=2)
     assert not optimizer._queue
-    assert len(optimizer.space) == 5
-    assert tracker.start_count == 3
-    assert tracker.step_count == 5
-    assert tracker.end_count == 3
+    assert len(optimizer.space) == 5  # Previously had 3, add 2 more from n_iter
 
 
 def test_define_wrong_transformer():

tests/test_logs.log

@@ -3,98 +3,26 @@
 from pathlib import Path
 
 import numpy as np
-import pytest
-from scipy.optimize import NonlinearConstraint
+from bayes_opt.util import ensure_rng
 
-from bayes_opt import BayesianOptimization
-from bayes_opt.util import load_logs
 
-test_dir = Path(__file__).parent.resolve()
+def test_ensure_rng():
+    """Test that ensure_rng properly handles different inputs."""
 
+    # Test with None (should return a new RandomState)
+    rng1 = ensure_rng(None)
+    assert isinstance(rng1, np.random.RandomState)
 
-def test_logs():
-    def f(x, y):
-        return -(x**2) - (y - 1) ** 2 + 1
+    # Test with int (should return a new RandomState seeded with that int)
+    rng2 = ensure_rng(123)
+    assert isinstance(rng2, np.random.RandomState)
 
-    optimizer = BayesianOptimization(f=f, pbounds={"x": (-200, 200), "y": (-200, 200)})
-    assert len(optimizer.space) == 0
+    # Test with RandomState (should return the same RandomState)
+    rng3 = np.random.RandomState(456)
+    rng4 = ensure_rng(rng3)
+    assert rng3 is rng4
 
-    load_logs(optimizer, [str(test_dir / "test_logs.log")])
-    assert len(optimizer.space) == 5
-
-    load_logs(optimizer, [str(test_dir / "test_logs.log")])
-    assert len(optimizer.space) == 5
-
-    other_optimizer = BayesianOptimization(f=lambda x: -(x**2), pbounds={"x": (-2, 2)})
-    with pytest.raises(ValueError):
-        load_logs(other_optimizer, [str(test_dir / "test_logs.log")])
-
-
-def test_logs_str():
-    def f(x, y):
-        return -(x**2) - (y - 1) ** 2 + 1
-
-    optimizer = BayesianOptimization(f=f, pbounds={"x": (-200, 200), "y": (-200, 200)})
-    assert len(optimizer.space) == 0
-
-    load_logs(optimizer, str(test_dir / "test_logs.log"))
-    assert len(optimizer.space) == 5
-
-
-def test_logs_bounds():
-    def f(x, y):
-        return x + y
-
-    optimizer = BayesianOptimization(f=f, pbounds={"x": (-2, 2), "y": (-2, 2)})
-
-    with pytest.warns(UserWarning):
-        load_logs(optimizer, [str(test_dir / "test_logs_bounds.log")])
-
-    assert len(optimizer.space) == 5
-
-
-def test_logs_constraint():
-    def f(x, y):
-        return -(x**2) - (y - 1) ** 2 + 1
-
-    def c(x, y):
-        return x**2 + y**2
-
-    constraint = NonlinearConstraint(c, -np.inf, 3)
-
-    optimizer = BayesianOptimization(f=f, pbounds={"x": (-200, 200), "y": (-200, 200)}, constraint=constraint)
-
-    with pytest.raises(KeyError):
-        load_logs(optimizer, [str(test_dir / "test_logs.log")])
-
-    load_logs(optimizer, [str(test_dir / "test_logs_constrained.log")])
-
-    assert len(optimizer.space) == 7
-
-
-def test_logs_constraint_new_array():
-    def f(x, y):
-        return -(x**2) - (y - 1) ** 2 + 1
-
-    def c(x, y):
-        return np.array(
-            [-np.cos(x) * np.cos(y) + np.sin(x) * np.sin(y), -np.cos(x) * np.cos(-y) + np.sin(x) * np.sin(-y)]
-        )
-
-    constraint_lower = np.array([-np.inf, -np.inf])
-    constraint_upper = np.array([0.6, 0.6])
-
-    constraint = NonlinearConstraint(c, constraint_lower, constraint_upper)
-
-    optimizer = BayesianOptimization(f=f, pbounds={"x": (-200, 200), "y": (-200, 200)}, constraint=constraint)
-
-    with pytest.raises(KeyError):
-        load_logs(optimizer, [str(test_dir / "test_logs.log")])
-
-    with pytest.raises(ValueError):
-        load_logs(optimizer, [str(test_dir / "test_logs_constrained.log")])
-
-    load_logs(optimizer, [str(test_dir / "test_logs_multiple_constraints.log")])
-
-    print(optimizer.space)
-    assert len(optimizer.space) == 12
+    # Test that different seeds produce different random numbers
+    rng5 = ensure_rng(1)
+    rng6 = ensure_rng(2)
+    assert rng5.random() != rng6.random()