openrunner-sdk 2.17.4__tar.gz → 2.18.0__tar.gz

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 2.17.4
+Version: 2.18.0
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/openrunner/__init__.py

@@ -120,7 +120,7 @@ launch.from_run = _launch_from_run  # type: ignore[attr-defined]
 # openrunner.trace.patch_openai() syntax
 trace.patch_openai = _patch_openai  # type: ignore[attr-defined]
 
-__version__ = "2.17.4"
+__version__ = "2.18.0"
 
 logger = logging.getLogger("openrunner")
 

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/openrunner/cli.py

@@ -124,11 +124,12 @@ def login(host: str | None, expiry: int, manual: bool) -> None:
         base_url = host
     elif settings.get("base_url"):
         base_url = settings["base_url"]
-    elif sys.stdin.isatty():
-        base_url = click.prompt("Server URL")
     else:
-        click.echo("Error: No server URL configured. Run with --host or set base_url in ~/.openrunner/settings.json")
-        return
+        try:
+            base_url = click.prompt("Server URL", default="http://localhost:8000")
+        except (EOFError, click.Abort):
+            click.echo("Error: No server URL configured. Run with --host or set base_url in ~/.openrunner/settings.json")
+            return
 
     if manual:
         # Legacy manual flow

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/openrunner/install_commands.py

