specrig 0.1.0__py3-none-any.whl

specrig/__init__.py

@@ -0,0 +1,7 @@
+from .backend import Backend, Received
+from .http import Response
+from .postgres import Postgres
+from .redis import Redis
+from .rig import Logged
+
+__all__ = ["Backend", "Logged", "Postgres", "Received", "Redis", "Response"]

specrig/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .tool.cli import main
+
+sys.exit(main())

specrig/_yaml.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+_WHITE = "\x09-\x0d\x20\x85\xa0  - 

  　"
+_CONTROL = "\x00-\x1f\x7f-\x9f"
+_WORDS = re.compile(r"^(?:true|false|yes|no|on|off|y|n|null|~)$", re.IGNORECASE)
+_NUMBER = re.compile(r"^[-+]?(\.?[0-9]|0x|0o|\.inf|\.nan)", re.IGNORECASE)
+_EDGES = re.compile(f"^[{_WHITE}]|[{_WHITE}]$")
+_CONTROLS = re.compile(f"[{_CONTROL}]")
+
+
+# A mapping is a dict, a sequence a list; an entry whose value is None or empty is
+# left out, as omitempty does in the Go record.
+def emit(root: dict[str, Any]) -> str:
+    return _write(root, 0)
+
+
+def _write(mapping: dict[str, Any], indent: int) -> str:
+    pad = " " * indent
+    text = ""
+    for key, value in mapping.items():
+        if value is None or value == [] or value == {}:
+            continue
+        if isinstance(value, str):
+            text += f"{pad}{key}: {_scalar(value, indent + 2)}\n"
+        elif isinstance(value, dict):
+            text += f"{pad}{key}:\n{_write(value, indent + 2)}"
+        elif isinstance(value, list) and isinstance(value[0], str):
+            text += f"{pad}{key}:\n"
+            for item in value:
+                text += f"{pad}  - {_scalar(item, indent + 4)}\n"
+        elif isinstance(value, list) and isinstance(value[0], dict):
+            text += f"{pad}{key}:\n"
+            for item in value:
+                text += f"{pad}  - {_write(item, indent + 4)[indent + 4 :]}"
+        else:
+            raise TypeError(f"{key}: no YAML for a {type(value).__name__}")
+    return text
+
+
+def _scalar(value: str, indent: int) -> str:
+    if _plain(value):
+        return value
+    if "\n" not in value or "\r" in value or value.startswith(" ") or value.endswith("\n\n"):
+        return _quoted(value)
+    clip = value.endswith("\n")
+    pad = " " * indent
+    text = "|" if clip else "|-"
+    for line in (value[:-1] if clip else value).split("\n"):
+        text += "\n" if line == "" else f"\n{pad}{line}"
+    return text
+
+
+def _plain(value: str) -> bool:
+    return (
+        value != ""
+        and not _EDGES.search(value)
+        and value[0] not in "-?:,[]{}#&*!|>'\"%@`"
+        and ": " not in value
+        and " #" not in value
+        and not value.endswith(":")
+        and not _CONTROLS.search(value)
+        and not _WORDS.match(value)
+        and not _NUMBER.match(value)
+    )
+
+
+def _quoted(value: str) -> str:
+    text = '"'
+    for c in value:
+        if c == '"':
+            text += '\\"'
+        elif c == "\\":
+            text += "\\\\"
+        elif c == "\n":
+            text += "\\n"
+        elif c == "\t":
+            text += "\\t"
+        elif c == "\r":
+            text += "\\r"
+        elif _CONTROLS.match(c):
+            text += f"\\x{ord(c):02x}"
+        else:
+            text += c
+    return text + '"'
+
+
+class _Loader(yaml.SafeLoader):
+    pass
+
+
+# YAML 1.2's core schema, as Go and Symfony read it: yes and no are words, and a
+# date is the text it is written as.
+_Loader.yaml_implicit_resolvers = {
+    first: [
+        (tag, pattern)
+        for tag, pattern in resolvers
+        if tag not in ("tag:yaml.org,2002:bool", "tag:yaml.org,2002:timestamp")
+    ]
+    for first, resolvers in yaml.SafeLoader.yaml_implicit_resolvers.items()
+}
+_Loader.add_implicit_resolver(
+    "tag:yaml.org,2002:bool", re.compile(r"^(?:true|True|TRUE|false|False|FALSE)$"), list("tTfF")
+)
+
+
+def load(text: str) -> Any:
+    return yaml.load(text, Loader=_Loader)
+
+
+def read(path: Path) -> Any:
+    return load(path.read_text(encoding="utf-8")) if path.is_file() else None

