bohr-agent-sdk 0.1.122__tar.gz → 0.1.123__tar.gz

{bohr_agent_sdk-0.1.122 → bohr_agent_sdk-0.1.123}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bohr-agent-sdk
-Version: 0.1.122
+Version: 0.1.123
 Summary: SDK for scientific agents
 Home-page: https://github.com/dptech-corp/bohr-agent-sdk/
 Author: DP Technology

{bohr_agent_sdk-0.1.122 → bohr_agent_sdk-0.1.123}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="bohr-agent-sdk",
-    version="0.1.122",
+    version="0.1.123",
     description="SDK for science agent and mcp tools",
     long_description=long_description,
     long_description_content_type="text/markdown",

{bohr_agent_sdk-0.1.122 → bohr_agent_sdk-0.1.123}/src/bohr_agent_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bohr-agent-sdk
-Version: 0.1.122
+Version: 0.1.123
 Summary: SDK for scientific agents
 Home-page: https://github.com/dptech-corp/bohr-agent-sdk/
 Author: DP Technology

{bohr_agent_sdk-0.1.122 → bohr_agent_sdk-0.1.123}/src/bohr_agent_sdk.egg-info/SOURCES.txt

@@ -84,4 +84,5 @@ src/dp/agent/server/storage/bohrium_storage.py
 src/dp/agent/server/storage/http_storage.py
 src/dp/agent/server/storage/local_storage.py
 src/dp/agent/server/storage/oss_storage.py
+tests/test_calculation_mcp_server.py
 tests/test_cli.py

{bohr_agent_sdk-0.1.122 → bohr_agent_sdk-0.1.123}/src/dp/agent/server/calculation_mcp_server.py

@@ -7,7 +7,7 @@ from copy import deepcopy
 from datetime import datetime
 from pathlib import Path
 from urllib.parse import urlparse
