better-optimize 0.3.1__tar.gz → 0.3.2__tar.gz

{better_optimize-0.3.1 → better_optimize-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: better_optimize
-Version: 0.3.1
+Version: 0.3.2
 Summary: A drop-in replacement for scipy optimize functions with quality of life improvements
 License: MIT License
 Project-URL: Homepage, https://github.com/jessegrabowski/better_optimize

{better_optimize-0.3.1 → better_optimize-0.3.2}/better_optimize/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-03-20T00:48:11+0100",
+ "date": "2026-03-20T19:57:42+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "0478ed4b401b74272d06dee5e904e77be2916235",
- "version": "0.3.1"
+ "full-revisionid": "2c8f4f7afbc2b54fa1e8aa8827b4be15e6ea87a9",
+ "version": "0.3.2"
 }
 '''  # END VERSION_JSON
 

{better_optimize-0.3.1 → better_optimize-0.3.2}/better_optimize/basinhopping.py

@@ -1,3 +1,5 @@
+import sys
+
 from collections.abc import Callable, Sequence
 
 import numpy as np
@@ -64,7 +66,7 @@ def initialize_progress_bar(progressbar, use_jac=True, use_hess=False):
         *columns,
         expand=False,
         disable=not progressbar,
-        console=Console(width=CONSOLE_WIDTH),
+        console=Console(file=sys.stderr, width=CONSOLE_WIDTH),
         transient=True,
     )
 

{better_optimize-0.3.1 → better_optimize-0.3.2}/better_optimize/multi_optimize.py

@@ -2,6 +2,7 @@ import contextlib
 import logging
 import multiprocessing as mp
 import pickle
+import sys
 import threading
 
 from collections.abc import Callable
@@ -176,8 +177,22 @@ def _run_single(
         if blas_cores_per_worker is not None
         else contextlib.nullcontext()
     )
-    with limiter:
-        result = solver(x0=x0, progressbar=progress, progress_task=task_id, **solver_kwargs)
+    try:
+        with limiter:
+            result = solver(x0=x0, progressbar=progress, progress_task=task_id, **solver_kwargs)
+    except Exception as exc:
+        _log.warning(
+            "Run %d failed with %s: %s",
+            run_index,
+            type(exc).__name__,
+            exc,
+        )
+        result = OptimizeResult(
+            x=x0,
+            fun=np.inf,
+            success=False,
+            message=f"Solver raised {type(exc).__name__}: {exc}",
+        )
 
     result.run_index = run_index
     result.x0 = x0
@@ -249,7 +264,7 @@ class MultiStartResult:
 
         for rank, res in enumerate(display, 1):
             table.add_row(*self._format_result_row(rank, res))
-        Console().print(table)
+        Console(file=sys.stderr).print(table)
 
     def _result_to_dict(self, rank: int, res: OptimizeResult) -> dict:
         """Convert a single ``OptimizeResult`` into a flat dict for DataFrame export."""

{better_optimize-0.3.1 → better_optimize-0.3.2}/better_optimize/wrapper.py

@@ -1,4 +1,5 @@
 import logging
+import sys
 
 from collections.abc import Callable
 from functools import partial
@@ -61,7 +62,7 @@ def build_progress_bar(
         *columns,
         expand=False,
         disable=not progressbar,
-        console=Console(width=CONSOLE_WIDTH),
+        console=Console(file=sys.stderr, width=CONSOLE_WIDTH),
     )
 
 
@@ -234,20 +235,40 @@ def optimizer_early_stopping_wrapper(f_optim: partial):
                 "prematurely.",
             )
         except Exception as e:
-            raise e
-
-        outputs = objective.step(final_value)
-
-        if not objective.use_jac and not objective.use_hess:
-            value = outputs
-            grad = None
-            hess = None
-        elif objective.use_jac and not objective.use_hess:
-            value, grad = outputs
-            hess = None
-        else:
-            value, grad, hess = outputs
+            # Catch any runtime errors from the optimizer (e.g. nan/inf) and return a failed
+            # result instead of crashing.
+            _log.warning("Optimizer raised %s: %s", type(e).__name__, e)
+            final_value = objective.previous_x
+            x0 = f_optim.keywords.get("x0")
+            if final_value is None:
+                final_value = x0
+            res = OptimizeResult(
+                x=final_value,
+                fun=np.inf,
+                success=False,
+                message=f"Optimizer raised {type(e).__name__}: {e}",
+            )
 
-        objective.update_progressbar(value, grad, hess, completed=True)
+        # Guard against final_value being None (can happen if no finite
+        # iterate was ever recorded and no x0 was available).
+        if final_value is not None:
+            try:
+                outputs = objective.step(final_value)
+
+                if not objective.use_jac and not objective.use_hess:
+                    value = outputs
+                    grad = None
+                    hess = None
+                elif objective.use_jac and not objective.use_hess:
+                    value, grad = outputs
+                    hess = None
+                else:
+                    value, grad, hess = outputs
+
+                objective.update_progressbar(value, grad, hess, completed=True)
+            except Exception:
+                # If the final evaluation itself fails (e.g. NaN inputs),
+                # just mark the progress bar as complete.
+                _log.debug("Final evaluation failed; skipping progress-bar update.", exc_info=True)
 
     return res

{better_optimize-0.3.1 → better_optimize-0.3.2}/better_optimize.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: better_optimize
-Version: 0.3.1
+Version: 0.3.2
 Summary: A drop-in replacement for scipy optimize functions with quality of life improvements
 License: MIT License
 Project-URL: Homepage, https://github.com/jessegrabowski/better_optimize

{better_optimize-0.3.1 → better_optimize-0.3.2}/tests/test_multistart.py

@@ -263,19 +263,27 @@ def test_run_single_attaches_metadata():
     assert_allclose(result.x0, x0)
 
 
-def test_run_single_propagates_solver_exception():
+def test_run_single_catches_solver_exception():
+    """Solver exceptions are caught and returned as failed OptimizeResults."""
+
     def exploding_solver(x0, **kwargs):
-        raise RuntimeError("solver exploded")
-
-    with pytest.raises(RuntimeError, match="solver exploded"):
-        _run_single(
-            run_index=0,
-            x0=np.zeros(2),
-            solver=exploding_solver,
-            solver_kwargs={},
-            progress=MagicMock(),
-            task_id=0,
-        )
+        raise RuntimeError("NaN encountered")
+
+    x0 = np.array([1.0, 2.0])
+    result = _run_single(
+        run_index=3,
+        x0=x0,
+        solver=exploding_solver,
+        solver_kwargs={},
+        progress=MagicMock(),
+        task_id=0,
+    )
+    assert not result.success
+    assert result.fun == np.inf
+    assert "RuntimeError" in result.message
+    assert result.run_index == 3
+    assert_allclose(result.x0, x0)
+    assert_allclose(result.x, x0)
 
 
 class TestMultiStartResult:
@@ -431,3 +439,34 @@ def test_multistart_pickle_fallback(caplog):
     # Fallback may or may not trigger depending on environment,
     # but either way we must get valid results.
     assert len(result.results) == 2
+
+
+def test_multistart_survives_crashing_solver():
+    """A solver that raises for some starting points should not kill the campaign."""
+    call_count = 0
+
+    def sometimes_exploding_solver(x0, **kwargs):
+        nonlocal call_count
+        call_count += 1
+        if call_count % 2 == 0:
+            raise RuntimeError("NaN in trust region subproblem")
+        return OptimizeResult(x=x0, fun=float(np.sum(x0**2)), success=True)
+
+    x0_list = [np.ones(2) * i for i in range(4)]
+    result = multi_optimize(
+        solver=sometimes_exploding_solver,
+        x0=x0_list,
+        backend="sequential",
+        progressbar=False,
+        blas_cores=None,
+    )
+
+    assert len(result.results) == 4
+    n_success = sum(r.success for r in result.results)
+    n_failed = sum(not r.success for r in result.results)
+    assert n_success == 2
+    assert n_failed == 2
+    for r in result.results:
+        if not r.success:
+            assert r.fun == np.inf
+            assert "RuntimeError" in r.message

{better_optimize-0.3.1 → better_optimize-0.3.2}/tests/test_wrapper.py

@@ -43,7 +43,8 @@ def test_early_return_from_keyboard_interrupt(root, method):
 
 
 @pytest.mark.parametrize("root", [True, False], ids=["root", "minimize"])
-def test_execption_breaks_optimization(root, monkeypatch):
+def test_exception_returns_failed_result(root, monkeypatch):
+    """Exceptions raised inside the optimizer should be caught and returned as a failed result."""
     N_EXEC = 0
 
     def f(x: np.ndarray):
@@ -64,9 +65,9 @@ def test_execption_breaks_optimization(root, monkeypatch):
         callback=objective.callback,
     )
 
-    # Non-KeyboardInterrupt exceptions should break execution.
-    with pytest.raises(Exception, match="Simulated error"):
-        optimizer_early_stopping_wrapper(f_optim)
+    result = optimizer_early_stopping_wrapper(f_optim)
+    assert not result.success
+    assert "Simulated error" in result.message
 
 
 def func2(x, a, b):