specrig/asgi.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import math
+from collections.abc import Callable, Mapping
+from typing import Any
+from urllib.parse import unquote, urlsplit
+
+import anyio
+import anyio.from_thread
+
+Message = dict[str, Any]
+
+
+# An ASGI server of the harness's own, in a thread of its own: the service's lifespan
+# runs from the boot to the end of the case, and a request is answered whole — its
+# background tasks included — before the step that sent it goes on.
+class Server:
+    def __init__(self, app: Callable[..., Any]) -> None:
+        self.app = app
+        self.state: dict[str, Any] = {}
+        self._stack = contextlib.ExitStack()
+        self.portal = self._stack.enter_context(anyio.from_thread.start_blocking_portal())
+        self._to_app, self._app_reads = anyio.create_memory_object_stream[Message](math.inf)
+        self._app_sends, self._from_app = anyio.create_memory_object_stream[Message | None](math.inf)
+        self._lifespan = False
+
+    def start(self) -> None:
+        self.portal.start_task_soon(self._run_lifespan)
+        answer = self.portal.call(self._lifespan_event, "startup")
+        if answer is None:
+            return
+        if answer["type"] == "lifespan.startup.failed":
+            raise RuntimeError(f"the service did not start: {answer.get('message', '')}")
+        self._lifespan = True
+
+    def stop(self) -> None:
+        try:
+            if self._lifespan:
+                answer = self.portal.call(self._lifespan_event, "shutdown")
+                if answer is not None and answer["type"] == "lifespan.shutdown.failed":
+                    raise RuntimeError(f"the service did not stop: {answer.get('message', '')}")
+        finally:
+            self._stack.close()
+
+    def request(
+        self, method: str, url: str, headers: Mapping[str, str], body: bytes, client: str = "127.0.0.1"
+    ) -> tuple[int, list[tuple[str, str]], bytes]:
+        parts = urlsplit(url)
+        host = parts.netloc or "testserver"
+        sent = [(b"host", host.encode())]
+        sent += [(k.lower().encode("latin-1"), v.encode("latin-1")) for k, v in headers.items() if k.lower() != "host"]
+        if body and not any(k == b"content-length" for k, _ in sent):
+            sent.append((b"content-length", str(len(body)).encode()))
+        scope = {
+            "type": "http",
+            "asgi": {"version": "3.0", "spec_version": "2.4"},
+            "http_version": "1.1",
+            "method": method.upper(),
+            "scheme": parts.scheme or "http",
+            "path": unquote(parts.path) or "/",
+            "raw_path": (parts.path or "/").encode(),
+            "query_string": parts.query.encode(),
+            "root_path": "",
+            "headers": sent,
+            "client": (client, 50000),
+            "server": (parts.hostname or "testserver", parts.port or (443 if parts.scheme == "https" else 80)),
+            "state": dict(self.state),
+        }
+        return self.portal.call(self._request, scope, body)
+
+    async def _run_lifespan(self) -> None:
+        scope = {"type": "lifespan", "asgi": {"version": "3.0", "spec_version": "2.0"}, "state": self.state}
+        try:
+            await self.app(scope, self._app_reads.receive, self._app_sends.send)
+        except Exception:
+            if self._lifespan:
+                logging.getLogger("specrig").exception("the service's lifespan failed")
+        finally:
+            await self._app_sends.send(None)
+
+    async def _lifespan_event(self, event: str) -> Message | None:
+        await self._to_app.send({"type": f"lifespan.{event}"})
+        return await self._from_app.receive()
+
+    async def _request(self, scope: dict[str, Any], body: bytes) -> tuple[int, list[tuple[str, str]], bytes]:
+        read = False
+        done = anyio.Event()
+        status: int | None = None
+        headers: list[tuple[str, str]] = []
+        chunks: list[bytes] = []
+
+        async def receive() -> Message:
+            nonlocal read
+            if not read:
+                read = True
+                return {"type": "http.request", "body": body, "more_body": False}
+            await done.wait()
+            return {"type": "http.disconnect"}
+
+        async def send(message: Message) -> None:
+            nonlocal status, headers
+            if message["type"] == "http.response.start":
+                status = message["status"]
+                headers = [(k.decode("latin-1"), v.decode("latin-1")) for k, v in message.get("headers", [])]
+            elif message["type"] == "http.response.body":
+                chunks.append(message.get("body", b""))
+                if not message.get("more_body", False):
+                    done.set()
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception:
+            logging.getLogger("specrig").exception("the service failed on %s %s", scope["method"], scope["path"])
+            if status is None:
+                return 500, [], b""
+        finally:
+            done.set()
+        return status or 500, headers, b"".join(chunks)