@@ -468,6 +468,316 @@ Report version and installed commands to user. Remind them to enable the MCP plu
 """
 
 
+PLOT_SESSION_RUN_CMD = """---
+name: {prefix}plot-session-run
+description: Plot training metrics from runs in current project (ASCII chart + table, PNG on desktop)
+argument-hint: "[run_id] [--metric key] [--all] [--watch [secs]]"
+allowed-tools:
+  - Bash
+  - Read
+---
+
+Plot training run metrics from the current OpenRunner project as ASCII sparklines and summary table.
+If on a desktop with display, also generates a PNG chart.
+
+Use `--watch` (or `-w`) for live refresh every 2 minutes (override: `--watch 30` for 30s).
+Auto-stops when no runs are in progress.
+
+## Process
+
+### Step 1: Fetch runs and metrics
+
+```bash
+python3 -c "
+import sys, os, json
+from pathlib import Path
+for p in ([os.path.join(d, 'site-packages') for d in __import__('glob').glob(os.path.expanduser('~/.local/lib/python3.*/')) + __import__('glob').glob(os.path.expanduser('~/Library/Python/3.*/lib/python/'))]):
+    if os.path.isdir(p): sys.path.insert(0, p)
+
+from openrunner.session import get_session_config
+from openrunner.api_client import APIClient
+
+config = get_session_config()
+if not config.get('api_key'):
+    print('NOT_CONFIGURED')
+    sys.exit(1)
+
+client = APIClient(base_url=config['base_url'], api_key=config['api_key'])
+
+# Resolve project
+project_name = config.get('project', '')
+project_id = None
+for p in client.list_projects():
+    if f'{{p.get(\"org_name\",\"\")}}/{{p.get(\"name\",\"\")}}' == project_name or p.get('name') == project_name:
+        project_id = p.get('id')
+        break
+
+if not project_id:
+    print(f'PROJECT_NOT_FOUND={{project_name}}')
+    client.close()
+    sys.exit(1)
+
+args = '$ARGUMENTS'.strip()
+run_id = None
+metric_keys = ['train/loss', 'learning_rate']
+show_all = False
+watch_mode = False
+watch_interval = 120
+
+# Parse args
+parts = args.split() if args else []
+i = 0
+while i < len(parts):
+    if parts[i] == '--metric' and i+1 < len(parts):
+        metric_keys = [parts[i+1]]; i += 2
+    elif parts[i] == '--all':
+        show_all = True; i += 1
+    elif parts[i] == '--watch' or parts[i] == '-w':
+        watch_mode = True
+        if i+1 < len(parts) and parts[i+1].isdigit():
+            watch_interval = int(parts[i+1]); i += 2
+        else:
+            i += 1
+    elif not parts[i].startswith('--'):
+        run_id = parts[i]; i += 1
+    else:
+        i += 1
+
+import time as _time
+
+iteration = 0
+while True:
+    iteration += 1
+
+    # Clear screen on refresh (not first run)
+    if iteration > 1:
+        print('\\033[2J\\033[H', end='')
+
+    # Get runs
+    if run_id:
+        runs = [{{'id': run_id}}]
+    else:
+        resp = client._request('get', f'/projects/{{project_id}}/runs', params={{'limit': 10, 'order': 'desc'}})
+        runs_data = resp.json()
+        runs = runs_data.get('runs', runs_data) if isinstance(runs_data, dict) else runs_data
+        if not runs:
+            print('NO_RUNS')
+            client.close()
+            sys.exit(1)
+
+# Collect metrics
+bars = '▁▂▃▄▅▆▇█'
+results = []
+
+for run in runs[:10]:
+    rid = run.get('id', run) if isinstance(run, dict) else run
+    try:
+        keys_param = ','.join(metric_keys)
+        resp = client._request('get', f'/runs/{{rid}}/metrics', params={{'keys': keys_param}})
+        data = resp.json()
+        metrics = data.get('metrics', {{}})
+        if not metrics and not show_all:
+            continue
+
+        # If none of the requested metrics found, use whatever is available
+        found_any = any(k in metrics for k in metric_keys)
+        if not found_any and metrics and not show_all:
+            metric_keys = list(metrics.keys())[:2]
+
+        for key, points in metrics.items():
+            if not show_all and key not in metric_keys:
+                continue
+            if not points:
+                continue
+
+            values = [pt.get('value', pt) if isinstance(pt, dict) else pt for pt in points]
+            steps = [pt.get('step', i) if isinstance(pt, dict) else i for i, pt in enumerate(points)]
+            values = [v for v in values if isinstance(v, (int, float))]
+            if not values:
+                continue
+
+            min_v = min(values)
+            max_v = max(values)
+            range_v = max_v - min_v or 1
+            width = 60
+
+            # Sample if too many
+            if len(values) > width:
+                step_size = len(values) / width
+                sampled = [values[int(j * step_size)] for j in range(width)]
+            else:
+                sampled = values
+
+            sparkline = ''
+            for v in sampled:
+                idx = int((v - min_v) / range_v * (len(bars) - 1))
+                sparkline += bars[idx]
+
+            run_name = run.get('display_name') or run.get('name') or rid[:8] if isinstance(run, dict) else rid[:8]
+            run_state = run.get('state', 'unknown') if isinstance(run, dict) else 'unknown'
+            direction = 'rising' if values[-1] > values[0] else 'falling'
+            pct = ((values[-1] - values[0]) / (values[0] or 1)) * 100
+
+            results.append({{
+                'run_id': rid,
+                'run_name': run_name,
+                'metric': key,
+                'sparkline': sparkline,
+                'min': min_v,
+                'max': max_v,
+                'latest': values[-1],
+                'steps': len(values),
+                'step_range': f'{{steps[0]}}->{{steps[-1]}}',
+                'direction': direction,
+                'pct': pct,
+                'state': run_state,
+            }})
+    except Exception as e:
+        results.append({{'run_id': rid, 'error': str(e)}})
+
+if not results:
+    print('NO_METRICS')
+    client.close()
+    sys.exit(1)
+
+# ASCII output
+print('=' * 72)
+print(f' OPENRUNNER METRICS — {{project_name}}')
+print('=' * 72)
+
+for r in results:
+    if 'error' in r:
+        print(f'  {{r[\"run_id\"][:8]}} — error: {{r[\"error\"]}}')
+        continue
+    print()
+    print(f'  Run: {{r[\"run_name\"]}} ({{r[\"run_id\"][:8]}})')
+    print(f'  Metric: {{r[\"metric\"]}} | Steps: {{r[\"step_range\"]}} ({{r[\"steps\"]}} pts)')
+    print('  Range: %.6f -> %.6f | Latest: %.6f' % (r['min'], r['max'], r['latest']))
+    print('  ' + r['sparkline'])
+    arrow = '↗' if r['pct'] > 0 else '↘'
+    print('  %s %s (%+.1f%%)' % (arrow, r['direction'], r['pct']))
+
+# Summary table
+print()
+print('-' * 72)
+print(' %-20s %-15s %10s %10s %10s %8s' % ('Run', 'Metric', 'Latest', 'Min', 'Max', 'Trend'))
+print('-' * 72)
+for r in results:
+    if 'error' in r:
+        continue
+    name = (r['run_name'] or '')[:20]
+    met = r['metric'][:15]
+    arrow = '↗' if r['pct'] > 0 else '↘'
+    trend = '%s%+.0f%%' % (arrow, r['pct'])
+    print(' %-20s %-15s %10.4f %10.4f %10.4f %8s' % (name, met, r['latest'], r['min'], r['max'], trend))
+print('-' * 72)
+
+# Live runs footer — show link + loss indicator for in-progress runs
+base_url = config.get('base_url', '').rstrip('/')
+live_runs = [r for r in results if r.get('state') in ('running', 'in_progress') and 'error' not in r]
+if live_runs:
+    print()
+    print('=' * 72)
+    print(' LIVE RUNS')
+    print('=' * 72)
+    seen_ids = set()
+    for r in live_runs:
+        if r['run_id'] in seen_ids:
+            continue
+        seen_ids.add(r['run_id'])
+        # Loss indicator
+        loss_metrics = [x for x in live_runs if x['run_id'] == r['run_id'] and 'loss' in x['metric'].lower()]
+        lr_metrics = [x for x in live_runs if x['run_id'] == r['run_id'] and 'lr' in x['metric'].lower() or 'learning' in x['metric'].lower()]
+        indicator = ''
+        if loss_metrics:
+            lm = loss_metrics[0]
+            arrow = '↘' if lm['pct'] < 0 else '↗'
+            indicator += ' loss: %.4f %s' % (lm['latest'], arrow)
+        if lr_metrics:
+            lrm = lr_metrics[0]
+            indicator += ' | lr: %.2e' % lrm['latest']
+        run_url = '%s/%s/runs/%s' % (base_url, project_name, r['run_id'])
+        print()
+        print('  %s %s' % (r['run_name'], indicator))
+        # Compact sparkline for loss
+        if loss_metrics:
+            print('  %s' % loss_metrics[0]['sparkline'])
+        print('  -> %s' % run_url)
+    print()
+    print('=' * 72)
+
+    # Watch mode: loop or exit
+    if not watch_mode:
+        break
+    if not live_runs:
+        print('\\nAll runs finished. Exiting watch mode.')
+        break
+    print('\\n  Refreshing in %ds... (Ctrl+C to stop)' % watch_interval)
+    try:
+        _time.sleep(watch_interval)
+    except KeyboardInterrupt:
+        print('\\nWatch stopped.')
+        break
+
+# PNG generation if display available
+has_display = os.environ.get('DISPLAY') or os.environ.get('WAYLAND_DISPLAY') or sys.platform == 'darwin'
+if has_display:
+    try:
+        import matplotlib
+        matplotlib.use('Agg')
+        import matplotlib.pyplot as plt
+        import tempfile
+
+        fig, axes = plt.subplots(len([r for r in results if 'error' not in r]), 1,
+                                  figsize=(12, 3 * len([r for r in results if 'error' not in r])),
+                                  squeeze=False)
+        fig.suptitle(f'OpenRunner Metrics — {{project_name}}', fontsize=14, fontweight='bold')
+
+        plot_idx = 0
+        for r in results:
+            if 'error' in r:
+                continue
+            # Re-fetch values for plot
+            resp2 = client._request('get', f'/runs/{{r[\"run_id\"]}}/metrics', params={{'keys': r[\"metric\"]}})
+            pts = resp2.json().get('metrics', {{}}).get(r['metric'], [])
+            vals = [pt.get('value', pt) if isinstance(pt, dict) else pt for pt in pts]
+            stp = [pt.get('step', i) if isinstance(pt, dict) else i for i, pt in enumerate(pts)]
+            vals = [v for v in vals if isinstance(v, (int, float))]
+            stp = stp[:len(vals)]
+
+            ax = axes[plot_idx][0]
+            ax.plot(stp, vals, linewidth=1.5, color='#2196F3')
+            ax.fill_between(stp, vals, alpha=0.1, color='#2196F3')
+            ax.set_title(f'{{r[\"run_name\"]}} — {{r[\"metric\"]}}', fontsize=11)
+            ax.set_xlabel('Step')
+            ax.set_ylabel(r['metric'])
+            ax.grid(True, alpha=0.3)
+            plot_idx += 1
+
+        plt.tight_layout()
+        png_path = Path(tempfile.gettempdir()) / 'openrunner_metrics.png'
+        fig.savefig(png_path, dpi=150, bbox_inches='tight')
+        plt.close(fig)
+        print(f'\\nPNG_SAVED={{png_path}}')
+    except ImportError:
+        print('\\nPNG_SKIP=matplotlib not installed (pip install matplotlib)')
+    except Exception as e:
+        print(f'\\nPNG_ERROR={{e}}')
+
+client.close()
+print('\\nDONE')
+"
+```
+
+### Step 2: Present results
+
+Show the ASCII chart and table to the user. If a PNG was generated, mention its path so they can open it.
+
+If NOT_CONFIGURED: tell user to run `/openrunner:setup` first.
+If NO_RUNS: tell user no training runs found in project.
+If NO_METRICS: tell user runs exist but no metrics logged yet.
+"""
+
 MCP_CMD = """---
 name: {prefix}mcp
 description: Register OpenRunner MCP server for native tool access
