labthings-fastapi 0.2.0rc1__tar.gz → 0.2.1__tar.gz

{labthings_fastapi-0.2.0rc1 → labthings_fastapi-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labthings-fastapi
-Version: 0.2.0rc1
+Version: 0.2.1
 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

{labthings_fastapi-0.2.0rc1 → labthings_fastapi-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "labthings-fastapi"
-version = "0.2.0-rc1"
+version = "0.2.1"
 authors = [
   { name="Richard Bowman", email="richard.bowman@cantab.net" },
 ]

{labthings_fastapi-0.2.0rc1 → labthings_fastapi-0.2.1}/src/labthings_fastapi/server/__init__.py

@@ -146,9 +146,9 @@ class ThingServer:
         self._set_url_for_middleware()
         self._add_exception_handlers()
         self.action_manager = ActionManager()
-        self.app.include_router(self.action_manager.router(), prefix=self._api_prefix)
-        self.app.include_router(blob.router, prefix=self._api_prefix)
-        self.app.include_router(self._things_view_router(), prefix=self._api_prefix)
+        self.app.include_router(self.action_manager.router(), prefix=self.api_prefix)
+        self.app.include_router(blob.router, prefix=self.api_prefix)
+        self.app.include_router(self._things_view_router(), prefix=self.api_prefix)
         self.blocking_portal: Optional[BlockingPortal] = None
         self.startup_status: dict[str, str | dict] = {"things": {}}
         global _thing_servers  # noqa: F824
@@ -270,10 +270,7 @@ class ThingServer:
 
     @property
     def things(self) -> Mapping[str, Thing]:
-        """Return a dictionary of all the things.
-
-        :return: a dictionary mapping thing paths to `~lt.Thing` instances.
-        """
+        """A read-only mapping of names to `~lt.Thing` instances."""
         return MappingProxyType(self._things)
 
     @property
@@ -286,7 +283,7 @@ class ThingServer:
         return self._config.application_config
 
     @property
-    def _api_prefix(self) -> str:
+    def api_prefix(self) -> str:
         r"""A string that prefixes all URLs in the application.
 
         This will either be empty, or start with a slash and not
@@ -337,7 +334,7 @@ class ThingServer:
         """
         if name not in self._things:
             raise KeyError(f"No thing named {name} has been added to this server.")
-        return f"{self._api_prefix}/{name}/"
+        return f"{self.api_prefix}/{name}/"
 
     def _create_things(self) -> Mapping[str, Thing]:
         r"""Create the Things, add them to the server, and connect them up if needed.
@@ -475,7 +472,7 @@ class ThingServer:
             """
             return {
                 name: thing.thing_description(
-                    path=f"{self._api_prefix}/{name}/", base=str(request.base_url)
+                    path=f"{self.api_prefix}/{name}/", base=str(request.base_url)
                 )
                 for name, thing in thing_server.things.items()
             }

{labthings_fastapi-0.2.0rc1 → labthings_fastapi-0.2.1}/src/labthings_fastapi/server/fallback.py

@@ -16,6 +16,7 @@ from traceback import format_exception
 from typing import Any, TYPE_CHECKING
 
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
 from jinja2 import Environment, BaseLoader, select_autoescape
 from starlette.responses import RedirectResponse
@@ -149,6 +150,15 @@ class FallbackApp(FastAPI):
 
 app = FallbackApp()
 
+# Add middleware so contacting the the fallback server doesn't throw CORS errors.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 
 @app.get("/")
 async def root() -> HTMLResponse:
@@ -159,6 +169,17 @@ async def root() -> HTMLResponse:
     return app.fallback_page()
 
 
+@app.get("/labthings_fallback")
+async def fallback_route() -> bool:
+    """Return True, this is a LabThings Fallback Server.
+
+    Use this to check over the API if this is a LabThings Fallback Server.
+
+    :return: returns True. This is a LabThings Fallback Server.
+    """
+    return True
+
+
 def _format_error_and_traceback(context: FallbackContext) -> tuple[str, str]:
     """Format the error and traceback.
 

{labthings_fastapi-0.2.0rc1 → labthings_fastapi-0.2.1}/src/labthings_fastapi/testing.py

@@ -1,7 +1,7 @@
 """Test harnesses to help with writitng tests for things.."""
 
 from __future__ import annotations
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from concurrent.futures import Future
 from contextlib import contextmanager
 from typing import (
@@ -270,3 +270,37 @@ def use_dummy_url_for() -> Iterator[None]:
     """Use the dummy URL for function in the context variable."""
     with set_url_for_context(dummy_url_for):
         yield
+
+
+def manually_connect_thing_slot(
+    host: Thing,
+    slot_name: str,
+    target: Thing | Sequence[Thing],
+) -> None:
+    """Manually connect a thing_slot.
+
+    This will accept either a single `Thing` instance or a sequence
+    of `Thing` instances. If `Mock` instances are used, note that they
+    must pass an `isinstance` test, so should use the ``spec`` argument
+    to specify the correct class for the `~lt.thing_slot` being mocked.
+    Mock instances must also provide a unique ``name`` attribute.
+
+    :param host: the `~lt.Thing` on which the slot is defined.
+    :param slot_name: the name of the `~lt.thing_slot`.
+    :param target: the `~lt.Thing` or sequence of Things it should be connected to.
+        If a sequence of multiple Thing are passed, their names are used to create a
+        mapping.
+    :raises KeyError: if multiple targets are specified, but they do not
+        have unique names.
+    """
+    if not isinstance(target, Sequence):
+        names: str | Sequence[str] = target.name
+        things = {target.name: target}
+    else:
+        names = [t.name for t in target]
+        if len(set(names)) != len(names):
+            msg = f"Thing slot targets {names} are not uniquely named."
+            raise KeyError(msg)
+        things = {t.name: t for t in target}
+    slot = getattr(host.__class__, slot_name)
+    slot.connect(host, target=names, things=things)

{labthings_fastapi-0.2.0rc1 → labthings_fastapi-0.2.1}/src/labthings_fastapi/thing_class_settings.py

@@ -89,17 +89,19 @@ def get_validate_properties_on_set(cls: "type[Thing]") -> bool:
     :return: whether validation should be performed.
     """
     settings = get_class_settings(cls)
-    if "validate_properties_on_set" not in settings:
+    value = settings.get(
+        "validate_properties_on_set",
+        False,
+    )
+    if not value:
         warnings.warn(
             DefaultWillChangeWarning(
                 "`get_validate_properties_on_set` will become `True` by default "
-                "in the future. Set this property explicitly to `True` or `False` in "
+                "in the future, and may become the only option. "
+                "Set this property to `True` in "
                 f"`{cls.__module__}.{cls.__name__}._class_settings` "
                 "to eliminate this warning."
             ),
             stacklevel=3,
         )
-    return settings.get(
-        "validate_properties_on_set",
-        False,
-    )
+    return value