davinci-resolve-mcp 2.68.1 → 2.68.2

package/CHANGELOG.md

@@ -2,6 +2,78 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.68.2
+
+Bug fixes. The server no longer opens a second DaVinci Resolve, and a failed
+connection now tells the caller what is actually wrong.
+
+### Fixed
+
+- **The server launched Resolve when one was already running — usually the wrong
+  one.** The free edition refuses external scripting by design, so on a machine
+  where only it is running `scriptapp("Resolve")` always returns None.
+  `get_resolve()` read that as *"Resolve is not running"* and ran `open` on the
+  application; with both editions installed that started **Studio**, a second and
+  different application, on every tool call.
+
+  `resolve_is_running()` now answers the question that was being assumed. It
+  returns None when it cannot tell, deliberately — "cannot tell" must never decay
+  into "nothing is running", because that is the answer that leads to launching
+  something. A genuinely absent Resolve is still launched, as documented, and the
+  macOS candidate list now contains **both** editions rather than only the
+  installer path.
+- **The error a caller received described something that had not happened.**
+  Eleven sites asserted that Resolve was not running, that starting it had been
+  tried and failed, and that the reader should check their Studio install. After
+  the fix above none of that was true, and the accurate guidance was only reaching
+  the log. `_not_connected_error()` derives the message from the situation and
+  names the applicable remedy — external scripting on Studio, or the in-app bridge
+  on the free edition, including the framework-Python prerequisite. Three codes:
+  `SCRIPTING_UNAVAILABLE`, `BRIDGE_UNAVAILABLE`, `RESOLVE_NOT_RUNNING`.
+- **Those two are marked `retryable: false`.** The `not_connected` category
+  defaults to retryable because auto-launch may succeed next time; neither of
+  these can — one needs a preference changed, the other a script started inside
+  Resolve — and reporting them as retryable sends an agent into a loop it cannot
+  win.
+- **The offline test suite opened Resolve, and connected to whatever was running.**
+  A stub-based audio test reached for `AUDIO_SYNC_*`, which are attributes on the
+  *live* object, so it called `get_resolve()`, found nothing, and started Resolve;
+  when Resolve *was* open it connected instead, making the test's result depend on
+  the state of the machine. `tests/conftest.py` closes both suite-wide and names
+  any launch attempt in the terminal summary.
+- **`src/server.py` reported the wrong tool count to every agent.** Its module
+  docstring said "34 compound tools" while the agent-facing workflow prompt and
+  the startup log line said 32. The drift guard only required the correct number
+  to appear *somewhere* in the file, so the wrong one shipped. It now rejects any
+  other count in front of that phrase, and counts decorators from the parsed
+  syntax tree rather than by matching text — a docstring mentioning
+  `@mcp.tool()` had been counted as a 35th tool.
+- **The bridge harness graded the wrong clip and reported a known trap as a
+  finding.** It took the first video item, which is often a generator or title
+  that has no MediaPoolItem and answers None to every node query, so the grading
+  surface read as unreachable; it now takes the first gradeable item. And it
+  passed the codec *description* `"H.264"` to `SetCurrentRenderFormatAndCodec`,
+  which only accepts the id `"H264"`, making that observation permanently false
+  for a documented reason.
+
+### Changed
+
+- `scripts/install_resolve_bridge.py` no longer claims Resolve ignores Fusion's
+  standalone script tree. Measured on free 21.0.3.7: markers left in two
+  undocumented container paths both appeared under Workspace ▸ Scripts, so Lite
+  scans more locations than the README documents. Install behaviour is unchanged —
+  the documented paths work, and each extra target is another chance for the macOS
+  App Management prompt to stall the copy — but the stated reason is now the true
+  one.
+
+### Validated
+
+Free edition alone (21.0.3.7, App Store), Studio never launched at any point,
+confirmed by process check after every stage: 165/165 read-shaped MCP actions
+clean with Blackmagic's module blocked; 109/112 API read methods exercised; render
+to a non-empty file with `set_format` true; AAF/DRT/EDL/FCPXML all written;
+SetLUT clears and reads back. Suite 1913 passing.
+
 ## What's New in v2.68.1
 
 Bug fix. A missing tool argument now returns the structured error envelope the

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.68.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.68.2-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-34%20(341%20full)-blue.svg)](#server-modes)

package/install.py

@@ -36,7 +36,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.68.1"
+VERSION = "2.68.2"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.68.1",
+  "version": "2.68.2",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/scripts/bridge_differential.py

@@ -75,11 +75,21 @@ def scenario_render(resolve: Any, workspace: Path) -> Dict[str, Any]:
     observations: Dict[str, Any] = {}
     formats = project.GetRenderFormats() or {}
     observations["format_count"] = len(formats)
-    observations["codec_count_for_mov"] = len(project.GetRenderCodecs("mov") or {})
+    codecs = project.GetRenderCodecs("mov") or {}
+    observations["codec_count_for_mov"] = len(codecs)
 
     output = workspace / "bridge_render_probe"
     output.mkdir(parents=True, exist_ok=True)
-    observations["set_format"] = project.SetCurrentRenderFormatAndCodec("mov", "H.264")
+    # `GetRenderCodecs` returns {description: id} and only the **id** is accepted.
+    # Passing the description shown in the Deliver page returns False — verified
+    # again here on free 21.0.3.7: 'H.264' -> False, 'H264' -> True. Feeding it the
+    # description made this observation permanently False for a documented reason,
+    # which is a harness reporting a known trap as if it were a finding.
+    codec_id = codecs.get("H.264") or next(iter(codecs.values()), None)
+    observations["codec_id"] = codec_id
+    observations["set_format"] = (
+        project.SetCurrentRenderFormatAndCodec("mov", codec_id) if codec_id else False
+    )
     observations["set_settings"] = project.SetRenderSettings({
         "TargetDir": str(output),
         "CustomName": "bridge_render_probe",
@@ -147,8 +157,16 @@ def scenario_set_lut(resolve: Any, _workspace: Path) -> Dict[str, Any]:
     items = timeline.GetItemListInTrack("video", 1) or []
     if not items:
         return {"skipped": "no clip on video track 1"}
-    item = items[0]
-    observations: Dict[str, Any] = {"node_count": item.GetNumNodes()}
+    # Not items[0]: a generator or title has no MediaPoolItem and answers None to
+    # every node question, so grading it silently produces a row of nulls that
+    # reads like a bridge failure. Measured on a real timeline — SMPTE Color Bar
+    # returns None for GetNumNodes and GetNodeGraph, the clip beside it returns 1
+    # and a live graph.
+    item = next((i for i in items if i.GetMediaPoolItem()), None)
+    if item is None:
+        return {"skipped": "video track 1 holds only generators/titles, which cannot be graded",
+                "items_seen": len(items)}
+    observations: Dict[str, Any] = {"clip": item.GetName(), "node_count": item.GetNumNodes()}
     original = item.GetLUT(1)
     observations["lut_before"] = original
     # An empty path is the documented way to clear a node's LUT, so it is a

package/scripts/install_resolve_bridge.py

@@ -37,9 +37,9 @@ _SCRIPTS_SUFFIX = "Library/Application Support/Blackmagic Design/DaVinci Resolve
 #: Two traps, both hit on a real install:
 #:
 #: 1. `<container>/Data/Library/Application Support/Fusion/Scripts/Utility`
-#:    exists and is pre-scaffolded with Color/Comp/Deliver/Edit/Tool/Utility —
-#:    but that is **Fusion's standalone tree**, not Resolve's, and Resolve does
-#:    not scan it. Keying on "which directory already exists" picks the decoy.
+#:    exists and is pre-scaffolded with Color/Comp/Deliver/Edit/Tool/Utility, but
+#:    it is **Fusion's standalone tree**, not Resolve's. Keying on "which
+#:    directory already exists" picks it over the one the README documents.
 #: 2. Resolve does not create its own `Fusion/Scripts` tree until a script is
 #:    installed, so requiring the target to pre-exist skips the free edition
 #:    entirely — the one build the bridge exists for.
@@ -47,6 +47,16 @@ _SCRIPTS_SUFFIX = "Library/Application Support/Blackmagic Design/DaVinci Resolve
 #: So: a container that exists means the edition is installed, and the tree is
 #: *created*. Blackmagic's README is the authority on the suffix, not the
 #: filesystem.
+#:
+#: **Correction, measured on free 21.0.3.7:** an earlier version of trap 1 said
+#: Resolve "does not scan" the Fusion standalone tree. It does — a marker left in
+#: `<container>/Data/Library/Application Support/Fusion/Scripts/Utility` appeared
+#: under Workspace ▸ Scripts, as did one in
+#: `<container>/Data/Documents/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Utility`.
+#: So Lite scans more locations than the README documents. That changes nothing
+#: about *where to install* — the documented paths work, and each extra target is
+#: another chance for the App Management prompt to stall the copy — but the reason
+#: to prefer them is that they are documented, not that the others are dead.
 _SANDBOX_MARKER = "com.blackmagic-design."
 #: Containers that are not Resolve (RAW Player, Speed Test, the IO XPC helper).
 _NON_RESOLVE_CONTAINERS = ("BlackmagicRaw", "IOXPC")

package/src/granular/common.py

@@ -85,7 +85,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.68.1"
+VERSION = "2.68.2"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.68.1"
+VERSION = "2.68.2"
 
 import base64
 import os
@@ -296,7 +296,7 @@ def davinci_resolve_workflow() -> str:
     return """Use this DaVinci Resolve MCP server as a guarded post-production control surface.
 
 Core pattern:
-- Prefer the 32 compound tools and their action names over raw scripting.
+- Prefer the 34 compound tools and their action names over raw scripting.
 - Start by probing state: resolve_control.get_version/get_page, project_manager.get_current, timeline.get_current, and media_pool.probe_media_pool.
 - Before mutating timelines, media pools, render settings, grades, projects, databases, or extensions, prefer the matching probe, capabilities, boundary_report, safe_*, or dry_run action when one exists.
 - Preserve source media integrity. Never transcode, proxy, rewrite, move, rename, or create derivatives of source media unless the user explicitly asks. Analysis output belongs in sidecars or analysis directories.
@@ -899,6 +899,37 @@ def _launch_resolve():
     logger.warning("Resolve did not respond within 60s after launch")
     return False
 
+#: Process names that mean a DaVinci Resolve application is already running.
+#: Deliberately not the full path: the App Store build lives at
+#: `/Applications/DaVinci Resolve.app` and the installer build inside
+#: `/Applications/DaVinci Resolve/`, and either one counts.
+_RESOLVE_PROCESS_PATTERNS = (
+    "DaVinci Resolve.app/Contents/MacOS/Resolve",   # macOS, both editions
+    "Resolve.exe",                                  # Windows
+    "/opt/resolve/bin/resolve",                     # Linux
+)
+
+
+def resolve_is_running() -> Optional[bool]:
+    """Is a Resolve application already up? None when it cannot be determined.
+
+    Best-effort and dependency-free. `None` rather than `False` on failure, so an
+    unanswerable question never silently becomes "nothing is running" — which is
+    the answer that leads to launching something.
+    """
+    try:
+        if platform.system().lower() == "windows":
+            out = subprocess.run(["tasklist"], capture_output=True, text=True, timeout=10, check=False)
+        else:
+            out = subprocess.run(["ps", "-Ao", "command="], capture_output=True, text=True, timeout=10, check=False)
+        if out.returncode != 0 and not out.stdout:
+            return None
+        listing = out.stdout or ""
+    except Exception:  # pragma: no cover - defensive; an unknown answer is None
+        return None
+    return any(pattern in listing for pattern in _RESOLVE_PROCESS_PATTERNS)
+
+
 def get_resolve():
     """Lazy connection to Resolve — connects on first tool call, auto-launches if needed."""
     global resolve
@@ -909,12 +940,84 @@ def get_resolve():
         # Try to connect to an already-running Resolve.
         if _try_connect():
             return resolve
-        # Not running — launch it automatically.
+        # Failing to connect is NOT the same as nothing running, and conflating
+        # them opened an application nobody asked for. The free edition refuses
+        # external scripting by design, so on a machine where only it is running
+        # `_try_connect` always fails — and this then launched *Studio*, a second,
+        # different application, on every tool call. Reported three times before
+        # it was traced.
+        already_running = resolve_is_running()
+        if already_running:
+            logger.error(
+                "DaVinci Resolve is already running but is not answering the scripting API, "
+                "so it will NOT be launched again. Either enable Preferences > General > "
+                "'External scripting using' = Local (Studio only), or, on the free edition, "
+                "use the in-app bridge: install it, run Workspace > Scripts > resolve_bridge, "
+                "and set DAVINCI_RESOLVE_BRIDGE=1."
+            )
+            return None
+        if already_running is None:
+            logger.warning("Could not determine whether Resolve is running; not launching it.")
+            return None
         logger.info("Resolve not running, attempting to launch automatically...")
         _launch_resolve()
         return resolve
 
 
+def _not_connected_error():
+    """The caller-facing "no Resolve" error, describing what is actually the case.
+
+    Eleven call sites used to assert that Resolve was not running, that starting it
+    had been tried and failed, and that the reader should check their Studio
+    install. Once `get_resolve` stopped launching a second application, all three
+    claims were wrong: nothing was launched, Resolve *is* running, and a
+    free-edition user was being sent to check an install they may not have. The
+    accurate guidance was only reaching the log.
+
+    So the message is derived from the situation instead of asserted, and it names
+    the fix that applies: enable external scripting on Studio, or use the in-app
+    bridge on the free edition.
+    """
+    running = resolve_is_running()
+    bridge_on = _bridge_requested()
+    if bridge_on:
+        return _err(
+            "The in-app bridge is enabled but not answering.",
+            code="BRIDGE_UNAVAILABLE", category="not_connected",
+            # `not_connected` defaults to retryable because auto-launch may
+            # succeed next time. Nothing here will: the listener only appears once
+            # someone runs the script inside Resolve, so an agent retrying on a
+            # loop it cannot win is strictly worse than being told to stop.
+            retryable=False,
+            reason="DAVINCI_RESOLVE_BRIDGE is set, so no other transport is tried.",
+            remediation="In Resolve, run Workspace > Scripts > resolve_bridge. If it is not in "
+                        "that menu, run `python scripts/install_resolve_bridge.py` and restart "
+                        "Resolve; a framework Python from python.org is required for Resolve to "
+                        "list .py scripts at all.",
+            state={"resolve_running": running, "bridge_enabled": True},
+        )
+    if running:
+        return _err(
+            "DaVinci Resolve is running but is not answering the scripting API.",
+            code="SCRIPTING_UNAVAILABLE", category="not_connected",
+            # Not retryable: a preference has to change, or the bridge has to be
+            # started. Retrying the same call cannot make either happen.
+            retryable=False,
+            reason="External scripting is a Studio feature; the free edition refuses it "
+                   "regardless of the preference. Resolve was NOT launched again.",
+            remediation="On Studio: Preferences > General > 'External scripting using' = Local. "
+                        "On the free edition: install the in-app bridge, run "
+                        "Workspace > Scripts > resolve_bridge, and set DAVINCI_RESOLVE_BRIDGE=1.",
+            state={"resolve_running": True, "bridge_enabled": False},
+        )
+    return _err(
+        "DaVinci Resolve is not running and could not be started.",
+        code="RESOLVE_NOT_RUNNING", category="not_connected",
+        remediation="Start DaVinci Resolve and open a project, then retry.",
+        state={"resolve_running": bool(running), "bridge_enabled": False},
+    )
+
+
 def _destructive_versioning_provider() -> Optional[Tuple[Any, Any, str, Optional[str]]]:
     """Provider used by the C6 version-on-mutate hook.
 
@@ -13065,11 +13168,11 @@ def resolve_control(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
         r = get_resolve()  # auto-launches if not running
         if r is not None:
             return _ok(message="DaVinci Resolve is running and connected.")
-        return _err("Could not connect to DaVinci Resolve. Check that Resolve Studio is installed and 'External scripting using' is set to Local in Preferences.")
+        return _not_connected_error()
 
     r = get_resolve()  # auto-launches if not running
     if r is None:
-        return _err("Could not connect to DaVinci Resolve after auto-launch attempt. Check that Resolve Studio is installed.")
+        return _not_connected_error()
 
     if action == "get_version":
         update_env = _setup_update_env()
@@ -13992,7 +14095,7 @@ def layout_presets(action: str, params: Optional[Dict[str, Any]] = None) -> Dict
     p = _params(params)
     r = get_resolve()
     if r is None:
-        return _err("Could not connect to DaVinci Resolve. It was not running and auto-launch failed. Check that Resolve Studio is installed.")
+        return _not_connected_error()
 
     if action == "save":
         if not p.get("name"):
@@ -14037,7 +14140,7 @@ def render_presets(action: str, params: Optional[Dict[str, Any]] = None) -> Dict
     p = _params(params)
     r = get_resolve()
     if r is None:
-        return _err("Could not connect to DaVinci Resolve. It was not running and auto-launch failed. Check that Resolve Studio is installed.")
+        return _not_connected_error()
 
     if action == "import_render":
         return {"success": bool(r.ImportRenderPreset(p["path"]))}
@@ -14980,7 +15083,7 @@ def project_manager(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
     p = _params(params)
     r = get_resolve()
     if r is None:
-        return _err("Could not connect to DaVinci Resolve. It was not running and auto-launch failed. Check that Resolve Studio is installed.")
+        return _not_connected_error()
     pm = r.GetProjectManager()
 
     if action == "lint":
@@ -15100,7 +15203,7 @@ def project_manager_folders(action: str, params: Optional[Dict[str, Any]] = None
     p = _params(params)
     r = get_resolve()
     if r is None:
-        return _err("Could not connect to DaVinci Resolve. It was not running and auto-launch failed. Check that Resolve Studio is installed.")
+        return _not_connected_error()
     pm = r.GetProjectManager()
 
     if action == "list":
@@ -15142,7 +15245,7 @@ def project_manager_cloud(action: str, params: Optional[Dict[str, Any]] = None)
     p = _params(params)
     r = get_resolve()
     if r is None:
-        return _err("Could not connect to DaVinci Resolve. It was not running and auto-launch failed. Check that Resolve Studio is installed.")
+        return _not_connected_error()
     pm = r.GetProjectManager()
 
     # cloudSettings is enum-keyed (CLOUD_SETTING_*/CLOUD_SYNC_*); resolve string
@@ -15180,7 +15283,7 @@ def project_manager_database(action: str, params: Optional[Dict[str, Any]] = Non
     p = _params(params)
     r = get_resolve()
     if r is None:
-        return _err("Could not connect to DaVinci Resolve. It was not running and auto-launch failed. Check that Resolve Studio is installed.")
+        return _not_connected_error()
     pm = r.GetProjectManager()
 
     if action == "get_current":
@@ -16190,7 +16293,7 @@ def media_storage(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[
     p = _params(params)
     r = get_resolve()
     if r is None:
-        return _err("Could not connect to DaVinci Resolve. It was not running and auto-launch failed. Check that Resolve Studio is installed.")
+        return _not_connected_error()
     ms = r.GetMediaStorage()
 
     if action == "get_volumes":
@@ -24936,8 +25039,7 @@ def _execute_python_script(path: str, args: List[str],
 def _execute_lua_script(path: str) -> Dict[str, Any]:
     r = get_resolve()
     if r is None:
-        return _err("Cannot run Lua script — Resolve isn't running and "
-                    "auto-launch failed.")
+        return _not_connected_error()
     fusion = r.Fusion()
     if fusion is None:
         return _err("handle.Fusion() returned None — cannot run Lua scripts.")
@@ -25002,7 +25104,7 @@ def _run_inline_lua(source: str) -> Dict[str, Any]:
     """
     r = get_resolve()
     if r is None:
-        return _err("Cannot run Lua — Resolve isn't running and auto-launch failed.")
+        return _not_connected_error()
     fusion = r.Fusion()
     if fusion is None:
         return _err("handle.Fusion() returned None — cannot run inline Lua.")
@@ -26112,5 +26214,5 @@ if __name__ == "__main__":
         logger.error(f"Unknown --transport {transport!r}; use stdio|sse|streamable-http")
         sys.exit(2)
 
-    logger.info(f"Starting DaVinci Resolve MCP Server (32 compound tools)")
+    logger.info("Starting DaVinci Resolve MCP Server (34 compound tools)")
     run_fastmcp_stdio(mcp)

package/src/utils/bridge_differential.py

@@ -182,12 +182,22 @@ def probe_surface(roots: Sequence[str] = SOURCE_ROOTS) -> Dict[str, Any]:
 #: MediaPoolItem or Graph — which between them carry most of the read surface
 #: worth qualifying (LUTs, node graphs, source timings, metadata).
 _INDEX = "[]"
+#: Pick the first element of a returned list for which `method()` is truthy.
+#: Indexing blindly is not good enough: a timeline's first video item is often a
+#: generator or a title, which has no MediaPoolItem and answers None to every
+#: node-graph question. Measured on a real timeline — `GetNumNodes` and
+#: `GetNodeGraph` both None on an SMPTE Color Bar, and 1 and a live graph on the
+#: clip sitting next to it. Taking index 0 therefore reported the whole grading
+#: surface as unreachable, which is the silent coverage gap this module exists to
+#: refuse.
+_FIRST_WITH = "[first-with]"
 
 _PM = ("GetProjectManager", ())
 _PROJECT = (_PM, ("GetCurrentProject", ()))
 _POOL = _PROJECT + (("GetMediaPool", ()),)
 _TIMELINE = _PROJECT + (("GetCurrentTimeline", ()),)
-_TIMELINE_ITEM = _TIMELINE + (("GetItemListInTrack", ("video", 1)), (_INDEX, (0,)))
+_TIMELINE_ITEM = _TIMELINE + (("GetItemListInTrack", ("video", 1)),
+                              (_FIRST_WITH, ("GetMediaPoolItem",)))
 _GALLERY = _PROJECT + (("GetGallery", ()),)
 
 OBJECT_GRAPH: Tuple[Tuple[str, Tuple[Any, ...]], ...] = (
@@ -229,6 +239,22 @@ def walk(resolve: Any, chain: Iterable[Tuple[str, Tuple[Any, ...]]]) -> Any:
                 return None
             current = current[index]
             continue
+        if method == _FIRST_WITH:
+            if not isinstance(current, (list, tuple)):
+                return None
+            probe = args[0]
+            chosen = None
+            for candidate in current:
+                try:
+                    if getattr(candidate, probe, lambda: None)():
+                        chosen = candidate
+                        break
+                except Exception:  # noqa: BLE001 - an unusable candidate, not a verdict
+                    continue
+            if chosen is None:
+                return None
+            current = chosen
+            continue
         function = getattr(current, method, None)
         if function is None:
             return None