@@ -535,6 +845,7 @@ def install_claude_code() -> list[str]:
         "code-upload.md": CODE_UPLOAD_CMD,
         "update.md": UPDATE_CMD,
         "mcp.md": MCP_CMD,
+        "plot-session-run.md": PLOT_SESSION_RUN_CMD,
     }
 
     files = []
@@ -555,6 +866,10 @@ When the user asks about training metrics, loss charts, run data, or experiment
 
 Do NOT parse log files or grep for metrics when OpenRunner MCP tools are available.
 
+When the user asks to plot or visualize run metrics in this session:
+- Use `/openrunner:plot-session-run` for full ASCII charts + table + PNG
+- Supports: `/openrunner:plot-session-run [run_id] [--metric key] [--all]`
+
 When the user asks about papers, research, or sessions:
 - Use `mcp__openrunner__openrunner_search_papers` for paper content
 - Use `mcp__openrunner__openrunner_search_research` for research plans
@@ -597,6 +912,7 @@ def _install_all_commands_to_dir(cmd_dir: Path, prefix: str = "openrunner:") ->
         "code-upload.md": CODE_UPLOAD_CMD,
         "update.md": UPDATE_CMD,
         "mcp.md": MCP_CMD,
+        "plot-session-run.md": PLOT_SESSION_RUN_CMD,
     }
 
     files = []

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openrunner-sdk"
-version = "2.17.4"
+version = "2.18.0"
 description = "OpenRunner SDK - W&B-compatible ML experiment tracking client"
 readme = "README.md"
 license = {text = "MIT"}

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/conftest.py