specrig/backend.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import copy
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, TypeVar
+
+from . import http
+from .contract import Contract
+from .http import Request, Response, Unreachable
+from .records import Trace
+
+T = TypeVar("T")
+
+Query = Mapping[str, str | int | Sequence[str | int]]
+
+
+@dataclass(frozen=True)
+class Received:
+    method: str
+    path: str
+    query: dict[str, list[str]]
+    json: Any
+
+
+class StandIn(ABC):
+    origin: str
+    setting: str | None
+
+    @abstractmethod
+    def attach(self, name: str, trace: Trace, root: Path) -> None: ...
+
+    @abstractmethod
+    def answer(self, request: Request) -> Response: ...
+
+    @abstractmethod
+    def failures(self) -> list[str]: ...
+
+    @abstractmethod
+    def fresh(self) -> StandIn: ...
+
+
+class Backend(StandIn):
+    def __init__(
+        self, origin: str, setting: str | None = None, contract: str | None = None, failure: str | None = None
+    ) -> None:
+        self.origin = http.origin(origin)
+        self.setting = setting
+        self._contract = contract
+        self._failure = failure
+        self.name = ""
+        self._trace = Trace()
+        self._checked: Contract | None = None
+        self._replies: dict[str, list[tuple[dict[str, list[str]], int, Any]]] = {}
+        self._timeouts: dict[str, list[dict[str, list[str]]]] = {}
+        self._received: list[Received] = []
+        self._unanswered: list[str] = []
+        self._violations: list[str] = []
+
+    def fresh(self) -> Backend:
+        return Backend(self.origin, self.setting, self._contract, self._failure)
+
+    def attach(self, name: str, trace: Trace, root: Path) -> None:
+        self.name = name
+        self._trace = trace
+        if self._contract is not None:
+            self._checked = Contract.load((root / self._contract).resolve(), name, self._failure)
+
+    def failures(self) -> list[str]:
+        failures = []
+        if self._unanswered:
+            failures.append(f"{self.name} was called where no step declared its answer: {', '.join(self._unanswered)}")
+        if self._violations:
+            failures.append(
+                f"what {self.name}'s contract, {self._contract}, does not allow: {'; '.join(self._violations)}"
+            )
+        return failures
+
+    def reply(self, method: str, path: str, status: int, body: Any = None) -> None:
+        self.reply_to(method, path, {}, status, body)
+
+    def reply_to(self, method: str, path: str, query: Query, status: int, body: Any = None) -> None:
+        key = f"{method.upper()} {path}"
+        asked = _listed(query)
+        kept = [r for r in self._replies.get(key, []) if r[0] != asked]
+        self._replies[key] = [*kept, (asked, status, copy.deepcopy(body))]
+
+    def time_out(self, method: str, path: str, query: Query | None = None) -> None:
+        key = f"{method.upper()} {path}"
+        asked = _listed(query or {})
+        self._timeouts[key] = [*(q for q in self._timeouts.get(key, []) if q != asked), asked]
+
+    def requests(self, method: str, path: str) -> list[Received]:
+        return [r for r in self._received if r.method == method.upper() and r.path == path]
+
+    def answer(self, request: Request) -> Response:
+        method = request.method.upper()
+        path = request.path()
+        key = f"{method} {path}"
+        asked = http.query(request.search())
+        body = http.decoded(request.body)
+        call = self._trace.begin()
+        try:
+            self._received.append(Received(method, path, asked, body))
+            if self._checked is not None:
+                self._violations.extend(self._checked.request(method, path, body))
+            if _pick(self._timeouts.get(key, []), asked, lambda q: q) is not None:
+                raise Unreachable(f"{self.name} did not answer {key} in time", timed_out=True)
+            return self._fulfil(method, path, key + request.search(), asked)
+        finally:
+            name = self._checked.name(method, path) if self._checked is not None else key
+            self._trace.end(call, "out", "http", name, body)
+
+    def _fulfil(self, method: str, path: str, asked: str, query: dict[str, list[str]]) -> Response:
+        reply = _pick(self._replies.get(f"{method} {path}", []), query, lambda r: r[0])
+        if reply is None:
+            self._unanswered.append(asked)
+            return _respond(501, {"code": "unanswered", "message": f"{method} {path}"})
+        _, status, body = reply
+        if self._checked is not None:
+            self._violations.extend(self._checked.response(method, path, status, {} if body is None else body))
+        return _respond(status, None if status == 204 else ({} if body is None else body))
+
+
+def _respond(status: int, body: Any) -> Response:
+    if body is None:
+        return Response(status)
+    return Response(status, {"Content-Type": "application/json"}, http.encoded(body))
+
+
+def _pick(candidates: list[T], query: dict[str, list[str]], of: Callable[[T], dict[str, list[str]]]) -> T | None:
+    found: T | None = None
+    for candidate in candidates:
+        if _matches(of(candidate), query) and len(of(candidate)) >= (0 if found is None else len(of(found))):
+            found = candidate
+    return found
+
+
+def _matches(wanted: dict[str, list[str]], got: dict[str, list[str]]) -> bool:
+    for name, values in wanted.items():
+        have = got.get(name)
+        if have is None or (have[:1] != values if len(values) == 1 else have != values):
+            return False
+    return True
+
+
+def _listed(query: Query) -> dict[str, list[str]]:
+    return {
+        name: [str(v) for v in value] if isinstance(value, (list, tuple)) else [str(value)]
+        for name, value in query.items()
+    }

