thingctx 0.2.2__tar.gz → 0.2.3__tar.gz

{thingctx-0.2.2/src/thingctx.egg-info → thingctx-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thingctx
-Version: 0.2.2
+Version: 0.2.3
 Summary: Drive any agent against any W3C WoT Thing, over any transport. No per-integration server.
 Author: The thingctx Authors
 License: Apache-2.0
@@ -21,12 +21,14 @@ Provides-Extra: http
 Requires-Dist: httpx>=0.25; extra == "http"
 Provides-Extra: mqtt
 Requires-Dist: paho-mqtt>=2.0; extra == "mqtt"
+Provides-Extra: redis
+Requires-Dist: redis>=5.0; extra == "redis"
 Provides-Extra: validate
 Requires-Dist: jsonschema>=4.0; extra == "validate"
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.3; extra == "mcp"
+Requires-Dist: mcp<2,>=1.3; extra == "mcp"
 Provides-Extra: mcp-http
-Requires-Dist: mcp>=1.3; extra == "mcp-http"
+Requires-Dist: mcp<2,>=1.3; extra == "mcp-http"
 Requires-Dist: uvicorn>=0.27; extra == "mcp-http"
 Provides-Extra: openapi
 Requires-Dist: httpx>=0.25; extra == "openapi"
@@ -50,8 +52,9 @@ Provides-Extra: all
 Requires-Dist: litellm>=1.0; extra == "all"
 Requires-Dist: httpx>=0.27; extra == "all"
 Requires-Dist: paho-mqtt>=2.0; extra == "all"
+Requires-Dist: redis>=5.0; extra == "all"
 Requires-Dist: jsonschema>=4.0; extra == "all"
-Requires-Dist: mcp>=1.3; extra == "all"
+Requires-Dist: mcp<2,>=1.3; extra == "all"
 Requires-Dist: pyyaml>=6; extra == "all"
 Requires-Dist: pyjwt[crypto]>=2.8; extra == "all"
 Requires-Dist: azure-identity>=1.20; extra == "all"
@@ -62,8 +65,10 @@ Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
 Requires-Dist: pytest-cov==7.1.0; extra == "dev"
+Requires-Dist: redis>=5.0; extra == "dev"
+Requires-Dist: fakeredis>=2.18; extra == "dev"
 Requires-Dist: jsonschema>=4.0; extra == "dev"
-Requires-Dist: mcp>=1.3; extra == "dev"
+Requires-Dist: mcp<2,>=1.3; extra == "dev"
 Requires-Dist: httpx>=0.27; extra == "dev"
 Requires-Dist: pyyaml>=6; extra == "dev"
 Requires-Dist: pyjwt[crypto]>=2.8; extra == "dev"
@@ -124,9 +129,7 @@ td = {
 
 
 async def main():
-    client = thingctx.ThingClient(
-        tds=[td], bindings=[thingctx.LocalBinding(make_time_handler())]
-    )
+    client = thingctx.ThingClient(tds=[td], bindings=[thingctx.LocalBinding(make_time_handler())])
     tools, invoke = client.as_tools()
     print("tools:", [t["function"]["name"] for t in tools])
     print(await invoke("clock__getCurrentTime", {"timezone": "UTC"}))

{thingctx-0.2.2 → thingctx-0.2.3}/README-pypi.md

@@ -40,9 +40,7 @@ td = {
 
 
 async def main():
-    client = thingctx.ThingClient(
-        tds=[td], bindings=[thingctx.LocalBinding(make_time_handler())]
-    )
+    client = thingctx.ThingClient(tds=[td], bindings=[thingctx.LocalBinding(make_time_handler())])
     tools, invoke = client.as_tools()
     print("tools:", [t["function"]["name"] for t in tools])
     print(await invoke("clock__getCurrentTime", {"timezone": "UTC"}))

{thingctx-0.2.2 → thingctx-0.2.3}/README.md

@@ -84,9 +84,7 @@ TD = {
 
 
 async def main():
-    client = thingctx.ThingClient(
-        tds=[TD], bindings=[thingctx.LocalBinding(make_time_handler())]
-    )
+    client = thingctx.ThingClient(tds=[TD], bindings=[thingctx.LocalBinding(make_time_handler())])
     tools, invoke = client.as_tools()  # specs for your model; invoke runs a call
     print("tools:", [t["function"]["name"] for t in tools])
     print(await invoke("time__getCurrentTime", {"timezone": "UTC"}))
@@ -113,7 +111,8 @@ pip install 'thingctx[llm,http,validate]'
 
 Quote the argument; unquoted brackets fail in zsh. Base
 `pip install thingctx` has no dependencies; it already includes the `local`
-and `exec` transports. Every optional transport and capability has an extra,
+and `exec` transports. Redis support is `pip install 'thingctx[redis]'`. Every optional
+transport and capability has an extra,
 listed in [`pyproject.toml`](pyproject.toml); each one this page uses is
 named next to the code that needs it.
 
@@ -187,15 +186,17 @@ async def run():  # a sketch, not a program: call it from your own loop
 
     await invoke("pump__set_speed", {"rpm": 1500})
     await client.read_property("pump__rpm")
-    await client.write_property("pump__target_rpm", 1500)   # gated like invoke
-    async for evt in await client.subscribe("pump__overheat"):  # subscribe returns an async iterator
+    await client.write_property("pump__target_rpm", 1500)  # gated like invoke
+    async for evt in await client.subscribe(
+        "pump__overheat"
+    ):  # subscribe returns an async iterator
         ...
 ```
 
-The form picks the transport per call, so one client can read over HTTP and
-subscribe over MQTT. Bindings that pull optional dependencies, MQTT among
-them, are off by default: install the extra and pass
-`bindings=thingctx.BindingRegistry.default(mqtt=True)`.
+The form picks the transport per call, so one client can read over HTTP, subscribe
+over MQTT, and read or write cached properties over Redis. Bindings that pull optional
+dependencies, including MQTT and Redis, are off by default: install the extra and pass
+`bindings=thingctx.BindingRegistry.default(mqtt=True, redis=True)`.
 
 Want the loop handled for you? The `llm` extra runs any provider through
 litellm; add the `http` extra, since the weather file's form is HTTPS. Set
@@ -242,6 +243,7 @@ Carrying on from the first example above, with the same `TD`:
 def approve(req):  # sync or async; return True to allow
     return input(f"run {req.tool_name}{req.arguments}? [y/N] ").lower() == "y"
 
+
 client = thingctx.ThingClient(
     tds=[TD],
     bindings=[thingctx.LocalBinding(make_time_handler())],
@@ -262,18 +264,16 @@ property, `target_rpm`.
 from thingctx import LocalBinding, ThingClient
 from thingctx.authz import LocalPolicyGrantSource, PolicyDecisionPoint, build_vocabulary
 
-reader = ThingClient(tds=[TD], bindings=[LocalBinding(Pump())])  # no pdp yet; parsed only to read the description
+reader = ThingClient(
+    tds=[TD], bindings=[LocalBinding(Pump())]
+)  # no pdp yet; parsed only to read the description
 vocab = build_vocabulary(reader.things)  # the closed set the description declares
 
-grants = LocalPolicyGrantSource(
-    {"operator": {("urn:demo:pump", "target_rpm", "readproperty")}}
-)
+grants = LocalPolicyGrantSource({"operator": {("urn:demo:pump", "target_rpm", "readproperty")}})
 pdp = PolicyDecisionPoint(vocabulary=vocab, grant_source=grants)
 identity = {"sub": "alice", "roles": ["operator"]}  # claims, validated upstream
 
-client = ThingClient(
-    tds=[TD], bindings=[LocalBinding(Pump())], pdp=pdp, identity=identity
-)
+client = ThingClient(tds=[TD], bindings=[LocalBinding(Pump())], pdp=pdp, identity=identity)
 ```
 
 Alice's `operator` role grants read on `target_rpm` and nothing else, so her
@@ -374,8 +374,8 @@ A transport is the common case:
 class CoapBinding:
     scheme = "coap"
 
-    async def invoke(self, action, form, arguments): ...   # required
-    async def read(self, prop, form): ...                  # optional
+    async def invoke(self, action, form, arguments): ...  # required
+    async def read(self, prop, form): ...  # optional
 ```
 
 The contract is a `scheme` plus an async `invoke`. Add `read`, `write`, or

{thingctx-0.2.2 → thingctx-0.2.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "thingctx"
-version = "0.2.2"
+version = "0.2.3"
 description = "Drive any agent against any W3C WoT Thing, over any transport. No per-integration server."
 readme = "README-pypi.md"
 requires-python = ">=3.10"
@@ -33,13 +33,16 @@ llm = ["litellm>=1.0"]
 # Transports.
 http = ["httpx>=0.25"]
 mqtt = ["paho-mqtt>=2.0"]
+redis = ["redis>=5.0"]
 # Validate TDs against the official W3C WoT TD 1.1 schema.
 validate = ["jsonschema>=4.0"]
-# Expose a Thing (or a whole fleet of TDs) to any MCP client.
-mcp = ["mcp>=1.3"]
+# Expose a Thing (or a whole fleet of TDs) to any MCP client. Held below 2
+# until the bridge is ported: 2.0 renames the tool and annotation fields,
+# drops the server decorators, and moves the in-memory test helper.
+mcp = ["mcp>=1.3,<2"]
 # Serve the bridge over streamable HTTP (thingctx-mcp --http) for a hosted gateway or
 # a cloud agent runtime that only takes a remote MCP URL. starlette ships with mcp.
-mcp-http = ["mcp>=1.3", "uvicorn>=0.27"]
+mcp-http = ["mcp>=1.3,<2", "uvicorn>=0.27"]
 # Import OpenAPI specs (YAML support; JSON works without it).
 openapi = ["httpx>=0.25", "pyyaml>=6"]
 # Cloud auth: OAuth2 JWT-bearer assertions need RS256 JWT signing (pyjwt);
@@ -59,14 +62,14 @@ entra = ["azure-identity>=1.20", "pyjwt[crypto]>=2.8", "httpx>=0.27"]
 # still refuses every call until THINGCTX_FS_ROOT is set.
 filesystem = []
 # Everything.
-all = ["litellm>=1.0", "httpx>=0.27", "paho-mqtt>=2.0", "jsonschema>=4.0", "mcp>=1.3", "pyyaml>=6", "pyjwt[crypto]>=2.8", "azure-identity>=1.20", "av>=11", "numpy>=1.23", "pillow>=10"]
+all = ["litellm>=1.0", "httpx>=0.27", "paho-mqtt>=2.0", "redis>=5.0", "jsonschema>=4.0", "mcp>=1.3,<2", "pyyaml>=6", "pyjwt[crypto]>=2.8", "azure-identity>=1.20", "av>=11", "numpy>=1.23", "pillow>=10"]
 # The gate tools are pinned, not floated: the CI and the pre-commit hook must
 # agree with what a contributor runs locally, or "green here, red in CI" churn
-# follows. ruff 0.14.x is where the in-function-import rule (PLC0415) is stable.
+# follows.
 # botocore is here only as an independent oracle for the SigV4 signer: the test
 # compares our signature against botocore's canonical one. Without it installed
 # that comparison skips, so the signing code goes unchecked.
-dev = ["pytest>=7", "pytest-asyncio>=0.21", "pytest-cov==7.1.0", "jsonschema>=4.0", "mcp>=1.3", "httpx>=0.27", "pyyaml>=6", "pyjwt[crypto]>=2.8", "azure-identity>=1.20", "paho-mqtt>=2.0", "av>=11", "numpy>=1.23", "pillow>=10", "botocore>=1.34", "ruff==0.16.0", "mypy==2.3.0", "vulture==2.16", "bandit==1.9.4", "pip-audit==2.10.1", "import-linter==2.13", "diff-cover==10.4.1"]
+dev = ["pytest>=7", "pytest-asyncio>=0.21", "pytest-cov==7.1.0", "redis>=5.0", "fakeredis>=2.18", "jsonschema>=4.0", "mcp>=1.3,<2", "httpx>=0.27", "pyyaml>=6", "pyjwt[crypto]>=2.8", "azure-identity>=1.20", "paho-mqtt>=2.0", "av>=11", "numpy>=1.23", "pillow>=10", "botocore>=1.34", "ruff==0.16.0", "mypy==2.3.0", "vulture==2.16", "bandit==1.9.4", "pip-audit==2.10.1", "import-linter==2.13", "diff-cover==10.4.1"]
 
 [project.scripts]
 # Serve a Thing (or a whole fleet of TDs) to any MCP client.

{thingctx-0.2.2 → thingctx-0.2.3}/src/thingctx/__init__.py

@@ -3,7 +3,7 @@
 """Consume a WoT Thing Description and drive the Thing over any transport.
 
 Parse a TD, present its actions as tools, and invoke each over the
-transport its form names. Depends on stdlib; litellm, httpx, paho-mqtt
+transport its form names. Depends on stdlib; litellm, httpx, paho-mqtt, and redis-py
 are optional extras.
 
     import thingctx
@@ -57,7 +57,7 @@ from thingctx.auth import (
     sigv4_sign,
 )
 
-# Binding contract: built-in transports (http, mqtt, media, local, exec) implement it;
+# Binding contract: built-in transports (http, mqtt, redis, media, local, exec) implement it;
 # an adopter registers their own binding to replace one or add a new protocol.
 from thingctx.bindings import (
     BUILTIN_BINDINGS,
@@ -79,6 +79,7 @@ from thingctx.bindings import (
     MqttBinding,
     ProtocolBinding,
     Readable,
+    RedisBinding,
     SecurityAware,
     Subscribable,
     Writable,
@@ -132,7 +133,7 @@ from thingctx.trust import (
 )
 from thingctx.validate import TDValidationError, validate_td
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 __all__ = [
     "BUILTIN_BINDINGS",
@@ -184,6 +185,7 @@ __all__ = [
     "ProtocolBinding",
     "Quality",
     "Readable",
+    "RedisBinding",
     "Registry",
     "RequestSigner",
     "RetryPolicy",

{thingctx-0.2.2 → thingctx-0.2.3}/src/thingctx/auth/providers.py

@@ -277,6 +277,7 @@ class OAuth2ClientCredentialsAuth(BaseAuth):
         secret: str | None,
         grant: str,
         scopes: tuple[str, ...],
+        *,
         owner: dict[str, Any] | None = None,
     ) -> tuple[dict[str, Any], dict[str, str]]:
         data: dict[str, Any] = {"grant_type": grant}
@@ -331,7 +332,7 @@ class OAuth2ClientCredentialsAuth(BaseAuth):
         tok = None
         async with httpx.AsyncClient(timeout=ctx.timeout) as client:
             for i, method in enumerate(methods):
-                data, headers = self._token_request(method, cid, secret, grant, scopes, owner)
+                data, headers = self._token_request(method, cid, secret, grant, scopes, owner=owner)
                 resp = await client.post(token_url, data=data, headers=headers)
                 if resp.status_code in (400, 401) and i < len(methods) - 1:
                     continue

{thingctx-0.2.2 → thingctx-0.2.3}/src/thingctx/bindings/__init__.py

@@ -4,7 +4,7 @@
 
 A binding speaks one transport scheme and answers the runtime through the
 :class:`ProtocolBinding` contract (a ``scheme`` plus an async ``invoke``, with
-optional read / write / subscribe / media capabilities). http, mqtt, media, local,
+optional read / write / subscribe / media capabilities). http, mqtt, redis, media, local,
 and exec are the built-in bindings, shipped under :mod:`thingctx.bindings.builtin`;
 each is only an implementation of the contract. Register your own binding to add
 a protocol thingctx has never heard of, or to replace a built-in, with no fork.
@@ -40,6 +40,7 @@ from thingctx.bindings.builtin.http import HttpBinding
 from thingctx.bindings.builtin.local import LocalBinding
 from thingctx.bindings.builtin.media import Frame, MediaBackend, MediaBinding, is_media_form
 from thingctx.bindings.builtin.mqtt import MqttBinding
+from thingctx.bindings.builtin.redis import RedisBinding
 from thingctx.bindings.registry import (
     BUILTIN_BINDINGS,
     CONTRACT_VERSION,
@@ -76,6 +77,7 @@ __all__ = [
     # Contract
     "ProtocolBinding",
     "Readable",
+    "RedisBinding",
     "SecurityAware",
     "Subscribable",
     "Writable",

{thingctx-0.2.2 → thingctx-0.2.3}/src/thingctx/bindings/builtin/__init__.py

@@ -1,6 +1,6 @@
 # Copyright 2026 The thingctx Authors
 # SPDX-License-Identifier: Apache-2.0
-"""The built-in bindings thingctx ships: http, mqtt, media, local, and exec.
+"""The built-in bindings thingctx ships: http, mqtt, redis, media, local, and exec.
 
 Each is an implementation of the :class:`~thingctx.bindings.base.ProtocolBinding`
 contract, privileged only by being bundled. An adopter can replace any of
@@ -17,5 +17,13 @@ from thingctx.bindings.builtin.http import HttpBinding
 from thingctx.bindings.builtin.local import LocalBinding
 from thingctx.bindings.builtin.media import MediaBinding
 from thingctx.bindings.builtin.mqtt import MqttBinding
+from thingctx.bindings.builtin.redis import RedisBinding
 
-__all__ = ["ExecBinding", "HttpBinding", "LocalBinding", "MediaBinding", "MqttBinding"]
+__all__ = [
+    "ExecBinding",
+    "HttpBinding",
+    "LocalBinding",
+    "MediaBinding",
+    "MqttBinding",
+    "RedisBinding",
+]

{thingctx-0.2.2 → thingctx-0.2.3}/src/thingctx/bindings/builtin/media/backends.py

@@ -683,7 +683,7 @@ class ExtractorBackend(PyAVBackend):
         with the URL to the open."""
         info = self._resolve_info(url, options)
         requested = info.get("requested_formats")
-        formats = requested if requested else [info]
+        formats = requested or [info]
         return [(f["url"], f.get("http_headers") or {}) for f in formats]
 
     def _download_format(
@@ -759,7 +759,7 @@ class ExtractorBackend(PyAVBackend):
         tmpdir = tempfile.mkdtemp(prefix="thingctx-dl-")
         try:
             local: list[tuple[str, dict | None]] = [
-                (self._download_format(url, f["format_id"], tmpdir, options, stop), None)
+                (self._download_format(url, f["format_id"], tmpdir, options, stop=stop), None)
                 for f in requested
             ]
             super()._mux(local, target, options=opts, stop=stop)

thingctx-0.2.3/src/thingctx/bindings/builtin/redis.py

@@ -0,0 +1,294 @@
+# Copyright 2026 The thingctx Authors
+# SPDX-License-Identifier: Apache-2.0
+"""RedisBinding: read/write Redis keys and subscribe to Redis channels."""
+
+from __future__ import annotations
+
+import contextlib
+import inspect
+import json
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from urllib.parse import parse_qs, unquote, urlsplit, urlunsplit
+
+from thingctx.bindings.base import ProtocolBinding
+from thingctx.contracts import implements
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Callable
+
+    from thingctx.thing import WoTAction, WoTForm, WoTProperty
+
+
+@dataclass(frozen=True)
+class RedisEndpoint:
+    """One parsed Redis form endpoint.
+
+    ``connection_url`` identifies the Redis server and logical database.
+    ``resource`` is interpreted as a Redis key by ``read``/``write`` and as a
+    pub/sub channel by ``subscribe``.
+    """
+
+    connection_url: str
+    resource: str
+
+
+def _parse_endpoint(href: str) -> RedisEndpoint:
+    """Parse ``redis[s]://host[:port]/<resource>[?db=N]``.
+
+    The path names the resource rather than Redis' conventional database-number
+    path because a WoT form needs to identify the key/channel it drives. Select
+    a logical Redis database with ``?db=N`` instead. The form must not embed
+    credentials; pass those when constructing the binding instead.
+    """
+
+    parts = urlsplit(href)
+    if parts.scheme not in {"redis", "rediss"}:
+        raise ValueError("Redis form href must use redis:// or rediss://")
+    if not parts.hostname:
+        raise ValueError("Redis form href must include a hostname")
+    if parts.username is not None or parts.password is not None:
+        raise ValueError("Redis form href must not embed credentials; pass them to RedisBinding")
+    if parts.fragment:
+        raise ValueError("Redis form href must not include a fragment")
+
+    resource = unquote(parts.path.lstrip("/"))
+    if not resource:
+        raise ValueError("Redis form href must include a key or channel in its path")
+
+    query = parse_qs(parts.query, keep_blank_values=True)
+    unknown = set(query) - {"db"}
+    if unknown:
+        names = ", ".join(sorted(unknown))
+        raise ValueError(f"unsupported Redis form query parameter(s): {names}")
+
+    db_values = query.get("db", ["0"])
+    if len(db_values) != 1:
+        raise ValueError("Redis form db must be specified at most once")
+    try:
+        db = int(db_values[0])
+    except ValueError as exc:
+        raise ValueError("Redis form db must be a non-negative integer") from exc
+    if db < 0:
+        raise ValueError("Redis form db must be a non-negative integer")
+
+    # Rebuild a redis-py connection URL whose path is the logical DB. The form's
+    # original path is the thingctx resource and is intentionally not forwarded.
+    connection_url = urlunsplit((parts.scheme, parts.netloc, f"/{db}", "", ""))
+    return RedisEndpoint(connection_url=connection_url, resource=resource)
+
+
+def _schema_type(schema: Any) -> str | None:
+    """Return a single declared JSON-schema type when one is unambiguous."""
+
+    if not isinstance(schema, dict):
+        return None
+    raw = schema.get("type")
+    if isinstance(raw, str):
+        return raw
+    if isinstance(raw, list):
+        concrete = [item for item in raw if isinstance(item, str) and item != "null"]
+        if len(concrete) == 1:
+            return concrete[0]
+    return None
+
+
+def _target_schema(target: Any) -> dict[str, Any] | None:
+    """Return a property's value schema or an event's data schema."""
+
+    schema = getattr(target, "schema", None)
+    if isinstance(schema, dict):
+        return schema
+    data_schema = getattr(target, "data_schema", None)
+    return data_schema if isinstance(data_schema, dict) else None
+
+
+def _decode_redis(value: Any, schema: dict[str, Any] | None = None) -> Any:
+    """Decode Redis bytes into the most useful Python value.
+
+    Redis returns bytes by default. A TD-declared ``string`` remains a string;
+    JSON-shaped data for number/boolean/object/array schemas is JSON-decoded.
+    Without a schema, valid JSON is decoded heuristically and other UTF-8 stays
+    text. Non-UTF-8 payloads stay bytes.
+    """
+
+    if value is None or not isinstance(value, bytes | bytearray | memoryview):
+        return value
+
+    raw = bytes(value)
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return raw
+
+    if _schema_type(schema) == "string":
+        return text
+
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return text
+
+
+def _encode_redis(value: Any, schema: dict[str, Any] | None = None) -> bytes:
+    """Encode a Python value for a Redis ``SET`` or ``PUBLISH`` payload.
+
+    Strings are written as ordinary UTF-8 so non-thingctx Redis clients see the
+    expected value. Structured/scalar JSON values are compact-JSON encoded;
+    bytes pass through unchanged. The TD schema lets the read side preserve a
+    numeric-looking string such as ``"42"`` as a string.
+    """
+
+    if isinstance(value, bytes | bytearray | memoryview):
+        return bytes(value)
+    if isinstance(value, str):
+        return value.encode("utf-8")
+    try:
+        return json.dumps(
+            value,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            allow_nan=False,
+        ).encode("utf-8")
+    except (TypeError, ValueError) as exc:
+        kind = _schema_type(schema) or "Redis"
+        raise TypeError(f"{kind} value must be bytes, text, or JSON-serializable") from exc
+
+
+async def _close_resource(resource: Any) -> None:
+    """Close redis-py 5.x (``close``) or newer (``aclose``) resources."""
+
+    closer = getattr(resource, "aclose", None) or getattr(resource, "close", None)
+    if not callable(closer):
+        return
+    result = closer()
+    if inspect.isawaitable(result):
+        await result
+
+
+@implements(ProtocolBinding)
+class RedisBinding:
+    """Drive Redis keys and pub/sub channels with redis-py's asyncio client.
+
+    A form uses ``redis://host[:port]/<name>[?db=N]`` (or ``rediss://`` for
+    TLS). The WoT affordance decides what ``<name>`` addresses:
+
+    * property ``read`` / ``write`` -> a Redis key (``GET`` / ``SET``);
+    * event/observable ``subscribe`` -> a Redis pub/sub channel (``SUBSCRIBE``).
+
+    The URL therefore does not guess whether a name is a key or a channel. The
+    Thing Description operation supplies that meaning. Redis action invocation
+    has no mapping in this binding and raises ``NotImplementedError``.
+
+    Credentials belong in binding configuration, not in a Thing Description:
+    pass redis-py connection options such as ``username`` / ``password`` via
+    ``connection_kwargs`` instead of embedding them in the form URL.
+    """
+
+    scheme = "redis"
+    schemes = ("redis", "rediss")
+
+    def __init__(
+        self,
+        *,
+        connection_kwargs: dict[str, Any] | None = None,
+        client_factory: Callable[..., Any] | None = None,
+    ) -> None:
+        self._connection_kwargs = dict(connection_kwargs or {})
+        self._client_factory = client_factory
+        self._clients: dict[str, Any] = {}
+
+    def _new_client(self, connection_url: str) -> Any:
+        options = {**self._connection_kwargs, "decode_responses": False}
+        if self._client_factory is not None:
+            return self._client_factory(connection_url, **options)
+
+        # Optional dependency: importing thingctx must not import redis-py.
+        import redis.asyncio as redis  # noqa: PLC0415
+
+        return redis.from_url(connection_url, **options)
+
+    def _client(self, endpoint: RedisEndpoint) -> Any:
+        client = self._clients.get(endpoint.connection_url)
+        if client is None:
+            client = self._new_client(endpoint.connection_url)
+            self._clients[endpoint.connection_url] = client
+        return client
+
+    async def invoke(
+        self,
+        action: WoTAction,
+        form: WoTForm,
+        arguments: dict[str, Any],
+    ) -> Any:
+        del action, form, arguments
+        raise NotImplementedError(
+            "RedisBinding maps properties to keys and subscriptions to channels; "
+            "Redis actions are not supported"
+        )
+
+    async def read(self, prop: WoTProperty, form: WoTForm) -> Any:
+        """GET the Redis key named by the form path."""
+
+        endpoint = _parse_endpoint(form.href)
+        value = await self._client(endpoint).get(endpoint.resource)
+        return _decode_redis(value, _target_schema(prop))
+
+    async def write(self, prop: WoTProperty, form: WoTForm, value: Any) -> Any:
+        """SET the Redis key named by the form path."""
+
+        endpoint = _parse_endpoint(form.href)
+        payload = _encode_redis(value, _target_schema(prop))
+        ok = await self._client(endpoint).set(endpoint.resource, payload)
+        return {"ok": bool(ok)}
+
+    async def subscribe(
+        self,
+        target: Any,
+        form: WoTForm,
+        args: dict[str, Any] | None = None,
+    ) -> AsyncIterator[Any]:
+        """SUBSCRIBE to the Redis channel named by the form path."""
+
+        if args:
+            raise ValueError("Redis subscriptions do not accept subscription arguments")
+
+        endpoint = _parse_endpoint(form.href)
+        pubsub = self._client(endpoint).pubsub()
+        try:
+            await pubsub.subscribe(endpoint.resource)
+        except BaseException:
+            await _close_resource(pubsub)
+            raise
+
+        schema = _target_schema(target)
+
+        async def _stream() -> AsyncIterator[Any]:
+            try:
+                while True:
+                    message = await pubsub.get_message(
+                        ignore_subscribe_messages=True,
+                        timeout=None,
+                    )
+                    if message is not None and message.get("type") in {"message", "pmessage"}:
+                        yield _decode_redis(message.get("data"), schema)
+            finally:
+                with contextlib.suppress(Exception):
+                    await pubsub.unsubscribe(endpoint.resource)
+                with contextlib.suppress(Exception):
+                    await _close_resource(pubsub)
+
+        return _stream()
+
+    async def aclose(self) -> None:
+        """Close every pooled Redis client. Safe to call more than once."""
+
+        clients, self._clients = list(self._clients.values()), {}
+        for client in clients:
+            await _close_resource(client)
+
+    async def __aenter__(self) -> RedisBinding:
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()