-from typing import Annotated, Literal, Optional, List, Dict
+from typing import Annotated, Literal, Optional, List, Dict, Union, Any, get_origin, get_args
 
 from mcp.server.fastmcp import FastMCP
 from mcp.server.fastmcp.utilities.context_injection import (
@@ -30,12 +30,18 @@ CALCULATION_MCP_WORKDIR = os.getenv("CALCULATION_MCP_WORKDIR", os.getcwd())
 
 
 def parse_uri(uri):
-    scheme = urlparse(uri).scheme
+    parsed = urlparse(uri)
+    scheme = parsed.scheme
     if scheme == "":
         key = uri
         scheme = "local"
     else:
-        key = uri[len(scheme)+3:]
+        if parsed.netloc:
+            key = parsed.netloc + parsed.path
+        else:
+            key = parsed.path
+        if parsed.query:
+            key += "?" + parsed.query
     return scheme, key
 
 
@@ -105,96 +111,128 @@ def terminate_job(job_id: str, executor: Optional[dict] = None):
         logger.info("Job %s is terminated" % job_id)
 
 
+def _normalize_annotation(ann):
+    if ann is None:
+        return None
+    origin = get_origin(ann)
+    if origin is Annotated:
+        return _normalize_annotation(get_args(ann)[0])
+    if origin is Union:
+        args = get_args(ann)
+        if type(None) in args:
+            non_none = [a for a in args if a is not type(None)]
+            if non_none:
+                return _normalize_annotation(non_none[0])
+    return ann
+
+
+def _download_artifact(uri, storage, storage_type, input_artifacts,
+                       input_name, path_trace):
+    scheme, key = parse_uri(uri)
+    if scheme == storage_type:
+        s = storage
+    else:
+        s = storage_dict[scheme]()
+    rel = "/".join(str(p) for p in path_trace) if path_trace else ""
+    download_dir = os.path.join("inputs", input_name, rel) if rel else os.path.join("inputs", input_name)
+    os.makedirs(download_dir, exist_ok=True)
+    path = s.download(key, download_dir)
+    logger.info("Artifact %s downloaded to %s" % (uri, path))
+    if input_name not in input_artifacts:
+        input_artifacts[input_name] = {"storage_type": scheme, "uri": []}
+    if isinstance(input_artifacts[input_name].get("uri"), list):
+        input_artifacts[input_name]["uri"].append(uri)
+    return path
+
+
+def _traverse_and_process(value, annotation, storage_type, storage,
+                          input_artifacts, input_name, path_trace=None):
+    if path_trace is None:
+        path_trace = []
+    ann = _normalize_annotation(annotation)
+    if ann is None:
+        return value
+    origin = get_origin(ann)
+    args = get_args(ann)
+
+    # Path: only when resolved annotation is Path (Optional[Path] is normalized to Path)
+    if ann is Path:
+        s = str(value)
+        if not s:
+            return Path(".")
+        parsed = urlparse(s)
+        if parsed.scheme and len(parsed.scheme) > 1:
+            return Path(_download_artifact(
+                s, storage, storage_type, input_artifacts, input_name, path_trace))
+        return Path(value)
+
+    # BaseModel: schema-driven traversal over model fields (check before dict so nesting works)
+    if isinstance(ann, type) and issubclass(ann, BaseModel):
+        # Convert to dict for traversal; re-instantiate to model at the end so callers get objects
+        if isinstance(value, BaseModel):
+            value = value.model_dump()
+        if not isinstance(value, dict):
+            return value
+        out = dict(value)
+        for field_name, field_info in ann.model_fields.items():
+            if field_name in out and out[field_name] is not None:
+                out[field_name] = _traverse_and_process(
+                    out[field_name],
+                    field_info.annotation,
+                    storage_type,
+                    storage,
+                    input_artifacts,
+                    input_name,
+                    path_trace + [field_name],
+                )
+        # Re-instantiate so tool functions receive model instances (dot notation works)
+        try:
+            return ann.model_validate(out)
+        except Exception as e:
+            logger.warning("Failed to re-instantiate model %s: %s", ann.__name__, e)
+            return out
+
+    # List: use inner type from type args
+    if origin in (list, List) and isinstance(value, (list, tuple)):
+        inner = _normalize_annotation(args[0]) if args else Any
+        return [
+            _traverse_and_process(
+                item, inner, storage_type, storage,
+                input_artifacts, input_name, path_trace + [i])
+            for i, item in enumerate(value)
+        ]
+
+    # Dict: use value type from type args (e.g. Dict[str, Path] processes values as Path)
+    if origin in (dict, Dict) and isinstance(value, dict):
+        value_type = _normalize_annotation(args[1]) if (args and len(args) > 1) else Any
+        return {
+            k: _traverse_and_process(
+                v, value_type, storage_type, storage,
+                input_artifacts, input_name, path_trace + [k])
+            for k, v in value.items()
+        }
+
+    return value
+
+
 def handle_input_artifacts(fn, kwargs, storage):
     storage_type, storage = init_storage(storage)
-    sig = inspect.signature(fn)
+    sig = inspect.signature(fn, eval_str=True)
     input_artifacts = {}
+    new_kwargs = {}
     for name, param in sig.parameters.items():
-        if param.annotation is Path or (
-            param.annotation is Optional[Path] and
-                kwargs.get(name) is not None):
-            uri = kwargs[name]
-            scheme, key = parse_uri(uri)
-            if scheme == storage_type:
-                s = storage
-            else:
-                s = storage_dict[scheme]()
-            path = s.download(key, "inputs/%s" % name)
-            logger.info("Artifact %s downloaded to %s" % (
-                uri, path))
-            kwargs[name] = Path(path)
-            input_artifacts[name] = {
-                "storage_type": scheme,
-                "uri": uri,
-            }
-        elif param.annotation is List[Path] or (
-            param.annotation is Optional[List[Path]] and
-                kwargs.get(name) is not None):
-            uris = kwargs[name]
-            new_paths = []
-            for i, uri in enumerate(uris):
-                scheme, key = parse_uri(uri)
-                if scheme == storage_type:
-                    s = storage
-                else:
-                    s = storage_dict[scheme]()
-                dest_dir = Path("inputs") / name / f"item_{i:03d}"
-                dest_dir.mkdir(parents=True, exist_ok=True)
-                path = s.download(key, str(dest_dir))
-                new_paths.append(Path(path))
-                logger.info("Artifact %s downloaded to %s" % (
-                    uri, path))
-            kwargs[name] = new_paths
-            input_artifacts[name] = {
-                "storage_type": storage_type,
-                "uri": uris,
-            }
-        elif param.annotation is Dict[str, Path] or (
-            param.annotation is Optional[Dict[str, Path]] and
-                kwargs.get(name) is not None):
-            uris_dict = kwargs[name]
-            new_paths_dict = {}
-            for key_name, uri in uris_dict.items():
-                scheme, key = parse_uri(uri)
-                if scheme == storage_type:
-                    s = storage
-                else:
-                    s = storage_dict[scheme]()
-                path = s.download(key, f"inputs/{name}/{key_name}")
-                new_paths_dict[key_name] = Path(path)
-                logger.info("Artifact %s (key=%s) downloaded to %s" % (
-                    uri, key_name, path))
-            kwargs[name] = new_paths_dict
-            input_artifacts[name] = {
-                "storage_type": storage_type,
-                "uri": uris_dict,
-            }
-        elif param.annotation is Dict[str, List[Path]] or (
-            param.annotation is Optional[Dict[str, List[Path]]] and
-                kwargs.get(name) is not None):
-            uris_dict = kwargs[name]
-            new_paths_dict = {}
-            for key_name, uris in uris_dict.items():
-                new_paths = []
-                for i, uri in enumerate(uris):
-                    scheme, key = parse_uri(uri)
-                    if scheme == storage_type:
-                        s = storage
-                    else:
-                        s = storage_dict[scheme]()
-                    dest_dir = Path("inputs") / name / key_name / f"item_{i:03d}"
-                    dest_dir.mkdir(parents=True, exist_ok=True)
-                    path = s.download(key, str(dest_dir))
-                    new_paths.append(Path(path))
-                    logger.info("Artifact %s (key=%s) downloaded to %s" % (
-                        uri, key_name, path))
-                new_paths_dict[key_name] = new_paths
-            kwargs[name] = new_paths_dict
-            input_artifacts[name] = {
-                "storage_type": storage_type,
-                "uri": uris_dict,
-            }
-    return kwargs, input_artifacts
+        if name not in kwargs:
+            if param.default is not inspect.Parameter.empty:
+                new_kwargs[name] = param.default
+            continue
+        val = kwargs[name]
+        if val is None and _normalize_annotation(param.annotation) != param.annotation:
+            new_kwargs[name] = val
+            continue
+        new_kwargs[name] = _traverse_and_process(
+            val, param.annotation, storage_type, storage,
+            input_artifacts, name)
+    return new_kwargs, input_artifacts
 
 
 def handle_output_artifacts(results, exec_id, storage):
@@ -269,6 +307,57 @@ annotation_map = {
 }
 
 
+# Cache for schema models derived from BaseModel (Path -> str in JSON schema)
+_schema_model_cache: Dict[type, type] = {}
+
+def get_schema_annotation(annotation: Any) -> Any:
+    """
+    Map an annotation to the type used in JSON schema (e.g. Path -> str).
+    For BaseModel, build a schema model with the same structure but Path fields as str.
+    Handles List[...], Dict[...], Optional[...] and nested BaseModel recursively.
+    """
+    if annotation is None or annotation is type(None):
+        return annotation
+    origin = get_origin(annotation)
+    if origin is Annotated:
+        return get_schema_annotation(get_args(annotation)[0])
+    if origin is Union:
+        args = get_args(annotation)
+        if type(None) in args:
+            non_none = [a for a in args if a is not type(None)]
+            if len(non_none) == 1:
+                return Optional[get_schema_annotation(non_none[0])]
+    if annotation in annotation_map:
+        return annotation_map[annotation]
+    # List[X] -> List[schema(X)] so e.g. List[BaseModel] becomes List[BaseModelSchema]
+    if origin in (list, List):
+        type_args = get_args(annotation)
+        inner = get_schema_annotation(type_args[0]) if type_args else Any
+        return List[inner]
+    # Dict[K, V] -> Dict[K, schema(V)]
+    if origin in (dict, Dict):
+        type_args = get_args(annotation)
+        if type_args and len(type_args) >= 2:
+            return Dict[type_args[0], get_schema_annotation(type_args[1])]
+        return annotation
+    if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+        if annotation not in _schema_model_cache:
+            schema_fields = {}
+            for name, field_info in annotation.model_fields.items():
+                fa = get_schema_annotation(field_info.annotation)
+                if field_info.is_required():
+                    schema_fields[name] = (fa, Field())
+                else:
+                    default = getattr(field_info, "default", None)
+                    schema_fields[name] = (fa, Field(default=default))
+            _schema_model_cache[annotation] = create_model(
+                f"{annotation.__name__}Schema",
+                **schema_fields,
+            )
+        return _schema_model_cache[annotation]
+    return annotation
+
+
 class SubmitResult(BaseModel):
     job_id: str
     extra_info: dict | None = None
@@ -329,11 +418,8 @@ class CalculationMCPServer:
         for n, annotation in \
                 func_arg_metadata.arg_model.__annotations__.items():
             param = params[n]
-            if param.annotation in annotation_map:
-                model_params[n] = Annotated[
-                    (annotation_map[param.annotation], Field())]
-            else:
-                model_params[n] = annotation
+            schema_ann = get_schema_annotation(param.annotation)
+            model_params[n] = Annotated[(schema_ann, Field())]
             if param.default is not inspect.Parameter.empty:
                 model_params[n] = (model_params[n], param.default)
         for n, param in inspect.signature(new_fn).parameters.items():

{bohr_agent_sdk-0.1.122 → bohr_agent_sdk-0.1.123}/src/dp/agent/server/executor/dispatcher_executor.py

@@ -200,6 +200,9 @@ class DispatcherExecutor(BaseExecutor):
             if isinstance(value, Path):
                 forward_files.append(str(value))
 
+        if os.path.isdir("inputs") and "inputs" not in forward_files:
+            forward_files.append("inputs")
+
         task = {
             "task_work_path": "./",
             "outlog": "log",

bohr_agent_sdk-0.1.123/tests/test_calculation_mcp_server.py

@@ -0,0 +1,357 @@
+"""
+Unit tests for calculation_mcp_server: get_schema_annotation and _traverse_and_process.
+"""
+from pathlib import Path
+from typing import Annotated, Any, Dict, List, Optional
+from unittest.mock import patch, MagicMock
+
+import pytest
+from pydantic import BaseModel
+
+from dp.agent.server.calculation_mcp_server import (
+    get_schema_annotation,
+    _schema_model_cache,
+    _traverse_and_process,
+)
+
+
+def _clear_schema_cache():
+    _schema_model_cache.clear()
+
+
+# --- get_schema_annotation ---
+
+
+def test_get_schema_annotation_none():
+    assert get_schema_annotation(None) is None
+
+
+def test_get_schema_annotation_type_none():
+    assert get_schema_annotation(type(None)) is type(None)
+
+
+def test_get_schema_annotation_annotated_path():
+    ann = Annotated[Path, "path field"]
+    result = get_schema_annotation(ann)
+    assert result is str
+
+
+def test_get_schema_annotation_annotated_nested():
+    ann = Annotated[Annotated[Optional[Path], "x"], "y"]
+    result = get_schema_annotation(ann)
+    assert result == Optional[str]
+
+
+def test_get_schema_annotation_optional_path():
+    assert get_schema_annotation(Optional[Path]) == Optional[str]
+
+
+def test_get_schema_annotation_optional_str():
+    assert get_schema_annotation(Optional[str]) == Optional[str]
+
+
+def test_get_schema_annotation_path():
+    assert get_schema_annotation(Path) is str
+
+
+def test_get_schema_annotation_list_path():
+    assert get_schema_annotation(List[Path]) == List[str]
+
+
+def test_get_schema_annotation_optional_list_path():
+    assert get_schema_annotation(Optional[List[Path]]) == Optional[List[str]]
+
+
+def test_get_schema_annotation_dict_str_path():
+    assert get_schema_annotation(Dict[str, Path]) == Dict[str, str]
+
+
+def test_get_schema_annotation_optional_dict_str_path():
+    assert get_schema_annotation(Optional[Dict[str, Path]]) == Optional[Dict[str, str]]
+
+
+def test_get_schema_annotation_dict_str_list_path():
+    assert get_schema_annotation(Dict[str, List[Path]]) == Dict[str, List[str]]
+
+
+def test_get_schema_annotation_list_str():
+    assert get_schema_annotation(List[str]) == List[str]
+
+
+def test_get_schema_annotation_list_any():
+    assert get_schema_annotation(List[Any]) == List[Any]
+
+
+def test_get_schema_annotation_dict_value_schema():
+    assert get_schema_annotation(Dict[str, List[Path]]) == Dict[str, List[str]]
+
+
+def test_get_schema_annotation_dict_no_args_unchanged():
+    assert get_schema_annotation(dict) is dict
+
+
+def test_get_schema_annotation_basemodel_with_path_field():
+    class ModelWithPath(BaseModel):
+        name: str
+        data_path: Path
+
+    _clear_schema_cache()
+    schema_ann = get_schema_annotation(ModelWithPath)
+    assert schema_ann is not ModelWithPath
+    assert hasattr(schema_ann, "model_fields")
+    assert "name" in schema_ann.model_fields
+    assert "data_path" in schema_ann.model_fields
+    assert schema_ann.model_fields["data_path"].annotation is str
+    assert schema_ann.model_fields["name"].annotation is str
+
+
+def test_get_schema_annotation_basemodel_cached():
+    class CachedModel(BaseModel):
+        x: Path
+
+    _clear_schema_cache()
+    first = get_schema_annotation(CachedModel)
+    second = get_schema_annotation(CachedModel)
+    assert first is second
+    assert CachedModel in _schema_model_cache
+
+
+def test_get_schema_annotation_basemodel_nested():
+    class Inner(BaseModel):
+        path_field: Path
+
+    class Outer(BaseModel):
+        inner: Inner
+        top_path: Optional[Path] = None
+
+    _clear_schema_cache()
+    schema_ann = get_schema_annotation(Outer)
+    assert "inner" in schema_ann.model_fields
+    assert "top_path" in schema_ann.model_fields
+    inner_schema = schema_ann.model_fields["inner"].annotation
+    assert hasattr(inner_schema, "model_fields")
+    assert inner_schema.model_fields["path_field"].annotation is str
+    assert schema_ann.model_fields["top_path"].annotation == Optional[str]
+
+
+def test_get_schema_annotation_plain_types():
+    assert get_schema_annotation(str) is str
+    assert get_schema_annotation(int) is int
+    assert get_schema_annotation(bool) is bool
+
+
+# --- _traverse_and_process ---
+
+
+def test_traverse_annotation_none_returns_value():
+    value = {"a": 1}
+    result = _traverse_and_process(
+        value, None, "local", MagicMock(), {}, "input_name"
+    )
+    assert result == value
+
+
+def test_traverse_primitive_str_unchanged():
+    result = _traverse_and_process(
+        "hello", str, "local", MagicMock(), {}, "input_name"
+    )
+    assert result == "hello"
+
+
+def test_traverse_primitive_int_unchanged():
+    result = _traverse_and_process(
+        42, int, "local", MagicMock(), {}, "input_name"
+    )
+    assert result == 42
+
+
+def test_traverse_path_local_string():
+    result = _traverse_and_process(
+        "/tmp/foo", Path, "local", MagicMock(), {}, "input_name"
+    )
+    assert result == Path("/tmp/foo")
+
+
+def test_traverse_path_empty_string_returns_dot():
+    result = _traverse_and_process(
+        "", Path, "local", MagicMock(), {}, "input_name"
+    )
+    assert result == Path(".")
+
+
+def test_traverse_path_uri_calls_download():
+    input_artifacts = {}
+    mock_storage = MagicMock()
+    with patch(
+        "dp.agent.server.calculation_mcp_server._download_artifact",
+        return_value="/downloaded/path",
+    ) as mock_download:
+        result = _traverse_and_process(
+            "local://bucket/key",
+            Path,
+            "local",
+            mock_storage,
+            input_artifacts,
+            "data",
+        )
+    assert result == Path("/downloaded/path")
+    mock_download.assert_called_once()
+    call_kw = mock_download.call_args
+    assert call_kw[0][0] == "local://bucket/key"
+    assert call_kw[0][-1] == []
+
+
+def test_traverse_path_uri_appends_path_trace():
+    input_artifacts = {}
+    with patch(
+        "dp.agent.server.calculation_mcp_server._download_artifact",
+        return_value="/downloaded/path",
+    ) as mock_download:
+        _traverse_and_process(
+            "http://example.com/file",
+            Path,
+            "local",
+            MagicMock(),
+            input_artifacts,
+            "input_name",
+            path_trace=["config", "file"],
+        )
+    call_args = mock_download.call_args[0]
+    assert call_args[-1] == ["config", "file"]
+
+
+def test_traverse_list_of_paths_local():
+    value = ["/a", "/b"]
+    result = _traverse_and_process(
+        value, List[Path], "local", MagicMock(), {}, "input_name"
+    )
+    assert result == [Path("/a"), Path("/b")]
+
+
+def test_traverse_list_path_trace():
+    value = ["/a", "/b"]
+    result = _traverse_and_process(
+        value,
+        List[Path],
+        "local",
+        MagicMock(),
+        {},
+        "input_name",
+        path_trace=["items"],
+    )
+    assert result == [Path("/a"), Path("/b")]
+
+
+def test_traverse_list_nested_basemodel():
+    class Item(BaseModel):
+        path: Path
+
+    value = [{"path": "/p1"}, {"path": "/p2"}]
+    result = _traverse_and_process(
+        value, List[Item], "local", MagicMock(), {}, "input_name"
+    )
+    assert len(result) == 2
+    assert result[0].path == Path("/p1")
+    assert result[1].path == Path("/p2")
+
+
+def test_traverse_dict_str_path():
+    value = {"a": "/path/a", "b": "/path/b"}
+    result = _traverse_and_process(
+        value, Dict[str, Path], "local", MagicMock(), {}, "input_name"
+    )
+    assert result == {"a": Path("/path/a"), "b": Path("/path/b")}
+
+
+def test_traverse_dict_path_trace():
+    value = {"x": "/x"}
+    result = _traverse_and_process(
+        value,
+        Dict[str, Path],
+        "local",
+        MagicMock(),
+        {},
+        "input_name",
+        path_trace=["config"],
+    )
+    assert result == {"x": Path("/x")}
+
+
+def test_traverse_basemodel_from_dict():
+    class Model(BaseModel):
+        name: str
+        data_path: Path
+
+    value = {"name": "test", "data_path": "/tmp/data"}
+    result = _traverse_and_process(
+        value, Model, "local", MagicMock(), {}, "input_name"
+    )
+    assert isinstance(result, Model)
+    assert result.name == "test"
+    assert result.data_path == Path("/tmp/data")
+
+
+def test_traverse_basemodel_from_instance():
+    class Model(BaseModel):
+        path: Path
+
+    inst = Model(path="/foo")
+    result = _traverse_and_process(
+        inst, Model, "local", MagicMock(), {}, "input_name"
+    )
+    assert isinstance(result, Model)
+    assert result.path == Path("/foo")
+
+
+def test_traverse_basemodel_nested():
+    class Inner(BaseModel):
+        p: Path
+
+    class Outer(BaseModel):
+        inner: Inner
+        label: str
+
+    value = {"inner": {"p": "/nested"}, "label": "ok"}
+    result = _traverse_and_process(
+        value, Outer, "local", MagicMock(), {}, "input_name"
+    )
+    assert isinstance(result, Outer)
+    assert result.inner.p == Path("/nested")
+    assert result.label == "ok"
+
+
+def test_traverse_basemodel_skips_none_fields():
+    class Model(BaseModel):
+        required: Path
+        optional: Optional[Path] = None
+
+    value = {"required": "/r", "optional": None}
+    result = _traverse_and_process(
+        value, Model, "local", MagicMock(), {}, "input_name"
+    )
+    assert result.required == Path("/r")
+    assert result.optional is None
+
+
+def test_traverse_basemodel_non_dict_value_returned_unchanged():
+    class Model(BaseModel):
+        x: int
+
+    result = _traverse_and_process(
+        "not a dict", Model, "local", MagicMock(), {}, "input_name"
+    )
+    assert result == "not a dict"
+
+
+def test_traverse_optional_path_present():
+    result = _traverse_and_process(
+        "/some/path", Optional[Path], "local", MagicMock(), {}, "input_name"
+    )
+    assert result == Path("/some/path")
+
+
+def test_traverse_optional_path_none():
+    with pytest.raises(TypeError, match="expected str, bytes or os.PathLike"):
+        _traverse_and_process(
+            None, Optional[Path], "local", MagicMock(), {}, "input_name"
+        )