revitdevtool-pytest 0.1.0__tar.gz → 0.2.0__tar.gz

revitdevtool_pytest-0.2.0/AGENTS.md

@@ -0,0 +1,112 @@
+# AGENTS
+
+## Overview
+
+This is the pytest client plugin for RevitDevTool. It bridges local pytest with a live Revit process via Named Pipe JSON-RPC.
+
+## Architecture
+
+```
+Local pytest (collect) → Named Pipe → Revit process (PytestRunner.py) → Results → Local pytest (report)
+```
+
+### Module Map
+
+| Module | Role |
+|--------|------|
+| `plugin.py` | Hook orchestrator — lifecycle, options, bridge setup |
+| `connection.py` | Bridge lifecycle — discover, connect, lease, launch |
+| `bridge.py` | Wire protocol — Named Pipe framing, request/response |
+| `discovery.py` | Pipe scan, Revit registry lookup, process launch |
+| `reporting.py` | Map remote CaseResult → pytest TestReport |
+| `suite_leasing.py` | Cross-process Revit instance allocation (file-based) |
+| `suite_lock.py` | Windows mutex for same-suite concurrency guard |
+| `dialog_resolver.py` | Auto-dismiss Revit startup dialogs via Win32 |
+| `models.py` | Wire protocol data models (mirrors C# PytestContracts) |
+| `constants.py` | Shared constants, option names, defaults |
+
+### Revit-Side (in RevitDevTool repo)
+
+| File | Role |
+|------|------|
+| `PytestRunner.py` | Embedded script — runs `pytest.main()` inside Revit |
+| `SetupRevit.py` | Runtime setup — API refs, I/O redirection |
+| `PytestExecutionService.cs` | C# orchestrator — receives pipe request, invokes Python |
+| `PytestContracts.cs` | C# wire models (mirrors `models.py`) |
+
+## Key Design Decisions
+
+- **Dual pytest model**: Local pytest collects tests; remote pytest executes them. This enables IDE integration (test tree, navigation) while executing in Revit's thread.
+- **`--capture=sys`**: Required because fd-level capture (`os.dup2`) doesn't work in embedded Python.NET.
+- **`--disable-plugin-autoload`**: Prevents third-party plugins from interfering with in-Revit execution.
+- **`sys.__pytest_running__`**: Flag set by PytestRunner to prevent SetupRevit from hijacking stdout/stderr during test runs.
+- **Streaming vs batch**: CLI gets real-time progress notifications; IDE adapters get one batch to avoid double-counting.
+- **Suite leasing**: File-based lease store binds suite → Revit PID across processes. Mutex prevents same-suite parallel runs.
+- **force_launch**: When enabled, spawns new Revit and waits for its exact PID pipe (ignores existing instances).
+
+## Running Tests
+
+```bash
+# From project root with .venv activated:
+pytest
+
+# Or via uv / pixi:
+uv run pytest
+pixi run pytest
+
+# Specific test:
+pytest tests/test_active_state.py::test_active_view_info -v
+```
+
+Plugin auto-enables `-rP` (show captured stdout for passing tests).
+
+## Configuration
+
+All options in `pyproject.toml` under `[tool.pytest.ini_options]`:
+
+```toml
+revit_version = "2025"        # Required for launch
+revit_launch = false           # true = always spawn new instance
+revit_timeout = "60"           # Per-test timeout (seconds)
+revit_launch_timeout = "180"   # Startup wait (seconds)
+revit_pipe = ""                # Explicit pipe (bypass discovery)
+```
+
+## Fixtures Pattern
+
+```python
+# conftest.py
+@pytest.fixture(scope="session")
+def revit_uiapp():
+    return __revit__  # UIApplication injected by host
+
+@pytest.fixture(scope="session")
+def revit_doc(revit_uiapp):
+    return revit_uiapp.ActiveUIDocument.Document
+
+@pytest.fixture
+def revit_auto_rollback(revit_transaction_service):
+    """Start undo tracking, revert after test."""
+    revit_transaction_service.StartChanges()
+    try:
+        yield revit_transaction_service
+    finally:
+        revit_transaction_service.RevertChanges()
+```
+
+## Common Traps
+
+- Tests execute **inside Revit**, not locally. `import` statements for Revit API (`Autodesk.Revit.DB`) only work at test runtime.
+- `__revit__` is a builtin injected by SetupRevit — always access via fixtures, not direct import.
+- Revit API requires main-thread access. All tests run sequentially via FIFO queue (`IHostContextExecutor`).
+- Named Pipe format: `Revit_{year}_{pid}` (e.g. `Revit_2025_12345`).
+- PEP 723 dependencies in `conftest.py` are auto-installed by `PytestDependencyService` before execution.
+- `force_launch` requires `revit_version` to be set — otherwise exits with config error.
+- Print output inside tests is captured by pytest's `--capture=sys` mechanism and returned via `CaseResult.stdout`.
+
+## Change Rules
+
+- Wire protocol changes must update both `models.py` (Python) and `PytestContracts.cs` (C#).
+- Adding CLI options: register in both `pytest_addoption` (CLI) and `parser.addini` (INI).
+- Connection logic is stateless by design — all functions receive parameters, no module-level mutable state except `plugin.py` globals.
+- After modifying connection/discovery logic, manually test with both `revit_launch = true` and `false`.

{revitdevtool_pytest-0.1.0 → revitdevtool_pytest-0.2.0}/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.0] - 2026-05-31
+
+### Added
+
+- **Auto print capture:** plugin automatically enables `-rP` behavior — captured `print()` output is shown for both passing and failing tests without any user configuration.
+- **PID-aware pipe discovery:** `wait_for_revit_pipe` can now wait for a specific process ID, ensuring `force_launch` connects to the newly spawned instance only.
+
+### Changed
+
+- **`revit_launch` → force_launch semantics:** renamed internal parameter from `prefer_fresh` to `force_launch`. When enabled, the plugin disconnects any existing bridge, spawns a new Revit instance, and waits for that exact PID's pipe — never reuses existing instances.
+- **`_opt_bool` fix:** corrected boolean option parsing so `revit_launch = true` in `pyproject.toml` is properly respected when no CLI flag is explicitly passed.
+- **Type annotations refactor:** resolved false-positive IDE warnings across `bridge.py`, `connection.py`, `suite_leasing.py`, and `dialog_resolver.py`.
+- **`SetupRevit.py` (Revit-side):** I/O hijacking is now conditional on `sys.__pytest_running__` flag — prevents conflict with pytest capture during test execution.
+- **`PytestRunner.py` (Revit-side):** sets `sys.__pytest_running__ = True` during execution; top-level error handling wraps entire `_run()` to always return structured JSON.
+
+### Removed
+
+- **`discover_tests()`** method from `bridge.py` (client-side dead code; server endpoint remains).
+- **`DiscoverRequest` / `DiscoverResponse`** classes from `models.py` (unused by client).
+- **`BRIDGE_METHOD_TESTS_DISCOVER`** constant (no longer referenced).
+- **`resolve_existing()` / `get_suite_process_id()` / `_prune_stale()`** from `suite_leasing.py` (unused).
+- **`launch_revit()`** from `discovery.py` (replaced by `start_revit` + PID tracking).
+- **`addopts = "-rP"`** from `pyproject.toml` (now automatic via plugin).
+
+### Fixed
+
+- **`revit_launch = true` in INI ignored:** `_opt_bool` now correctly reads INI value when CLI flag is not explicitly set.
+
 ## [0.1.0] - 2026-05-03
 
 ### Added

revitdevtool_pytest-0.2.0/CLAUDE.md

@@ -0,0 +1 @@
+Refer to [AGENTS.md](./AGENTS.md) for project rules, conventions, and workflow.

{revitdevtool_pytest-0.1.0 → revitdevtool_pytest-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: revitdevtool_pytest
-Version: 0.1.0
+Version: 0.2.0
 Summary: pytest plugin for testing Revit API code via RevitDevTool Named Pipe bridge
 Project-URL: Homepage, https://github.com/trgiangv/RevitDevTool.PyTest
 Project-URL: Repository, https://github.com/trgiangv/RevitDevTool.PyTest
@@ -40,10 +40,6 @@ Tests run inside a live Revit process — write standard pytest, execute remotel
 pip install revitdevtool_pytest
 ```
 
-```python
-import revitdevtool_pytest
-```
-
 ## Dependencies
 
 | Package | Version |
@@ -55,11 +51,11 @@ import revitdevtool_pytest
 ## Requirements
 
 - Windows (Named Pipes)
-- Revit with [RevitDevTool](https://github.com/trgiangv/RevitDevTool) add-in installed
+- Revit with [RevitDevTool](https://github.com/trgiangv/RevitDevTool) add-in installed and loaded
 
 ## Project Setup
 
-**Recommended:** scaffold your project with [uv](https://docs.astral.sh/uv/) or [pixi](https://pixi.sh/).
+**Recommended:** scaffold your project with [uv](https://docs.astral.sh/uv/) or [pixi](https://pixi.sh/):
 
 ```bash
 # uv
@@ -67,92 +63,130 @@ uv init my-revit-tests
 cd my-revit-tests
 uv add revitdevtool_pytest
 
-# pixi
-pixi init my-revit-tests
+# pixi (uses pyproject.toml as manifest)
+pixi init --format pyproject my-revit-tests
 cd my-revit-tests
-pixi add revitdevtool_pytest
+pixi add --pypi revitdevtool_pytest
 ```
 
-Both tools automatically manage virtual environments, lock files, and `pyproject.toml` — no separate `pip` setup needed.
-
 ## Configuration
 
 Add plugin settings to `[tool.pytest.ini_options]` in your `pyproject.toml`:
 
 ```toml
 [tool.pytest.ini_options]
-testpaths = ["tests"]
 revit_version = "2025"
-revit_launch = true
+revit_launch = false
 revit_launch_timeout = "180"
 ```
 
-> With `uv` or `pixi`, run tests via `uv run pytest` or `pixi run pytest`.
-
-All options are settable via `[tool.pytest.ini_options]` or standard INI files (`pytest.ini`, `tox.ini`, `setup.cfg`):
-
 | Option | Type | Default | Description |
 |---|---|---|---|
 | `revit_version` | string | — | Revit version year (e.g. `"2025"`). Required when `revit_launch = true`. |
-| `revit_launch` | bool | `false` | Auto-launch Revit if no running instance found. |
+| `revit_launch` | bool | `false` | Force-launch a **new** Revit instance (skip reusing existing free instances). |
 | `revit_timeout` | string | `"60"` | Per-test execution timeout in seconds. |
 | `revit_launch_timeout` | string | `"120"` | Seconds to wait for Revit to start. |
 | `revit_pipe` | string | — | Explicit pipe name (bypasses auto-discovery). |
 
-CLI flags override INI settings for one-off runs:
+CLI flags override INI settings:
 
 ```bash
 pytest --revit-launch --revit-version=2025 -v
 ```
 
+### Connection Behavior
+
+- **Default** (`revit_launch = false`): plugin auto-discovers a running Revit instance matching `revit_version` via Named Pipe scan. If none found, exits with error.
+- **Force launch** (`revit_launch = true`): always spawns a new Revit process, waits for its pipe to appear, then connects. Existing instances are ignored.
+
+### Print Output
+
+Captured `print()` output from tests running inside Revit is automatically shown in the terminal for passing tests (equivalent to `-rP`). No extra flags needed.
+
 ## Usage
 
+### Fixtures
+
+Define fixtures in `conftest.py` that provide Revit API objects:
+
 ```python
-def test_revit_version():
-    app = __revit__.Application
-    assert "2025" in app.VersionName
+import pytest
+
+@pytest.fixture(scope="session")
+def revit_uiapp():
+    return __revit__  # UIApplication injected by RevitDevTool
+
+@pytest.fixture(scope="session")
+def revit_app(revit_uiapp):
+    return revit_uiapp.Application
+
+@pytest.fixture(scope="session")
+def revit_doc(revit_uiapp):
+    return revit_uiapp.ActiveUIDocument.Document
 ```
 
+### Writing Tests
+
+```python
+def test_active_view(revit_doc):
+    view = revit_doc.ActiveView
+    print(f"Active View: {view.Name}")
+    assert view.Name is not None
+
+def test_revit_version(revit_app):
+    assert "2025" in revit_app.VersionName
+```
+
+### PEP 723 Dependencies
+
+Declare test-suite dependencies in `conftest.py` using PEP 723 metadata. RevitDevTool auto-installs them before test execution:
+
+```python
+# /// script
+# dependencies = [
+#   "numpy>=2.0",
+#   "polars>=1.0",
+# ]
+# ///
+```
+
+### Running Tests
+
 ```bash
-# With pyproject.toml configured, just run:
+# With pyproject.toml configured:
 pytest
 
-# Or override for a single run:
+# Override version for a single run:
 pytest --revit-version=2026 -v
+
+# Using uv or pixi:
+uv run pytest
+pixi run pytest
 ```
 
 ## How It Works
 
-1. pytest discovers tests locally as usual
-2. Plugin intercepts execution via `pytest_runtestloop`
-3. Test source is serialized and sent over Named Pipe to Revit
-4. RevitDevTool add-in executes the test inside Revit's Python (pythonnet) environment
-5. Results are mapped back to pytest pass/fail/skip
+1. pytest discovers and collects tests locally
+2. Plugin intercepts `pytest_runtestloop`, connects to Revit via Named Pipe
+3. Test nodeids are sent to Revit's `PytestRunner.py` (embedded in RevitDevTool)
+4. Tests execute inside Revit's Python.NET environment with full API access
+5. Results (pass/fail/skip, stdout, stderr, tracebacks) are returned via pipe
+6. Plugin maps results back to standard pytest reports
 
-## VSCode Integration
+## IDE Integration
 
-Add to `.vscode/settings.json`:
+### VS Code / Cursor
 
 ```json
 {
     "python.testing.pytestEnabled": true,
-    "python.testing.pytestArgs": [
-        "tests"
-    ]
+    "python.testing.pytestArgs": ["tests"]
 }
 ```
 
-CLI args can go in `pytestArgs` if not configured in `pyproject.toml`:
+### PyCharm
 
-```json
-{
-    "python.testing.pytestArgs": [
-        "--revit-launch",
-        "--revit-version=2025",
-        "tests"
-    ]
-}
-```
+Enable pytest as the test runner. Plugin auto-detects IDE adapters and disables streaming to avoid duplicate results in the test tree.
 
 ## License
 

revitdevtool_pytest-0.2.0/README.md

@@ -0,0 +1,166 @@
+# RevitDevTool.PyTest
+
+[![PyPI version](https://img.shields.io/pypi/v/RevitDevTool.PyTest)](https://pypi.org/project/RevitDevTool.PyTest/)
+[![Python](https://img.shields.io/pypi/pyversions/RevitDevTool.PyTest)](https://pypi.org/project/RevitDevTool.PyTest/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+pytest plugin for testing Revit API code via RevitDevTool Named Pipe bridge.
+Tests run inside a live Revit process — write standard pytest, execute remotely.
+
+## Installation
+
+```bash
+pip install revitdevtool_pytest
+```
+
+## Dependencies
+
+| Package | Version |
+|---|---|
+| Python | >= 3.10 |
+| pytest | >= 9.0 |
+| pywin32 | >= 311 |
+
+## Requirements
+
+- Windows (Named Pipes)
+- Revit with [RevitDevTool](https://github.com/trgiangv/RevitDevTool) add-in installed and loaded
+
+## Project Setup
+
+**Recommended:** scaffold your project with [uv](https://docs.astral.sh/uv/) or [pixi](https://pixi.sh/):
+
+```bash
+# uv
+uv init my-revit-tests
+cd my-revit-tests
+uv add revitdevtool_pytest
+
+# pixi (uses pyproject.toml as manifest)
+pixi init --format pyproject my-revit-tests
+cd my-revit-tests
+pixi add --pypi revitdevtool_pytest
+```
+
+## Configuration
+
+Add plugin settings to `[tool.pytest.ini_options]` in your `pyproject.toml`:
+
+```toml
+[tool.pytest.ini_options]
+revit_version = "2025"
+revit_launch = false
+revit_launch_timeout = "180"
+```
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `revit_version` | string | — | Revit version year (e.g. `"2025"`). Required when `revit_launch = true`. |
+| `revit_launch` | bool | `false` | Force-launch a **new** Revit instance (skip reusing existing free instances). |
+| `revit_timeout` | string | `"60"` | Per-test execution timeout in seconds. |
+| `revit_launch_timeout` | string | `"120"` | Seconds to wait for Revit to start. |
+| `revit_pipe` | string | — | Explicit pipe name (bypasses auto-discovery). |
+
+CLI flags override INI settings:
+
+```bash
+pytest --revit-launch --revit-version=2025 -v
+```
+
+### Connection Behavior
+
+- **Default** (`revit_launch = false`): plugin auto-discovers a running Revit instance matching `revit_version` via Named Pipe scan. If none found, exits with error.
+- **Force launch** (`revit_launch = true`): always spawns a new Revit process, waits for its pipe to appear, then connects. Existing instances are ignored.
+
+### Print Output
+
+Captured `print()` output from tests running inside Revit is automatically shown in the terminal for passing tests (equivalent to `-rP`). No extra flags needed.
+
+## Usage
+
+### Fixtures
+
+Define fixtures in `conftest.py` that provide Revit API objects:
+
+```python
+import pytest
+
+@pytest.fixture(scope="session")
+def revit_uiapp():
+    return __revit__  # UIApplication injected by RevitDevTool
+
+@pytest.fixture(scope="session")
+def revit_app(revit_uiapp):
+    return revit_uiapp.Application
+
+@pytest.fixture(scope="session")
+def revit_doc(revit_uiapp):
+    return revit_uiapp.ActiveUIDocument.Document
+```
+
+### Writing Tests
+
+```python
+def test_active_view(revit_doc):
+    view = revit_doc.ActiveView
+    print(f"Active View: {view.Name}")
+    assert view.Name is not None
+
+def test_revit_version(revit_app):
+    assert "2025" in revit_app.VersionName
+```
+
+### PEP 723 Dependencies
+
+Declare test-suite dependencies in `conftest.py` using PEP 723 metadata. RevitDevTool auto-installs them before test execution:
+
+```python
+# /// script
+# dependencies = [
+#   "numpy>=2.0",
+#   "polars>=1.0",
+# ]
+# ///
+```
+
+### Running Tests
+
+```bash
+# With pyproject.toml configured:
+pytest
+
+# Override version for a single run:
+pytest --revit-version=2026 -v
+
+# Using uv or pixi:
+uv run pytest
+pixi run pytest
+```
+
+## How It Works
+
+1. pytest discovers and collects tests locally
+2. Plugin intercepts `pytest_runtestloop`, connects to Revit via Named Pipe
+3. Test nodeids are sent to Revit's `PytestRunner.py` (embedded in RevitDevTool)
+4. Tests execute inside Revit's Python.NET environment with full API access
+5. Results (pass/fail/skip, stdout, stderr, tracebacks) are returned via pipe
+6. Plugin maps results back to standard pytest reports
+
+## IDE Integration
+
+### VS Code / Cursor
+
+```json
+{
+    "python.testing.pytestEnabled": true,
+    "python.testing.pytestArgs": ["tests"]
+}
+```
+
+### PyCharm
+
+Enable pytest as the test runner. Plugin auto-detects IDE adapters and disables streaming to avoid duplicate results in the test tree.
+
+## License
+
+[MIT](LICENSE)

{revitdevtool_pytest-0.1.0 → revitdevtool_pytest-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "revitdevtool_pytest"
-version = "0.1.0"
+version = "0.2.0"
 description = "pytest plugin for testing Revit API code via RevitDevTool Named Pipe bridge"
 readme = "README.md"
 license = "MIT"
@@ -41,5 +41,5 @@ packages = ["src/revitdevtool_pytest"]
 testpaths = ["tests"]
 revit_version = "2025"
 revit_timeout = "60"
-revit_launch = true
+revit_launch = false
 revit_launch_timeout = "180"

{revitdevtool_pytest-0.1.0 → revitdevtool_pytest-0.2.0}/src/revitdevtool_pytest/__init__.py

@@ -1,3 +1,3 @@
 """RevitDevTool.PyTest: Run pytest tests inside a live Revit process via Named Pipe bridge."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{revitdevtool_pytest-0.1.0 → revitdevtool_pytest-0.2.0}/src/revitdevtool_pytest/bridge.py

@@ -13,7 +13,6 @@ import time
 from typing import Any, Callable
 
 from .constants import (
-    BRIDGE_METHOD_TESTS_DISCOVER,
     BRIDGE_METHOD_TESTS_RUN,
     BRIDGE_MSG_TYPE_NOTIFICATION,
     DEFAULT_CONNECT_TIMEOUT_MS,
@@ -24,8 +23,6 @@ from .models import (
     BridgeRequest,
     BridgeResponse,
     CollectionError,
-    DiscoverRequest,
-    DiscoverResponse,
     RunRequest,
     RunResponse,
 )
@@ -69,7 +66,7 @@ class RevitBridge:
                     self._handle, win32pipe.PIPE_READMODE_BYTE, None, None,
                 )
                 return
-            except Exception:
+            except Exception: # noqa
                 if time.monotonic() >= deadline:
                     raise ConnectionError(
                         f"Cannot connect to pipe '{self._pipe_name}' "
@@ -85,11 +82,11 @@ class RevitBridge:
 
         try:
             win32file.FlushFileBuffers(handle)
-        except Exception:  # noqa: BLE001
+        except Exception:  # noqa
             pass
         try:
             win32file.CloseHandle(handle)
-        except Exception:  # noqa: BLE001
+        except Exception:  # noqa
             pass
 
     @property
@@ -101,31 +98,12 @@ class RevitBridge:
 
             win32pipe.PeekNamedPipe(self._handle, 0)
             return True
-        except Exception:  # noqa: BLE001
+        except Exception:  # noqa
             log.debug("Pipe health check failed, marking as disconnected")
             return False
 
     # -- Public RPC methods -------------------------------------------------
 
-    def discover_tests(
-        self,
-        workspace_root: str,
-        test_root: str,
-        *,
-        pytest_args: list[str] | None = None,
-        timeout_s: float = DEFAULT_TEST_TIMEOUT_S,
-    ) -> DiscoverResponse:
-        request = DiscoverRequest(
-            workspace_root=workspace_root,
-            test_root=test_root,
-            pytest_args=pytest_args or [],
-        )
-        response = self._request(
-            BridgeRequest(method=BRIDGE_METHOD_TESTS_DISCOVER, params=request.to_params()),
-            timeout_s,
-        )
-        return _parse_discover_response(response)
-
     def run_tests(
         self,
         workspace_root: str,
@@ -142,7 +120,7 @@ class RevitBridge:
             nodeids=nodeids,
             pytest_args=pytest_args or [],
         )
-        response = self._request(
+        response: BridgeResponse = self._request(
             BridgeRequest(method=BRIDGE_METHOD_TESTS_RUN, params=request.to_params()),
             timeout_s,
             on_notification=on_notification,
@@ -160,20 +138,17 @@ class RevitBridge:
     ) -> BridgeResponse:
         self._write_frame(req.to_json_bytes())
         deadline = time.monotonic() + timeout_s
-        while True:
-            remaining = deadline - time.monotonic()
-            if remaining <= 0:
-                raise TimeoutError(f"Timed out waiting for response to {req.id}")
-            data = self._read_frame(remaining)
+        while time.monotonic() < deadline:
+            data = self._read_frame(deadline - time.monotonic())
             parsed = json.loads(data)
 
             if parsed.get("type") == BRIDGE_MSG_TYPE_NOTIFICATION:
                 _dispatch_notification(parsed, on_notification)
                 continue
 
-            resp = BridgeResponse.from_json(parsed)
-            if resp.id == req.id:
-                return resp
+            return BridgeResponse.from_json(parsed)
+
+        raise TimeoutError(f"Timed out waiting for response to {req.id}")
 
     def _write_frame(self, body: bytes) -> None:
         import win32file  # type: ignore[import-untyped]
@@ -207,20 +182,6 @@ class RevitBridge:
 # ---------------------------------------------------------------------------
 
 
-def _parse_discover_response(response: BridgeResponse) -> DiscoverResponse:
-    if response.is_error:
-        return DiscoverResponse(
-            collection_errors=(CollectionError(message=response.error_message),),
-        )
-    if isinstance(response.result, dict):
-        return DiscoverResponse.from_dict(response.result)
-    return DiscoverResponse(
-        collection_errors=(
-            CollectionError(message=f"Unexpected response: {response.result}"),
-        ),
-    )
-
-
 def _parse_run_response(response: BridgeResponse) -> RunResponse:
     if response.is_error:
         return RunResponse(
@@ -247,5 +208,5 @@ def _dispatch_notification(
     params = parsed.get("params")
     try:
         callback(method, params)
-    except Exception:  # noqa: BLE001
+    except Exception:  # noqa
         log.debug("Notification callback error for method=%s", method, exc_info=True)