specrig/clock.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import datetime as dt
+
+import time_machine
+
+
+class Clock:
+    def __init__(self) -> None:
+        self._stopped: dt.datetime | None = None
+        self._travel: time_machine.travel | None = None
+
+    def now(self) -> dt.datetime:
+        return self._stopped or dt.datetime.now(dt.UTC)
+
+    def stopped(self) -> dt.datetime | None:
+        return self._stopped
+
+    def set(self, at: dt.datetime | dt.date | str) -> None:
+        if isinstance(at, str):
+            at = dt.datetime.fromisoformat(at)
+        elif not isinstance(at, dt.datetime):
+            at = dt.datetime.combine(at, dt.time())
+        self._move(at if at.tzinfo else at.replace(tzinfo=dt.UTC))
+
+    def advance(self, by: dt.timedelta) -> None:
+        if self._stopped is None:
+            raise RuntimeError("the clock follows the wall clock until a step sets it")
+        self._move(self._stopped + by)
+
+    def release(self) -> None:
+        if self._travel is not None:
+            self._travel.stop()
+        self._travel = None
+        self._stopped = None
+
+    def _move(self, at: dt.datetime) -> None:
+        self.release()
+        self._travel = time_machine.travel(at, tick=False)
+        self._travel.start()
+        self._stopped = at

