ng-postcode-mcp 0.2.4__tar.gz → 0.4.0__tar.gz

{ng_postcode_mcp-0.2.4 → ng_postcode_mcp-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ng-postcode-mcp
-Version: 0.2.4
+Version: 0.4.0
 Summary: MCP server for Nigeria's NIPOST digital postcode (NDAPS): validate, look up, reverse-geocode and resolve addresses to postcodes.
 Project-URL: Repository, https://github.com/Adeniyikayodee/ng-postcode
 Project-URL: Issues, https://github.com/Adeniyikayodee/ng-postcode/issues
@@ -104,11 +104,25 @@ Most clients take this entry in their MCP settings:
 | `NG_POSTCODE_BASE_URL` | `https://api.postcode.gov.ng` | Alternative API host, such as a staging stack. |
 | `NG_GEOCODER_URL` | none | A Nominatim server `resolve_address` uses to place described addresses. Without it, only typed postcodes and location pins resolve. |
 | `NG_GEOCODER_CONTACT` | none | A URL or email sent in the User-Agent. Required for the public Nominatim. |
+| `NG_POSTCODE_TRANSPORT` | `stdio` | `http` serves streamable HTTP at `/mcp` instead. |
+| `NG_POSTCODE_HOST`, `NG_POSTCODE_PORT` | `127.0.0.1`, `8000` | Where the HTTP transport listens. |
 
 The public Nominatim at `https://nominatim.openstreetmap.org` allows light personal use only; a service whose main job is geocoding must run its own instance. Map data © OpenStreetMap contributors.
 
+## HTTP and Docker
+
+```sh
+NG_POSTCODE_TRANSPORT=http uvx ng-postcode-mcp        # http://127.0.0.1:8000/mcp
+docker build -t ng-postcode-mcp . && docker run --rm -i ng-postcode-mcp   # from the repository root
+```
+
+Over HTTP a caller can send its own NIPOST key in the `X-NIPOST-API-Key` header, and that key is used for that caller's requests only. A caller that sends none uses the server's key, if `NG_POSTCODE_API_KEY` is set.
+
+To host the server for other people, leave `NG_POSTCODE_API_KEY` unset so every caller brings a key, and serve it over HTTPS so the header is encrypted. Callers are trusting the host with their key, and all of them share the host's geocoder, which answers one search a second. Validation still works without any key. If you do set a server key, anyone who can reach the server spends its credits, so keep it on loopback or behind your own authentication. `NG_POSTCODE_MAX_LEVEL` caps every caller either way.
+
 ## Safety
 
+- The key is read from the environment or the `X-NIPOST-API-Key` header, never from tool arguments, and never appears in results or logs.
 - Lookups default to level 1, which is free. A model cannot spend credits unless you raise `NG_POSTCODE_MAX_LEVEL`.
 - A mistyped code is never corrected and sent to the API silently. The server returns the suggestion and asks the model to confirm it with the user.
 - Levels 2 and up return house addresses. Treat them as personal data under the Nigeria Data Protection Act.

{ng_postcode_mcp-0.2.4 → ng_postcode_mcp-0.4.0}/README.md

@@ -76,11 +76,25 @@ Most clients take this entry in their MCP settings:
 | `NG_POSTCODE_BASE_URL` | `https://api.postcode.gov.ng` | Alternative API host, such as a staging stack. |
 | `NG_GEOCODER_URL` | none | A Nominatim server `resolve_address` uses to place described addresses. Without it, only typed postcodes and location pins resolve. |
 | `NG_GEOCODER_CONTACT` | none | A URL or email sent in the User-Agent. Required for the public Nominatim. |
+| `NG_POSTCODE_TRANSPORT` | `stdio` | `http` serves streamable HTTP at `/mcp` instead. |
+| `NG_POSTCODE_HOST`, `NG_POSTCODE_PORT` | `127.0.0.1`, `8000` | Where the HTTP transport listens. |
 
 The public Nominatim at `https://nominatim.openstreetmap.org` allows light personal use only; a service whose main job is geocoding must run its own instance. Map data © OpenStreetMap contributors.
 
+## HTTP and Docker
+
+```sh
+NG_POSTCODE_TRANSPORT=http uvx ng-postcode-mcp        # http://127.0.0.1:8000/mcp
+docker build -t ng-postcode-mcp . && docker run --rm -i ng-postcode-mcp   # from the repository root
+```
+
+Over HTTP a caller can send its own NIPOST key in the `X-NIPOST-API-Key` header, and that key is used for that caller's requests only. A caller that sends none uses the server's key, if `NG_POSTCODE_API_KEY` is set.
+
+To host the server for other people, leave `NG_POSTCODE_API_KEY` unset so every caller brings a key, and serve it over HTTPS so the header is encrypted. Callers are trusting the host with their key, and all of them share the host's geocoder, which answers one search a second. Validation still works without any key. If you do set a server key, anyone who can reach the server spends its credits, so keep it on loopback or behind your own authentication. `NG_POSTCODE_MAX_LEVEL` caps every caller either way.
+
 ## Safety
 
+- The key is read from the environment or the `X-NIPOST-API-Key` header, never from tool arguments, and never appears in results or logs.
 - Lookups default to level 1, which is free. A model cannot spend credits unless you raise `NG_POSTCODE_MAX_LEVEL`.
 - A mistyped code is never corrected and sent to the API silently. The server returns the suggestion and asks the model to confirm it with the user.
 - Levels 2 and up return house addresses. Treat them as personal data under the Nigeria Data Protection Act.

{ng_postcode_mcp-0.2.4 → ng_postcode_mcp-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ng-postcode-mcp"
-version = "0.2.4"
+version = "0.4.0"
 description = "MCP server for Nigeria's NIPOST digital postcode (NDAPS): validate, look up, reverse-geocode and resolve addresses to postcodes."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -36,7 +36,7 @@ Repository = "https://github.com/Adeniyikayodee/ng-postcode"
 Issues = "https://github.com/Adeniyikayodee/ng-postcode/issues"
 
 [dependency-groups]
-dev = ["jsonschema>=4.20", "mypy>=1.13", "pytest>=8", "ruff>=0.8"]
+dev = ["jsonschema>=4.20", "mypy>=1.13", "pytest>=8", "ruff>=0.8", "types-jsonschema>=4.20"]
 
 # Inside the repository, build against the local packages so they never drift.
 [tool.uv.sources]

{ng_postcode_mcp-0.2.4 → ng_postcode_mcp-0.4.0}/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.Adeniyikayodee/ng-postcode",
   "title": "Nigeria Postcode",
   "description": "Validate, look up and resolve addresses to Nigeria's NIPOST digital postcodes (NDAPS).",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "repository": {
     "url": "https://github.com/Adeniyikayodee/ng-postcode",
     "source": "github",
@@ -13,7 +13,7 @@
     {
       "registryType": "pypi",
       "identifier": "ng-postcode-mcp",
-      "version": "0.2.4",
+      "version": "0.4.0",
       "runtimeHint": "uvx",
       "transport": {
         "type": "stdio"
@@ -44,6 +44,15 @@
         {
           "name": "NG_GEOCODER_CONTACT",
           "description": "URL or email identifying you to the geocoder. Required for the public Nominatim."
+        },
+        {
+          "name": "NG_POSTCODE_TRANSPORT",
+          "description": "stdio (default), or http to serve streamable HTTP at /mcp on NG_POSTCODE_HOST and NG_POSTCODE_PORT.",
+          "default": "stdio",
+          "choices": [
+            "stdio",
+            "http"
+          ]
         }
       ]
     }

{ng_postcode_mcp-0.2.4 → ng_postcode_mcp-0.4.0}/src/ng_postcode_mcp/server.py

@@ -3,7 +3,9 @@
 Validation runs offline. Lookup, autocomplete and reverse geocoding call the
 postcode.gov.ng API with the key in NG_POSTCODE_API_KEY, which never appears in
 tool arguments or results. Address resolution also searches the geocoder in
-NG_GEOCODER_URL. stdout carries the protocol, so nothing else may print to it.
+NG_GEOCODER_URL. Over stdio, stdout carries the protocol, so nothing else may
+print to it. Over HTTP, a caller may send its own key in the X-NIPOST-API-Key
+header; without one it uses the server's key, if the server has one.
 """
 
 from __future__ import annotations
@@ -33,12 +35,14 @@ from ng_postcode.api import (
     lookup,
     reverse,
 )
-from ng_postcode.client import AsyncClient, TransportError
+from ng_postcode.client import TIMEOUT, AsyncClient, TransportError
 from pydantic import BaseModel, ConfigDict, Field
 
 T = TypeVar("T")
 
 KEY_URL = "https://dashboard.postcode.gov.ng"
+KEY_HEADER = "x-nipost-api-key"
+MAX_KEY_LENGTH = 256
 
 INSTRUCTIONS = """\
 Tools for Nigeria's 11-character building postcode, e.g. EK-01-A03-FK-01 \
@@ -59,8 +63,8 @@ READ_ONLY_OFFLINE = ToolAnnotations(
 READ_ONLY_ONLINE = ToolAnnotations(read_only_hint=True, idempotent_hint=True, open_world_hint=True)
 
 HINTS = {
-    "auth_required": f"Set NG_POSTCODE_API_KEY to a key from {KEY_URL}.",
-    "invalid_api_key": f"NG_POSTCODE_API_KEY is invalid or revoked; create a new key at {KEY_URL}.",
+    "auth_required": f"Supply a NIPOST API key from {KEY_URL}.",
+    "invalid_api_key": f"The NIPOST API key is invalid or revoked; create a new key at {KEY_URL}.",
     "insufficient_credits": "The NIPOST account is out of credits; top up or use level 1.",
     "level_not_granted": "The key is not granted this lookup level; use a lower level or "
     f"request more access at {KEY_URL}.",
@@ -79,6 +83,9 @@ class Settings:
     base_url: str = BASE_URL
     geocoder_url: str | None = None
     geocoder_contact: str | None = None
+    transport: Literal["stdio", "http"] = "stdio"
+    host: str = "127.0.0.1"
+    port: int = 8000
 
 
 def settings_from_env(env: Mapping[str, str]) -> Settings | str:
@@ -90,12 +97,21 @@ def settings_from_env(env: Mapping[str, str]) -> Settings | str:
     geocoder_contact = env.get("NG_GEOCODER_CONTACT", "").strip() or None
     if geocoder_url == PUBLIC_NOMINATIM and geocoder_contact is None:
         return "the public Nominatim requires NG_GEOCODER_CONTACT, a URL or email identifying you"
+    transport = env.get("NG_POSTCODE_TRANSPORT", "stdio").strip().lower()
+    if transport not in ("stdio", "http"):
+        return f"NG_POSTCODE_TRANSPORT must be stdio or http, got {transport!r}"
+    raw_port = env.get("NG_POSTCODE_PORT", "8000").strip()
+    if not (raw_port.isdecimal() and 0 < int(raw_port) < 65536):
+        return f"NG_POSTCODE_PORT must be 1 to 65535, got {raw_port!r}"
     return Settings(
         api_key=env.get("NG_POSTCODE_API_KEY", "").strip() or None,
         max_level=int(raw_level),
         base_url=env.get("NG_POSTCODE_BASE_URL", "").strip() or BASE_URL,
         geocoder_url=geocoder_url,
         geocoder_contact=geocoder_contact,
+        transport="http" if transport == "http" else "stdio",
+        host=env.get("NG_POSTCODE_HOST", "").strip() or "127.0.0.1",
+        port=int(raw_port),
     )
 
 
@@ -188,8 +204,11 @@ class Location(FromLibrary):
 
 @dataclass(frozen=True, slots=True)
 class State:
-    """What the tools share for the life of the server. Either part may be unconfigured."""
+    """What the tools share for the life of the server. `nipost` and `geocoder` may be
+    unconfigured."""
 
+    http: httpx.AsyncClient
+    base_url: str
     nipost: AsyncClient | None
     geocoder: Nominatim | None
 
@@ -204,17 +223,18 @@ def create_server(
 
     @asynccontextmanager
     async def lifespan(_: MCPServer[State]) -> AsyncIterator[State]:
+        shared = http if http is not None else httpx.AsyncClient(timeout=TIMEOUT)
         nipost = (
-            AsyncClient(settings.api_key, base_url=settings.base_url, http=http)
+            AsyncClient(settings.api_key, base_url=settings.base_url, http=shared)
             if settings.api_key
             else None
         )
         geocoder = geocoder_for(settings, geocoder_http)
         try:
-            yield State(nipost, geocoder)
+            yield State(shared, settings.base_url, nipost, geocoder)
         finally:
-            if nipost:
-                await nipost.aclose()
+            if http is None:
+                await shared.aclose()
             if geocoder:
                 await geocoder.aclose()
 
@@ -353,8 +373,8 @@ def create_server(
             if latitude is not None and longitude is not None
             else None
         )
-        state = ctx.request_context.lifespan_context
-        resolver = Resolver(nipost=state.nipost, geocoder=state.geocoder)
+        geocoder = ctx.request_context.lifespan_context.geocoder
+        resolver = Resolver(nipost=nipost_for(ctx), geocoder=geocoder)
         return await resolver.resolve(address, location, reading(landmarks, geocode_queries))
 
     return server
@@ -448,10 +468,25 @@ def checked(text: str) -> Postcode:
             raise ToolError(f"{text!r} is not a valid postcode: {error}.{maybe}")
 
 
+def nipost_for(ctx: Context[State, Any]) -> AsyncClient | None:
+    """The caller's own client when an HTTP request carries a key, else the server's."""
+    state = ctx.request_context.lifespan_context
+    sent = (v for k, v in (ctx.headers or {}).items() if k.lower() == KEY_HEADER)
+    key = next(sent, "").strip()
+    if not key:
+        return state.nipost
+    if not (key.isascii() and key.isprintable() and " " not in key and len(key) <= MAX_KEY_LENGTH):
+        raise ToolError("The X-NIPOST-API-Key header does not hold a usable NIPOST API key.")
+    return AsyncClient(key, base_url=state.base_url, http=state.http)
+
+
 def api(ctx: Context[State, Any]) -> AsyncClient:
-    client = ctx.request_context.lifespan_context.nipost
+    client = nipost_for(ctx)
     if client is None:
-        raise ToolError(f"This tool needs NG_POSTCODE_API_KEY. {HINTS['auth_required']}")
+        raise ToolError(
+            "This tool needs a NIPOST API key: set NG_POSTCODE_API_KEY on the server, or over "
+            f"HTTP send your own in the X-NIPOST-API-Key header. Get one at {KEY_URL}."
+        )
     return client
 
 
@@ -470,4 +505,8 @@ def main() -> None:
         sys.exit(f"ng-postcode-mcp: {settings}")
     # httpx logs every request URL at INFO, which would copy postcodes into client logs.
     logging.getLogger("httpx").setLevel(logging.WARNING)
-    create_server(settings).run()
+    server = create_server(settings)
+    if settings.transport == "http":
+        server.run("streamable-http", host=settings.host, port=settings.port)
+    else:
+        server.run()

ng_postcode_mcp-0.4.0/tests/test_caller_key.py

@@ -0,0 +1,94 @@
+"""A caller's own NIPOST key over HTTP, against an in-process server with NIPOST mocked."""
+
+from __future__ import annotations
+
+import socket
+import threading
+import time
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+import httpx
+import httpx2
+import pytest
+import uvicorn
+from mcp import Client
+from mcp.client.streamable_http import streamable_http_client
+from mcp.types import CallToolResult
+
+from ng_postcode_mcp import Settings, create_server
+
+LOOKUP = {"postcode": "EK-01-A03-FK-01"}
+
+
+@pytest.fixture
+def anyio_backend() -> str:
+    return "asyncio"
+
+
+@contextmanager
+def serving(server_key: str | None, keys_seen: list[str]) -> Iterator[str]:
+    """Run the server over HTTP on a loopback port; yields its URL."""
+
+    def nipost(request: httpx.Request) -> httpx.Response:
+        keys_seen.append(request.headers["X-API-Key"])
+        return httpx.Response(200, json={"data": {"postcode": "EK-01-A03-FK-01", "valid": True}})
+
+    upstream = httpx.AsyncClient(transport=httpx.MockTransport(nipost))
+    app = create_server(Settings(api_key=server_key), http=upstream).streamable_http_app()
+    with socket.socket() as probe:
+        probe.bind(("127.0.0.1", 0))
+        port = int(probe.getsockname()[1])
+    server = uvicorn.Server(uvicorn.Config(app, host="127.0.0.1", port=port, log_level="error"))
+    thread = threading.Thread(target=server.run, daemon=True)
+    thread.start()
+    deadline = time.monotonic() + 20
+    while not server.started and time.monotonic() < deadline:
+        time.sleep(0.05)
+    try:
+        yield f"http://127.0.0.1:{port}/mcp"
+    finally:
+        server.should_exit = True
+        thread.join(timeout=10)
+
+
+async def lookup(url: str, caller_key: str | bytes | None) -> CallToolResult:
+    sent = caller_key.encode() if isinstance(caller_key, str) else caller_key
+    headers = {b"X-NIPOST-API-Key": sent} if sent else {}
+    async with (
+        httpx2.AsyncClient(headers=headers) as http,
+        Client(streamable_http_client(url, http_client=http)) as client,
+    ):
+        return await client.call_tool("lookup_postcode", LOOKUP)
+
+
+@pytest.mark.anyio
+async def test_a_callers_key_is_used_for_its_own_requests() -> None:
+    seen: list[str] = []
+    with serving(None, seen) as url:
+        own = await lookup(url, "caller-key")
+        none = await lookup(url, None)
+    assert not own.is_error
+    assert seen == ["caller-key"]
+    assert none.is_error
+    assert "X-NIPOST-API-Key" in str(none.content)
+
+
+@pytest.mark.anyio
+async def test_the_servers_key_is_the_fallback() -> None:
+    seen: list[str] = []
+    with serving("server-key", seen) as url:
+        await lookup(url, None)
+        await lookup(url, "caller-key")
+    assert seen == ["server-key", "caller-key"]
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("key", ["k\xe9y".encode("latin-1"), b"two words", b"k" * 300])
+async def test_an_unusable_key_is_refused_before_nipost(key: bytes) -> None:
+    seen: list[str] = []
+    with serving("server-key", seen) as url:
+        result = await lookup(url, key)
+    assert result.is_error
+    assert "does not hold a usable" in str(result.content)
+    assert seen == []

ng_postcode_mcp-0.4.0/tests/test_http.py

@@ -0,0 +1,49 @@
+"""The real entry point over HTTP, on a loopback port."""
+
+from __future__ import annotations
+
+import os
+import socket
+import subprocess
+import sys
+import time
+
+import pytest
+from mcp import Client
+
+
+@pytest.fixture
+def anyio_backend() -> str:
+    return "asyncio"
+
+
+def free_port() -> int:
+    with socket.socket() as probe:
+        probe.bind(("127.0.0.1", 0))
+        return int(probe.getsockname()[1])
+
+
+def wait_until_listening(port: int, seconds: float = 20.0) -> None:
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        with socket.socket() as probe:
+            if probe.connect_ex(("127.0.0.1", port)) == 0:
+                return
+        time.sleep(0.1)
+    raise TimeoutError(f"nothing listening on port {port}")
+
+
+@pytest.mark.anyio
+async def test_serves_over_http() -> None:
+    port = free_port()
+    env = {k: v for k, v in os.environ.items() if not k.startswith("NG_POSTCODE_")}
+    env |= {"NG_POSTCODE_TRANSPORT": "http", "NG_POSTCODE_PORT": str(port)}
+    server = subprocess.Popen([sys.executable, "-m", "ng_postcode_mcp"], env=env)
+    try:
+        wait_until_listening(port)
+        async with Client(f"http://127.0.0.1:{port}/mcp") as client:
+            result = await client.call_tool("validate_postcode", {"postcode": "LA11W06TC10"})
+    finally:
+        server.terminate()
+        server.wait(timeout=10)
+    assert result.structured_content["postcode"] == "LA-11-W06-TC-10"

ng_postcode_mcp-0.4.0/tests/test_reference_schema.py

@@ -0,0 +1,74 @@
+"""The shared postcode reference schema, and that resolve_address answers fit it."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+from jsonschema import Draft202012Validator
+from ng_address.models import Resolution
+from ng_postcode import Postcode, Segment
+
+SCHEMA_FILE = Path(__file__).resolve().parents[2] / "docs/schemas/postcode-reference.schema.json"
+
+pytestmark = pytest.mark.skipif(
+    not SCHEMA_FILE.exists(), reason="the schema lives in the repository, not the sdist"
+)
+
+
+def loaded() -> dict[str, Any]:
+    document: dict[str, Any] = json.loads(SCHEMA_FILE.read_text(encoding="utf-8"))
+    return document
+
+
+@pytest.fixture(scope="module")
+def schema() -> Draft202012Validator:
+    Draft202012Validator.check_schema(loaded())
+    return Draft202012Validator(loaded())
+
+
+def test_its_own_examples_are_valid(schema: Draft202012Validator) -> None:
+    for example in loaded()["examples"]:
+        schema.validate(example)
+
+
+@pytest.mark.parametrize(
+    "reference",
+    [
+        {"code": "EK-01-A03-FK-01"},
+        {"code": "EK-01-A03-FK-01", "level": "area"},
+        {"code": "EK-01-A03-FK", "level": "building"},
+        {"code": "EK01A03FK01", "level": "building"},
+        {"code": "ek-01-a03-fk-01", "level": "building"},
+        {"code": "EK-00", "level": "lga"},
+        {"code": "EK-01", "level": "street"},
+        {"code": "EK-01", "level": "lga", "confidence": "certain"},
+    ],
+)
+def test_rejects_malformed_references(
+    schema: Draft202012Validator, reference: dict[str, str]
+) -> None:
+    assert not schema.is_valid(reference)
+
+
+def test_every_prefix_of_a_code_fits_its_level(schema: Draft202012Validator) -> None:
+    code = Postcode("EK01A03FK01")
+    levels = {"state": Segment.STATE, "lga": Segment.LGA, "district": Segment.DISTRICT}
+    levels |= {"area": Segment.AREA, "building": Segment.UNIT}
+    for level, segment in levels.items():
+        schema.validate({"code": code.prefix(segment), "level": level})
+
+
+def test_a_resolution_is_a_reference(schema: Draft202012Validator) -> None:
+    answer = Resolution(
+        status="partial",
+        code="EK-01-A03-FK",
+        level="area",
+        confidence="medium",
+        method="geocoded",
+        question="Which building is it?",
+        evidence=[],
+    )
+    schema.validate(answer.model_dump())

{ng_postcode_mcp-0.2.4 → ng_postcode_mcp-0.4.0}/tests/test_tools.py

@@ -161,7 +161,7 @@ async def test_lookup_never_autocorrects_before_spending() -> None:
 async def test_online_tools_explain_a_missing_or_rejected_key() -> None:
     missing = await call("lookup_postcode", {"postcode": "EK-01-A03-FK-01"}, key=None)
     assert missing.is_error
-    assert "needs NG_POSTCODE_API_KEY" in text(missing)
+    assert "needs a NIPOST API key" in text(missing)
 
     secret = "nipost_test_never_echo_me"
     rejected = await call("lookup_postcode", {"postcode": "EK-01-A03-FK-01"}, key=secret)
@@ -224,6 +224,14 @@ def test_output_models_only_use_fields_the_library_has(
     assert set(model.model_fields) <= {field.name for field in dataclasses.fields(source)}
 
 
+def test_transport_settings() -> None:
+    served = settings_from_env({"NG_POSTCODE_TRANSPORT": "HTTP", "NG_POSTCODE_PORT": "9000"})
+    assert isinstance(served, Settings)
+    assert (served.transport, served.host, served.port) == ("http", "127.0.0.1", 9000)
+    assert isinstance(settings_from_env({"NG_POSTCODE_TRANSPORT": "sse"}), str)
+    assert isinstance(settings_from_env({"NG_POSTCODE_PORT": "0"}), str)
+
+
 def test_settings_from_env() -> None:
     assert settings_from_env({}) == Settings(api_key=None)
     assert settings_from_env({"NG_POSTCODE_API_KEY": " k ", "NG_POSTCODE_MAX_LEVEL": "3"}) == (