@@ -68,6 +68,40 @@ def temp_git_repo(tmp_path: Path) -> Generator[Path, None, None]:
     yield repo_dir
 
 
+@pytest.fixture
+def block_import(monkeypatch: pytest.MonkeyPatch):
+    """Return a helper that blocks a module from being imported.
+
+    Usage:
+        def test_foo(block_import):
+            block_import("torch")
+            with pytest.raises(ImportError):
+                import openrunner.integration.pytorch
+    """
+    import builtins
+    import sys
+
+    real_import = builtins.__import__
+    blocked: set[str] = set()
+
+    def mock_import(name, *args, **kwargs):
+        for pkg in blocked:
+            if name == pkg or name.startswith(pkg + "."):
+                raise ImportError(f"No module named '{name}'")
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", mock_import)
+
+    def _block(module_name: str):
+        blocked.add(module_name)
+        # Remove from sys.modules
+        to_remove = [k for k in sys.modules if k == module_name or k.startswith(module_name + ".")]
+        for k in to_remove:
+            monkeypatch.delitem(sys.modules, k, raising=False)
+
+    return _block
+
+
 @pytest.fixture
 def mock_http_transport() -> MagicMock:
     """Create a mock HTTP transport for testing API client without real network calls."""

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_cli.py

@@ -39,8 +39,8 @@ class TestLogin:
     def test_login_stores_settings(self, runner, settings_dir):
         result = runner.invoke(
             main,
-            ["login"],
-            input="my-api-key\nhttp://myserver:8000\n",
+            ["login", "--manual"],
+            input="http://myserver:8000\nmy-api-key\n",
         )
         assert result.exit_code == 0
         assert "Login successful" in result.output