specrig/code/__init__.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..surface import Surface
+from ..tool.service import Service
+from . import calls, django, fastapi, settings
+from .index import Code
+
+_SKIPPED = {"tests", "scripts", "venv", "env", "node_modules", "__pycache__", "build", "dist", "site-packages"}
+
+
+def read(service: Service, name: str) -> Surface:
+    code = Code(service.root, files(service.root))
+    surface = Surface(name)
+    calls.read(code, surface)
+    settings.read(code, surface)
+    if service.framework() == "django":
+        django.read(code, surface, service.django_settings())
+    else:
+        fastapi.read(code, surface)
+    return surface
+
+
+def files(root: Path) -> list[Path]:
+    found = []
+    for file in root.rglob("*.py"):
+        parts = file.relative_to(root).parts[:-1]
+        if file.name != "conftest.py" and not any(part in _SKIPPED or part.startswith(".") for part in parts):
+            found.append(file)
+    return sorted(found)

specrig/code/calls.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import ast
+import re
+
+from ..surface import Surface
+from .index import UNCALLED, VARYING, Code
+
+_CLIENTS = {
+    "httpx.Client",
+    "httpx.AsyncClient",
+    "httpx2.Client",
+    "httpx2.AsyncClient",
+    "requests.Session",
+    "requests.sessions.Session",
+}
+_MODULES = {"httpx", "httpx2", "requests"}
+_VERBS = {"get", "head", "post", "put", "patch", "delete", "options"}
+
+
+def read(code: Code, surface: Surface) -> None:
+    for module in code.modules.values():
+        for call in ast.walk(module.tree):
+            if not isinstance(call, ast.Call) or not isinstance(call.func, ast.Attribute):
+                continue
+            method = call.func.attr
+            if method not in _VERBS and method not in ("request", "stream"):
+                continue
+            types = set(code.types(call.func.value))
+            if not types & _CLIENTS and not types & _MODULES:
+                continue
+            if method in _VERBS:
+                verbs, url = [method.upper()], code.argument(call, 0, "url")
+            else:
+                verbs = [
+                    v.upper()
+                    for v in code.templates(code.argument(call, 0, "method"))
+                    if VARYING not in v and UNCALLED not in v
+                ]
+                url = code.argument(call, 1, "url")
+            for template in code.templates(url):
+                if template.startswith(UNCALLED):
+                    continue
+                for verb in verbs:
+                    surface.call(code.where(call), f"{verb} {path(template.replace(UNCALLED, VARYING))}")
+
+
+# A request's path as the record names it: what varies is {}, an address that starts
+# with what varies is a base address and its path, and one with no constant part is
+# from data, somewhere outside.
+def path(template: str) -> str:
+    route = template.split("?", 1)[0]
+    absolute = re.match(r"^[a-z][a-z0-9+.-]*://[^/]*(/.*)?$", route, re.IGNORECASE)
+    if absolute:
+        route = absolute.group(1) or ""
+    elif route.startswith(VARYING) and "/" in route:
+        route = route[route.index("/") :]
+    if route.replace("/", "") in (VARYING, ""):
+        return "/" if route == "/" else "external"
+    segments = [s for s in route.split("/") if s != ""]
+    return "/" + "/".join(VARYING if VARYING in s else s for s in segments)

