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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labthings-fastapi
-Version: 0.0.16
+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.16 → labthings_fastapi-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "labthings-fastapi"
-version = "0.0.16"
+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.16 → 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.16 → 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.16 → 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.
@@ -335,22 +335,6 @@ class BaseDescriptorInfo(
         descriptor = self.get_descriptor()
         return descriptor.__get__(self.owning_object_or_error())
 
-    def set(self, value: Value) -> None:
-        """Set the value of the descriptor.
-
-        This method may only be called if the DescriptorInfo object is bound to a
-        `.Thing` instance. It will raise an error if called on a class.
-
-        :param value: the new value.
-
-        :raises NotBoundToInstanceError: if called on an unbound info object.
-        """
-        if not self.is_bound:
-            msg = f"We can't set the value of {self.name} when called on a class."
-            raise NotBoundToInstanceError(msg)
-        descriptor = self.get_descriptor()
-        descriptor.__set__(self.owning_object_or_error(), value)
-
     def __eq__(self, other: Any) -> bool:
         """Determine if this object is equal to another one.
 
@@ -404,6 +388,11 @@ class BaseDescriptor(Generic[Owner, Value]):
         assert p.name == "my_prop"
         assert p.title == "My Property."
         assert p.description.startswith("This is")
+
+    `.BaseDescriptor` is a "non-data descriptor" (meaning it doesn't implement
+    ``__set__``). This allows it to be overwritten by assigning to an object's
+    attribute, which can be useful in test code. This can easily be changed in
+    subclasses by implementing ``__set__``\ .
     """
 
     def __init__(self) -> None:
@@ -593,21 +582,6 @@ class BaseDescriptor(Generic[Owner, Value]):
             "See BaseDescriptor.__instance_get__ for details."
         )
 
-    def __set__(self, obj: Owner, value: Value) -> None:
-        """Mark the `BaseDescriptor` as a data descriptor.
-
-        Even for read-only descriptors, it's important to define a ``__set__`` method.
-        The presence of this method prevents Python overwriting the descriptor when
-        a value is assigned. This base implementation returns an `AttributeError` to
-        signal that the descriptor is read-only. Overriding it with a method that
-        does not raise an exception will allow the descriptor to be written to.
-
-        :param obj: The object on which to set the value.
-        :param value: The value to set the descriptor to.
-        :raises AttributeError: always, as this is read-only by default.
-        """
-        raise AttributeError("This attribute is read-only.")
-
     def _descriptor_info(
         self, info_class: type[DescriptorInfoT], obj: Owner | None = None
     ) -> DescriptorInfoT:
@@ -669,9 +643,35 @@ class FieldTypedBaseDescriptorInfo(
         """The type of the descriptor's value."""
         return self.get_descriptor().value_type
 
+    def set(self, value: Value) -> None:
+        """Set the value of the descriptor.
+
+        This method may only be called if the DescriptorInfo object is bound to a
+        `.Thing` instance. It will raise an error if called on a class.
+
+        :param value: the new value.
+
+        :raises NotBoundToInstanceError: if called on an unbound info object.
+        """
+        if not self.is_bound:
+            msg = f"We can't set the value of {self.name} when called on a class."
+            raise NotBoundToInstanceError(msg)
+        descriptor = self.get_descriptor()
+        descriptor.__set__(self.owning_object_or_error(), value)
+
 
 class FieldTypedBaseDescriptor(Generic[Owner, Value], BaseDescriptor[Owner, Value]):
-    """A BaseDescriptor that determines its type like a dataclass field."""
+    r"""A `.BaseDescriptor` that determines its type like a dataclass field.
+
+    This adds two things to `.BaseDescriptor`\ :
+
+    1. Descriptors inheriting from this class will inspect the type annotations of
+        their owning class when determining ``value_type``\ .
+    2. This class and its children will be "data descriptors" because there is a
+        stub implementation of ``__set__``\ . This means that the attribute may not
+        be assigned to (unless ``__set__`` is overridden). This is the behaviour
+        that `builtins.property` has.
+    """
 
     def __init__(self) -> None:
         """Initialise the FieldTypedBaseDescriptor.
@@ -852,6 +852,21 @@ class FieldTypedBaseDescriptor(Generic[Owner, Value], BaseDescriptor[Owner, Valu
         """
         return self._descriptor_info(FieldTypedBaseDescriptorInfo, owner)
 
+    def __set__(self, obj: Owner, value: Value) -> None:
+        """Mark the `BaseDescriptor` as a data descriptor.
+
+        Even for read-only descriptors, it's important to define a ``__set__`` method.
+        The presence of this method prevents Python overwriting the descriptor when
+        a value is assigned. This base implementation returns an `AttributeError` to
+        signal that the descriptor is read-only. Overriding it with a method that
+        does not raise an exception will allow the descriptor to be written to.
+
+        :param obj: The object on which to set the value.
+        :param value: The value to set the descriptor to.
+        :raises AttributeError: always, as this is read-only by default.
+        """
+        raise AttributeError("This attribute is read-only.")
+
 
 class DescriptorInfoCollection(
     Mapping[str, DescriptorInfoT],

{labthings_fastapi-0.0.16 → 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.16 → 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.16 → 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.16 → 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.16 → 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