@@ -54,8 +54,8 @@ class TestLogin:
     def test_login_uses_default_url(self, runner, settings_dir):
         result = runner.invoke(
             main,
-            ["login"],
-            input="my-api-key\n\n",  # empty input = default
+            ["login", "--manual"],
+            input="\nmy-api-key\n",  # empty input = default URL
         )
         assert result.exit_code == 0
         settings = json.loads(
@@ -70,15 +70,15 @@ class TestLogin:
         )
         result = runner.invoke(
             main,
-            ["login"],
-            input="new-key\nhttp://new:8000\n",
+            ["login", "--manual"],
+            input="new-key\n",
         )
         assert result.exit_code == 0
         settings = json.loads(
             (settings_dir / "settings.json").read_text()
         )
         assert settings["api_key"] == "new-key"
-        assert settings["base_url"] == "http://new:8000"
+        assert settings["base_url"] == "http://old:8000"
 
 
 class TestSyncAll:

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_fastai.py

@@ -163,10 +163,9 @@ class TestOpenRunnerFastAICallback:
 class TestFastAIImportError:
     """ImportError when fastai is missing."""
 
-    def test_import_error_when_fastai_missing(self, monkeypatch):
-        monkeypatch.delitem(sys.modules, "fastai", raising=False)
-        monkeypatch.delitem(sys.modules, "fastai.callback", raising=False)
-        monkeypatch.delitem(sys.modules, "fastai.callback.core", raising=False)
+    def test_import_error_when_fastai_missing(self, monkeypatch, block_import):
+        block_import("fastai")
+        import sys
         sys.modules.pop("openrunner.integration.fastai", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_huggingface.py

@@ -161,8 +161,9 @@ class TestOpenRunnerCallback:
 class TestHuggingFaceImportError:
     """Test 10: clear ImportError when transformers is missing."""
 
-    def test_import_error_when_transformers_missing(self, monkeypatch):
-        monkeypatch.delitem(sys.modules, "transformers", raising=False)
+    def test_import_error_when_transformers_missing(self, monkeypatch, block_import):
+        block_import("transformers")
+        import sys
         sys.modules.pop("openrunner.integration.huggingface", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_keras.py

@@ -147,12 +147,10 @@ class TestOpenRunnerKerasCallback:
 class TestKerasImportError:
     """ImportError when keras is missing."""
 
-    def test_import_error_when_keras_missing(self, monkeypatch):
-        monkeypatch.delitem(sys.modules, "keras", raising=False)
-        monkeypatch.delitem(sys.modules, "keras.callbacks", raising=False)
-        monkeypatch.delitem(sys.modules, "tensorflow", raising=False)
-        monkeypatch.delitem(sys.modules, "tensorflow.keras", raising=False)
-        monkeypatch.delitem(sys.modules, "tensorflow.keras.callbacks", raising=False)
+    def test_import_error_when_keras_missing(self, monkeypatch, block_import):
+        block_import("keras")
+        block_import("tensorflow")
+        import sys
         sys.modules.pop("openrunner.integration.keras", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_langchain.py

@@ -200,12 +200,10 @@ class TestOpenRunnerCallbackHandler:
 class TestLangChainImportError:
     """ImportError when langchain is missing."""
 
-    def test_import_error_when_langchain_missing(self, monkeypatch):
-        monkeypatch.delitem(sys.modules, "langchain_core", raising=False)
-        monkeypatch.delitem(sys.modules, "langchain_core.callbacks", raising=False)
-        monkeypatch.delitem(sys.modules, "langchain", raising=False)
-        monkeypatch.delitem(sys.modules, "langchain.callbacks", raising=False)
-        monkeypatch.delitem(sys.modules, "langchain.callbacks.base", raising=False)
+    def test_import_error_when_langchain_missing(self, monkeypatch, block_import):
+        block_import("langchain_core")
+        block_import("langchain")
+        import sys
         sys.modules.pop("openrunner.integration.langchain", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_lightning.py

@@ -175,10 +175,10 @@ class TestOpenRunnerLogger:
 class TestLightningImportError:
     """Test 8: clear ImportError when lightning is missing."""
 
-    def test_import_error_when_lightning_missing(self, monkeypatch):
-        monkeypatch.delitem(sys.modules, "lightning", raising=False)
-        monkeypatch.delitem(sys.modules, "lightning.pytorch", raising=False)
-        monkeypatch.delitem(sys.modules, "lightning.pytorch.loggers", raising=False)
+    def test_import_error_when_lightning_missing(self, monkeypatch, block_import):
+        block_import("lightning")
+        block_import("pytorch_lightning")
+        import sys
         sys.modules.pop("openrunner.integration.lightning", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_pytorch.py

@@ -113,10 +113,9 @@ class TestLogGradients:
 class TestPyTorchImportError:
     """Test 4: clear ImportError when torch is missing."""
 
-    def test_import_error_when_torch_missing(self, monkeypatch):
-        # Remove the mock torch to simulate missing install
-        monkeypatch.delitem(sys.modules, "torch", raising=False)
-        monkeypatch.delitem(sys.modules, "torch.nn", raising=False)
+    def test_import_error_when_torch_missing(self, monkeypatch, block_import):
+        block_import("torch")
+        import sys
         sys.modules.pop("openrunner.integration.pytorch", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_sklearn.py

@@ -250,9 +250,9 @@ class TestLogFeatureImportance:
 class TestSklearnImportError:
     """ImportError when sklearn is missing."""
 
-    def test_import_error_when_sklearn_missing(self, monkeypatch):
-        monkeypatch.delitem(sys.modules, "sklearn", raising=False)
-        monkeypatch.delitem(sys.modules, "sklearn.metrics", raising=False)
+    def test_import_error_when_sklearn_missing(self, monkeypatch, block_import):
+        block_import("sklearn")
+        import sys
         sys.modules.pop("openrunner.integration.sklearn", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):

{openrunner_sdk-2.17.4 → openrunner_sdk-2.18.0}/tests/test_integration_xgboost.py

@@ -167,9 +167,9 @@ class TestOpenRunnerXGBoostCallback:
 class TestXGBoostImportError:
     """ImportError when xgboost is missing."""
 
-    def test_import_error_when_xgboost_missing(self, monkeypatch):
-        monkeypatch.delitem(sys.modules, "xgboost", raising=False)
-        monkeypatch.delitem(sys.modules, "xgboost.callback", raising=False)
+    def test_import_error_when_xgboost_missing(self, monkeypatch, block_import):
+        block_import("xgboost")
+        import sys
         sys.modules.pop("openrunner.integration.xgboost", None)
 
         with pytest.raises(ImportError, match="pip install openrunner"):