specrig/code/django.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import ast
+import re
+
+from ..http import route
+from ..surface import Surface
+from .index import UNCALLED, VARYING, Code
+
+_PATHS = {
+    "django.urls.path",
+    "django.urls.re_path",
+    "django.conf.urls.url",
+    "django.urls.conf.path",
+    "django.urls.conf.re_path",
+}
+_INCLUDE = {"django.urls.include", "django.conf.urls.include", "django.urls.conf.include"}
+_VERBS = ("get", "post", "put", "patch", "delete", "head", "options")
+_DECORATED = {
+    "django.views.decorators.http.require_GET": ["GET"],
+    "django.views.decorators.http.require_POST": ["POST"],
+    "django.views.decorators.http.require_safe": ["GET", "HEAD"],
+}
+_LISTED = {"django.views.decorators.http.require_http_methods", "rest_framework.decorators.api_view"}
+
+
+def read(code: Code, surface: Surface, settings: str) -> None:
+    urlconf = code.definitions.get(f"{settings}.ROOT_URLCONF")
+    if urlconf is None:
+        raise ValueError(f"{settings} sets no ROOT_URLCONF the code names")
+    _module(code, _single(code, urlconf), "", surface, set())
+
+
+def _single(code: Code, expr: ast.AST) -> str:
+    found = code.templates(expr)
+    if len(found) != 1 or VARYING in found[0] or UNCALLED in found[0]:
+        raise ValueError("a URLconf named by what is not a constant")
+    return found[0]
+
+
+def _module(code: Code, name: str, prefix: str, surface: Surface, seen: set[str]) -> None:
+    if name in seen or name not in code.modules:
+        return
+    seen = {*seen, name}
+    patterns: list[ast.expr] = []
+    for stmt in code.modules[name].tree.body:
+        if isinstance(stmt, ast.Assign) and any(
+            isinstance(t, ast.Name) and t.id == "urlpatterns" for t in stmt.targets
+        ):
+            patterns = _listed(stmt.value)
+        elif isinstance(stmt, ast.AugAssign) and isinstance(stmt.target, ast.Name) and stmt.target.id == "urlpatterns":
+            patterns += _listed(stmt.value)
+    _patterns(code, patterns, prefix, surface, seen)
+
+
+def _listed(expr: ast.expr) -> list[ast.expr]:
+    if isinstance(expr, (ast.List, ast.Tuple)):
+        return list(expr.elts)
+    if isinstance(expr, ast.BinOp) and isinstance(expr.op, ast.Add):
+        return [*_listed(expr.left), *_listed(expr.right)]
+    return []
+
+
+def _patterns(code: Code, patterns: list[ast.expr], prefix: str, surface: Surface, seen: set[str]) -> None:
+    for pattern in patterns:
+        if not isinstance(pattern, ast.Call) or code.qualified(pattern.func) not in _PATHS:
+            continue
+        at = prefix + _single(code, code.argument(pattern, 0, "route"))
+        view = code.argument(pattern, 1, "view")
+        if isinstance(view, ast.Call) and code.qualified(view.func) in _INCLUDE:
+            included = code.argument(view, 0, "arg")
+            if isinstance(included, ast.Tuple) and included.elts:
+                included = included.elts[0]
+            if isinstance(included, (ast.List, ast.Tuple)):
+                _patterns(code, list(included.elts), at, surface, seen)
+            elif isinstance(included, ast.Constant):
+                _module(code, str(included.value), at, surface, seen)
+            else:
+                _module(code, code.qualified(included) or "", at, surface, seen)
+            continue
+        for method in _methods(code, view):
+            surface.serves.add(f"{method} {_route(at)}")
+
+
+# The view says which methods it answers; one that does not answers any, *.
+def _methods(code: Code, view: ast.AST | None) -> list[str]:
+    if isinstance(view, ast.Call) and isinstance(view.func, ast.Attribute) and view.func.attr == "as_view":
+        klass = code.qualified(view.func.value) or ""
+        defined = {
+            verb
+            for at in code.ancestry(klass)
+            if isinstance(definition := code.definitions.get(at), ast.ClassDef)
+            for verb in _VERBS
+            if f"{at}.{verb}" in code.definitions
+        }
+        return sorted(v.upper() for v in defined) or ["*"]
+    definition = code.definitions.get(code.qualified(view) or "")
+    if isinstance(definition, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        for decorator in definition.decorator_list:
+            named = code.qualified(decorator.func if isinstance(decorator, ast.Call) else decorator)
+            if named in _DECORATED:
+                return _DECORATED[named]
+            if named in _LISTED and isinstance(decorator, ast.Call):
+                listed = code.argument(decorator, 0, "http_method_names")
+                if isinstance(listed, (ast.List, ast.Tuple)):
+                    return [m.upper() for e in listed.elts for m in code.templates(e) if VARYING not in m]
+                return ["GET"]
+    return ["*"]
+
+
+def _route(template: str) -> str:
+    if template.startswith("^") or "(?P<" in template:
+        template = re.sub(r"\(\?P<(\w+)>[^)]*\)", r"{\1}", template)
+        template = template.replace("^", "").replace("\\Z", "").replace("$", "")
+    template = re.sub(
+        r"<(?:(\w+):)?(\w+)>", lambda m: "{" + m.group(2) + (":path}" if m.group(1) == "path" else "}"), template
+    )
+    return route(template, lambda name, kind: kind == "path")