labthings-fastapi 0.0.17__tar.gz → 0.1.0__tar.gz

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labthings-fastapi
-Version: 0.0.17
+Version: 0.1.0
 Summary: An implementation of LabThings using FastAPI
 Project-URL: Homepage, https://github.com/labthings/labthings-fastapi
 Project-URL: Bug Tracker, https://github.com/labthings/labthings-fastapi/issues
@@ -11,11 +11,11 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: anyio~=4.0
-Requires-Dist: fastapi[all]>=0.115.0
+Requires-Dist: fastapi[all]~=0.135.0
 Requires-Dist: httpx
 Requires-Dist: jsonschema
 Requires-Dist: numpy>=1.20
-Requires-Dist: pydantic~=2.10.6
+Requires-Dist: pydantic~=2.12
 Requires-Dist: typing-extensions
 Requires-Dist: zeroconf>=0.28.0
 Provides-Extra: dev

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "labthings-fastapi"
-version = "0.0.17"
+version = "0.1.0"
 authors = [
   { name="Richard Bowman", email="richard.bowman@cantab.net" },
 ]
@@ -13,13 +13,13 @@ classifiers = [
   "Operating System :: OS Independent",
 ]
 dependencies = [
-  "pydantic ~= 2.10.6",
+  "pydantic ~= 2.12",
   "numpy>=1.20",
   "jsonschema",
   "typing_extensions",
   "anyio ~=4.0",
   "httpx",
-  "fastapi[all]>=0.115.0",
+  "fastapi[all]~=0.135.0",
   "zeroconf >=0.28.0",
 ]
 

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/__init__.py

@@ -25,7 +25,6 @@ from .thing_server_interface import ThingServerInterface
 from .properties import property, setting, DataProperty, DataSetting
 from .actions import action
 from .endpoints import endpoint
-from . import deps
 from . import outputs
 from .outputs import blob
 from .server import ThingServer, cli
@@ -53,7 +52,6 @@ __all__ = [
     "action",
     "thing_slot",
     "endpoint",
-    "deps",
     "outputs",
     "blob",
     "ThingServer",

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/actions.py

@@ -48,7 +48,6 @@ from .base_descriptor import (
 from .logs import add_thing_log_destination
 from .utilities import model_to_dict, wrap_plain_types_in_rootmodel
 from .invocations import InvocationModel, InvocationStatus
-from .dependencies.invocation import NonWarningInvocationID
 from .exceptions import (
     InvocationCancelledError,
     InvocationError,
@@ -352,7 +351,6 @@ class ActionManager:
         self,
         action: ActionDescriptor,
         thing: Thing,
-        id: uuid.UUID,
         input: Any,
         dependencies: dict[str, Any],
     ) -> Invocation:
@@ -366,8 +364,6 @@ class ActionManager:
         :param thing: is the object on which we are running the ``action``, i.e.
             it is supplied to the function wrapped by ``action`` as the ``self``
             argument.
-        :param id: is a `uuid.UUID` used to identify the invocation, for example
-            when polling its status via HTTP.
         :param input: is a `pydantic.BaseModel` representing the body of the HTTP
             request that invoked the action. It is supplied to the function as
             keyword arguments.
@@ -381,7 +377,7 @@ class ActionManager:
             thing=thing,
             input=input,
             dependencies=dependencies,
-            id=id,
+            id=uuid.uuid4(),
         )
         self.append_invocation(thread)
         thread.start()
@@ -821,7 +817,6 @@ class ActionDescriptor(
         # the function to the decorator.
         def start_action(
             body: Any,  # This annotation will be overwritten below.
-            id: NonWarningInvocationID,
             background_tasks: BackgroundTasks,
             **dependencies: Any,
         ) -> InvocationModel:
@@ -831,7 +826,6 @@ class ActionDescriptor(
                 thing=thing,
                 input=body,
                 dependencies=dependencies,
-                id=id,
             )
             background_tasks.add_task(action_manager.expire_invocations)
             return action.response()

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/base_descriptor.py

@@ -247,7 +247,7 @@ class BaseDescriptorInfo(
     encountered directly by someone using LabThings, except as a base class for
     `.Action`\ , `.Property` and others.
 
-    LabThings uses descriptors to represent the :ref:`affordances` of a `.Thing`\ .
+    LabThings uses descriptors to represent the :ref:`wot_affordances` of a `.Thing`\ .
     However, passing descriptors around isn't very elegant for two reasons:
 
     * Holding references to Descriptor objects can confuse static type checkers.

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/logs.py

@@ -79,11 +79,11 @@ class DequeByInvocationIDHandler(logging.Handler):
                 pass  # If there's no destination for a particular log, ignore it.
 
 
-def configure_thing_logger() -> None:
+def configure_thing_logger(level: int | None = None) -> None:
     """Set up the logger for thing instances.
 
-    We always set the logger for thing instances to level INFO, as this
-    is currently used to relay progress to the client.
+    We always set the logger for thing instances to level INFO by default,
+    as this is currently used to relay progress to the client.
 
     This function will collect logs on a per-invocation
     basis by adding a `.DequeByInvocationIDHandler` to the log. Only one
@@ -93,8 +93,14 @@ def configure_thing_logger() -> None:
     a filter to add invocation ID is not possible. Instead, we attach a filter to
     the handler, which filters all the records that propagate to it (i.e. anything
     that starts with ``labthings_fastapi.things``).
+
+    :param level: the logging level to use. If not specified, we use INFO.
     """
-    THING_LOGGER.setLevel(logging.INFO)
+    if level is not None:
+        THING_LOGGER.setLevel(level)
+    else:
+        THING_LOGGER.setLevel(logging.INFO)
+
     if not any(
         isinstance(h, DequeByInvocationIDHandler) for h in THING_LOGGER.handlers
     ):

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/outputs/blob.py

@@ -93,7 +93,6 @@ from typing import (
     Literal,
     Mapping,
 )
-from warnings import warn
 from weakref import WeakValueDictionary
 from tempfile import TemporaryDirectory
 import uuid
@@ -615,7 +614,7 @@ class Blob:
         """
         return core_schema.no_info_wrap_validator_function(
             cls._validate,
-            BlobModel.__get_pydantic_core_schema__(BlobModel, handler),
+            BlobModel.__pydantic_core_schema__,
             serialization=core_schema.wrap_serializer_function_ser_schema(
                 cls._serialize,
                 is_field_serializer=False,
@@ -881,40 +880,6 @@ class Blob:
             )
 
 
-def blob_type(media_type: str) -> type[Blob]:
-    r"""Create a `.Blob` subclass for a given media type.
-
-    This convenience function may confuse static type checkers, so it is usually
-    clearer to make a subclass instead, e.g.:
-
-    .. code-block:: python
-
-        class MyImageBlob(Blob):
-            media_type = "image/png"
-
-    :param media_type: the media type that the new `.Blob` subclass will use.
-
-    :return: a subclass of `.Blob` with the specified media type.
-
-    :raise ValueError: if the media type contains ``'`` or ``\``.
-    """
-    warn(
-        "`blob_type` is deprecated and will be removed in v0.1.0. "
-        "Create a subclass of `Blob` instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    if "'" in media_type or "\\" in media_type:
-        raise ValueError("media_type must not contain single quotes or backslashes")
-    return type(
-        f"{media_type.replace('/', '_')}_blob",
-        (Blob,),
-        {
-            "media_type": media_type,
-        },
-    )
-
-
 router = APIRouter()
 """A FastAPI router for BlobData download endpoints."""
 

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/server/__init__.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 from typing import Any, AsyncGenerator, Optional, TypeVar
 from typing_extensions import Self
 import os
+import logging
 
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -27,7 +28,6 @@ from ..logs import configure_thing_logger
 from ..thing import Thing
 from ..thing_server_interface import ThingServerInterface
 from ..thing_description._model import ThingDescription
-from ..dependencies.thing_server import _thing_servers  # noqa: F401
 from .config_model import (
     ThingsConfig,
     ThingServerConfig,
@@ -66,6 +66,7 @@ class ThingServer:
         things: ThingsConfig,
         settings_folder: Optional[str] = None,
         application_config: Optional[Mapping[str, Any]] = None,
+        debug: bool = False,
     ) -> None:
         r"""Initialise a LabThings server.
 
@@ -86,9 +87,12 @@ class ThingServer:
             application. This is not processed by LabThings. Each `.Thing` can access
             application. This is not processed by LabThings. Each `.Thing` can access
             this via the Thing-Server interface.
+        :param debug: If ``True``, set the log level for `.Thing` instances to
+                      DEBUG.
         """
         self.startup_failure: dict | None = None
-        configure_thing_logger()  # Note: this is safe to call multiple times.
+        # Note: this is safe to call multiple times.
+        configure_thing_logger(logging.DEBUG if debug else None)
         self._config = ThingServerConfig(
             things=things,
             settings_folder=settings_folder,
@@ -105,22 +109,23 @@ class ThingServer:
         self.blocking_portal: Optional[BlockingPortal] = None
         self.startup_status: dict[str, str | dict] = {"things": {}}
         global _thing_servers  # noqa: F824
-        _thing_servers.add(self)
         # The function calls below create and set up the Things.
         self._things = self._create_things()
         self._connect_things()
         self._attach_things_to_server()
 
     @classmethod
-    def from_config(cls, config: ThingServerConfig) -> Self:
+    def from_config(cls, config: ThingServerConfig, debug: bool = False) -> Self:
         r"""Create a ThingServer from a configuration model.
 
         This is equivalent to ``ThingServer(**dict(config))``\ .
 
         :param config: The configuration parameters for the server.
+        :param debug: If ``True``, set the log level for `.Thing` instances to
+                      DEBUG.
         :return: A `.ThingServer` configured as per the model.
         """
-        return cls(**dict(config))
+        return cls(**dict(config), debug=debug)
 
     def _set_cors_middleware(self) -> None:
         """Configure the server to allow requests from other origins.

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/server/cli.py

@@ -56,6 +56,11 @@ def get_default_parser() -> ArgumentParser:
         default=5000,
         help="Bind socket to this port. If 0, an available port will be picked.",
     )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging.",
+    )
     return parser
 
 
@@ -149,10 +154,11 @@ def serve_from_cli(
         option is not specified.
     """
     args = parse_args(argv)
+
     try:
         config, server = None, None
         config = config_from_args(args)
-        server = ThingServer.from_config(config)
+        server = ThingServer.from_config(config, True if args.debug else False)
         if dry_run:
             return server
         uvicorn.run(server.app, host=args.host, port=args.port)

{labthings_fastapi-0.0.17 → labthings_fastapi-0.1.0}/src/labthings_fastapi/utilities/__init__.py

@@ -6,7 +6,6 @@ from typing import Any, Dict, Generic, Iterable, TYPE_CHECKING, Optional, TypeVa
 from weakref import WeakSet
 from pydantic import BaseModel, ConfigDict, Field, RootModel, create_model
 from pydantic.dataclasses import dataclass
-from pydantic_core import SchemaError
 
 from labthings_fastapi.exceptions import UnsupportedConstraintError
 from .introspection import EmptyObject
@@ -129,7 +128,7 @@ def wrap_plain_types_in_rootmodel(
     :raises UnsupportedConstraintError: if constraints are provided for an
         unsuitable type, for example `allow_inf_nan` for an `int` property, or
         any constraints for a `BaseModel` subclass.
-    :raises SchemaError: if other errors prevent Pydantic from creating a schema
+    :raises RuntimeError: if other errors prevent Pydantic from creating a schema
         for the generated model.
     """
     try:  # This needs to be a `try` as basic types are not classes
@@ -148,13 +147,9 @@ def wrap_plain_types_in_rootmodel(
             root=(model, Field(**constraints)),
             __base__=LabThingsRootModelWrapper,
         )
-    except SchemaError as e:
-        for error in e.errors():
-            if error["loc"][-1] in constraints:
-                key = error["loc"][-1]
-                raise UnsupportedConstraintError(
-                    f"Constraint {key} is not supported for type {model!r}."
-                ) from e
+    except RuntimeError as e:
+        if "Unable to apply constraint" in str(e):
+            raise UnsupportedConstraintError(str(e)) from e
         raise e
 
 

labthings_fastapi-0.0.17/src/labthings_fastapi/client/in_server.py

@@ -1,344 +0,0 @@
-"""A mock client that uses a Thing directly.
-
-When `.Thing` objects interact on the server, it can be very useful to
-use an interface that is identical to the `.ThingClient` used to access
-the same `.Thing` remotely. This means that code can run either on the
-server or on a client, e.g. in a Jupyter notebook where it is much
-easier to debug. See :ref:`things_from_things` for more detail.
-
-Currently `.DirectThingClient` is not a subclass of `.ThingClient`,
-that may need to change. It's a good idea to create a
-`.DirectThingClient` at module level, so that type hints work.
-
-
-"""
-
-from __future__ import annotations
-from functools import wraps
-import inspect
-import logging
-from typing import Any, Mapping, Optional, Union
-from warnings import warn
-from pydantic import BaseModel
-from ..actions import ActionDescriptor
-
-from ..properties import BaseProperty
-from ..utilities import attributes
-from . import PropertyClientDescriptor
-from ..thing import Thing
-from ..dependencies.thing_server import find_thing_server
-from fastapi import Request
-
-
-__all__ = ["DirectThingClient", "direct_thing_client_class"]
-
-
-class DirectThingClient:
-    """A wrapper for `.Thing` that is a work-a-like for `.ThingClient`.
-
-    This class is used to create a class that works like `.ThingClient`
-    but does not communicate over HTTP. Instead, it wraps a `.Thing` object
-    and calls its methods directly.
-
-    It is not yet 100% identical to `.ThingClient`, in particular `.ThingClient`
-    returns a lot of data directly as deserialised from JSON, while this class
-    generally returns `pydantic.BaseModel` instances, without serialisation.
-
-    `.DirectThingClient` is generally not used on its own, but is subclassed
-    (often dynamically) to add the actions and properties of a particular
-    `.Thing`.
-    """
-
-    __globals__ = globals()  # "bake in" globals so dependency injection works
-    thing_class: type[Thing]
-    """The class of the underlying `.Thing` we are wrapping."""
-    thing_name: str
-    """The name of the Thing on the server."""
-
-    def __init__(self, request: Request, **dependencies: Mapping[str, Any]) -> None:
-        r"""Wrap a `.Thing` so it works like a `.ThingClient`.
-
-        This class is designed to be used as a FastAPI dependency, and will
-        retrieve a `.Thing` based on its ``thing_path`` attribute.
-        Finding the Thing by class may also be an option in the future.
-
-        :param request: This is a FastAPI dependency to access the
-            `fastapi.Request` object, allowing access to various resources.
-        :param \**dependencies: Further arguments will be added
-            dynamically by subclasses, by duplicating this method and
-            manipulating its signature. Adding arguments with annotated
-            type hints instructs FastAPI to inject dependency arguments,
-            such as access to other `.Things`.
-        """
-        warn(
-            "`DirectThingClient` is deprecated and will be removed in v0.1.0. Use "
-            "`lt.thing_slot` instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        server = find_thing_server(request.app)
-        self._wrapped_thing = server.things[self.thing_name]
-        self._request = request
-        self._dependencies = dependencies
-
-
-def property_descriptor(
-    property_name: str,
-    model: Union[type, BaseModel],
-    description: Optional[str] = None,
-    readable: bool = True,
-    writeable: bool = True,
-    property_path: Optional[str] = None,
-) -> PropertyClientDescriptor:
-    """Create a correctly-typed descriptor that gets and/or sets a property.
-
-    .. todo::
-        This is copy-pasted from labthings_fastapi.client.__init__.property_descriptor
-        TODO: refactor this into a shared function.
-
-    Create a descriptor object that wraps a property. This is for use on
-    a `.DirectThingClient` subclass.
-
-    :param property_name: should be the name of the property (i.e. the
-        name it takes in the thing description, and also the name it is
-        assigned to in the class).
-    :param model: the Python ``type`` or a ``pydantic.BaseModel`` that
-        represents the datatype of the property.
-    :param description: text to use for a docstring.
-    :param readable: whether the property may be read (i.e. has ``__get__``).
-    :param writeable: whether the property may be written to.
-    :param property_path: the URL of the ``getproperty`` and ``setproperty``
-        HTTP endpoints. Currently these must both be the same. These are
-        relative to the ``base_url``, i.e. the URL of the Thing Description.
-
-    :return: a descriptor allowing access to the specified property.
-    """
-
-    class P(PropertyClientDescriptor):
-        name = property_name
-        type = model
-        path = property_path or property_name
-
-    def __get__(
-        self: PropertyClientDescriptor,
-        obj: Optional[DirectThingClient] = None,
-        _objtype: Optional[type[DirectThingClient]] = None,
-    ) -> Any:
-        if obj is None:
-            return self
-        return getattr(obj._wrapped_thing, self.name)
-
-    def __set__(
-        self: PropertyClientDescriptor, obj: DirectThingClient, value: Any
-    ) -> None:
-        setattr(obj._wrapped_thing, self.name, value)
-
-    def set_readonly(
-        self: PropertyClientDescriptor, obj: DirectThingClient, value: Any
-    ) -> None:
-        raise AttributeError("This property is read-only.")
-
-    if readable:
-        __get__.__annotations__["return"] = model
-        P.__get__ = __get__  # type: ignore[attr-defined]
-    if writeable:
-        __set__.__annotations__["value"] = model
-        P.__set__ = __set__  # type: ignore[attr-defined]
-    else:
-        set_readonly.__annotations__["value"] = model
-        P.__set__ = set_readonly  # type: ignore[attr-defined]
-    if description:
-        P.__doc__ = description
-    return P()
-
-
-class DependencyNameClashError(KeyError):
-    """A dependency argument name is used inconsistently.
-
-    A current limitation of `.DirectThingClient` is that the dependency
-    arguments (see :ref:`dependencies`) are collected together in a single
-    dictionary. This makes the assumption that, if a name is reused, it is
-    reused for the same dependency.
-
-    When names are reused, we check if the values match. If not, this
-    exception is raised.
-    """
-
-    def __init__(self, name: str, existing: type, new: type) -> None:
-        """Create a DependencyNameClashError.
-
-        See class docstring for an explanation of the error.
-
-        :param name: the name of the clashing dependencies.
-        :param existing: the dependency type annotation in the dictionary.
-        :param new: the clashing type annotation.
-        """
-        super().__init__(
-            f"{self.__doc__}\n\n"
-            f"This clash is with name: {name}.\n"
-            f"Its value is currently {existing}, which clashes with {new}."
-        )
-
-
-def add_action(
-    attrs: dict[str, Any],
-    dependencies: list[inspect.Parameter],
-    name: str,
-    action: ActionDescriptor,
-) -> None:
-    """Generate an action method and adds it to an attrs dict.
-
-    FastAPI Dependencies are appended to the `dependencies` list.
-    This list should later be converted to type hints on the class
-    initialiser, so that FastAPI supplies the dependencies when
-    the `.DirectThingClient` is initialised.
-
-    :param attrs: the attributes of a soon-to-be-created `.DirectThingClient`
-        subclass. This will be passed to `type()` to create the subclass.
-        We will add the action method to this dictionary.
-    :param dependencies: lists the dependency parameters that will be
-        injected by FastAPI as arguments to the class ``__init__``.
-        Any dependency parameters of the supplied ``action`` should be
-        added to this list.
-    :param name: the name of the action. Should be the name of the
-        attribute, i.e. we will set ``attrs[name]``, and also match
-        the ``name`` in the supplied action descriptor.
-    :param action: an `.ActionDescriptor` to be wrapped.
-
-    :raise DependencyNameClashError: if dependencies are inconsistent.
-    """
-
-    @wraps(action.func)
-    def action_method(self: DirectThingClient, **kwargs: Any) -> Any:
-        dependency_kwargs = {
-            param.name: self._dependencies[param.name]
-            for param in action.dependency_params
-        }
-        kwargs_and_deps = {**kwargs, **dependency_kwargs}
-        return getattr(self._wrapped_thing, name)(**kwargs_and_deps)
-
-    attrs[name] = action_method
-    # We collect up all the dependencies, so that we can
-    # resolve them when we create the client.
-    for param in action.dependency_params:
-        included = False
-        for existing_param in dependencies:
-            if existing_param.name == param.name:
-                # Currently, each name may only have one annotation, across
-                # all actions - this is a limitation we should fix.
-                if existing_param.annotation != param.annotation:
-                    raise DependencyNameClashError(
-                        param.name, existing_param.annotation, param.annotation
-                    )
-                included = True
-        if not included:
-            dependencies.append(param)
-
-
-def add_property(
-    attrs: dict[str, Any], property_name: str, property: BaseProperty
-) -> None:
-    """Add a property to a DirectThingClient subclass.
-
-    We create a new descriptor using `.property_descriptor` and add it
-    to the ``attrs`` dictionary as ``property_name``.
-
-    :param attrs: the attributes of a soon-to-be-created `.DirectThingClient`
-        subclass. This will be passed to `type()` to create the subclass.
-        We will add the property to this dictionary.
-    :param property_name: the name of the property. Should be the name of the
-        attribute, i.e. we will set ``attrs[name]``.
-    :param property: a `.PropertyDescriptor` to be wrapped.
-    """
-    attrs[property_name] = property_descriptor(
-        property_name,
-        property.model,
-        description=property.description,
-        writeable=not property.readonly,
-        readable=True,
-    )
-
-
-def direct_thing_client_class(
-    thing_class: type[Thing],
-    thing_name: str,
-    actions: Optional[list[str]] = None,
-) -> type[DirectThingClient]:
-    r"""Create a DirectThingClient from a Thing class and a path.
-
-    This is a class, not an instance: it's designed to be a FastAPI dependency.
-
-    :param thing_class: The `.Thing` subclass that will be wrapped.
-    :param thing_name: The name of the `.Thing` on the server.
-    :param actions: An optional list giving a subset of actions that will be
-        accessed. If this is specified, it may reduce the number of FastAPI
-        dependencies we need.
-
-    :return: a subclass of `DirectThingClient` with attributes that match the
-        properties and actions of ``thing_class``. The ``__init__`` method
-        will have annotations that instruct FastAPI to supply all the
-        dependencies needed by its actions.
-
-        This class may be used as a FastAPI dependency: see :ref:`things_from_things`.
-    """
-    warn(
-        "`direct_thing_client_class` is deprecated and will be removed in v0.1.0. "
-        "Use `lt.thing_slot` instead.",
-        DeprecationWarning,
-        stacklevel=3,  # This is called from `direct_thing_client_dependency` so we
-        # need stacklevel=3 to point to user code.
-    )
-
-    def init_proxy(
-        self: DirectThingClient, request: Request, **dependencies: Mapping[str, Any]
-    ) -> None:
-        r"""Initialise a DirectThingClient (this docstring will be replaced).
-
-        :param self: The DirectThingClient instance we're initialising.
-        :param request: a FastAPI Request option (will be supplied by FastAPI).
-        :param \**dependencies: Other keyword arguments will be saved as
-            dependencies. FastAPI will look at the signature (which we will
-            manipulate below) to determine these.
-        """
-        # NB this definition isimportant, as we must modify its signature.
-        # Inheriting __init__ means we'll accidentally modify the signature
-        # of `DirectThingClient` with bad results.
-        DirectThingClient.__init__(self, request, **dependencies)
-
-    init_proxy.__doc__ = f"""Initialise a client for {thing_class}"""
-
-    # Using a class definition gets confused by the scope of the function
-    # arguments - this is equivalent to a class definition but all the
-    # arguments are evaluated in the right scope.
-    client_attrs = {
-        "thing_class": thing_class,
-        "thing_name": thing_name,
-        "__doc__": f"A client for {thing_class} named {thing_name}",
-        "__init__": init_proxy,
-    }
-    dependencies: list[inspect.Parameter] = []
-    for name, item in attributes(thing_class):
-        if isinstance(item, BaseProperty):
-            add_property(client_attrs, name, item)
-        elif isinstance(item, ActionDescriptor):
-            if actions is None or name in actions:
-                add_action(client_attrs, dependencies, name, item)
-            else:
-                continue  # Ignore actions that aren't in the list
-        else:
-            for affordance in ["property", "action", "event"]:
-                if hasattr(item, f"{affordance}_affordance"):
-                    logging.warning(
-                        f"DirectThingClient doesn't support custom affordances, "
-                        f"ignoring {name}"
-                    )
-    # This block of code makes dependencies show up in __init__ so
-    # they get resolved. It's more or less copied from the `action` descriptor.
-    sig = inspect.signature(init_proxy)
-    params = [p for p in sig.parameters.values() if p.name != "dependencies"]
-    init_proxy.__signature__ = sig.replace(  # type: ignore[attr-defined]
-        parameters=params + dependencies
-    )
-    return type(
-        f"{thing_class.__name__}DirectClient", (DirectThingClient,), client_attrs
-    )