mesh-sandbox 1.0.10__py3-none-any.whl → 1.0.12__py3-none-any.whl

mesh_sandbox/__init__.py

@@ -1 +1 @@
-__version__ = "1.0.10"
+__version__ = "1.0.12"

mesh_sandbox/api.py

@@ -38,7 +38,6 @@ app = FastAPI(
 
 @app.on_event("startup")
 async def startup():
-
     config = get_env_config()
     # pylint: disable=logging-fstring-interpolation
     logger.info(f"startup auth_mode: {config.auth_mode} store_mode: {config.store_mode}")

mesh_sandbox/common/__init__.py

@@ -4,7 +4,7 @@ import os
 from dataclasses import dataclass, field
 from functools import partial
 from hashlib import sha256
-from typing import Any, Callable, Final, Optional, TypeVar, Union
+from typing import Any, Callable, Final, Optional, TypeVar
 
 from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel  # pylint: disable=no-name-in-module
@@ -47,7 +47,6 @@ def strtobool(val: Any) -> Optional[bool]:
 
 @dataclass
 class EnvConfig:
-
     env: str = field(default="local")
     build_label: str = field(default="latest")
     auth_mode: str = field(default="no_auth")
@@ -72,7 +71,6 @@ T = TypeVar("T")
 
 
 def index_of(items: list[T], find: Callable[[T], bool]) -> int:
-
     for index, elem in enumerate(items):
         if find(elem):
             return index

mesh_sandbox/common/messaging.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from functools import wraps
 from types import ModuleType
-from typing import Any, Callable, Literal, NamedTuple, Optional, TypeVar, cast
+from typing import Any, Callable, ClassVar, Literal, NamedTuple, Optional, TypeVar, cast
 
 from fastapi import HTTPException, status
 from starlette.background import BackgroundTasks
@@ -19,24 +19,25 @@ from . import constants, generate_cipher_text
 
 
 class _SandboxPlugin(ABC):
-
-    triggers: list[
-        Literal[
-            "before_accept_message",
-            "after_accept_message",
-            "accept_message_error",
-            "before_save_message",
-            "after_save_message",
-            "save_message_error",
-            "before_send_message",
-            "after_send_message",
-            "send_message_error",
-            "before_acknowledge_message",
-            "after_acknowledge_message",
-            "acknowledge_message_error",
-            "before_save_chunk",
-            "after_save_chunk",
-            "save_chunk_error",
+    triggers: ClassVar[
+        list[
+            Literal[
+                "before_accept_message",
+                "after_accept_message",
+                "accept_message_error",
+                "before_save_message",
+                "after_save_message",
+                "save_message_error",
+                "before_send_message",
+                "after_send_message",
+                "send_message_error",
+                "before_acknowledge_message",
+                "after_acknowledge_message",
+                "acknowledge_message_error",
+                "before_save_chunk",
+                "after_save_chunk",
+                "save_chunk_error",
+            ]
         ]
     ] = []
 
@@ -83,7 +84,6 @@ MESH_AUTH_SCHEME = "NHSMESH"
 
 
 def try_parse_authorisation_token(auth_token: str) -> Optional[AuthoriseHeaderParts]:
-
     if not auth_token:
         return None
 
@@ -126,7 +126,6 @@ class Messaging:
             self.event_name = event_name
 
         def __call__(self, func):
-
             if not inspect.iscoroutinefunction(func):
                 raise ValueError(f"wrapped function is not awaitable: {func}")
 
@@ -155,7 +154,6 @@ class Messaging:
 
     class _IfNotReadonly:
         def __call__(self, func):
-
             if not inspect.iscoroutinefunction(func):
                 raise ValueError(f"wrapped function is not awaitable: {func}")
 
@@ -170,18 +168,15 @@ class Messaging:
             return _async_inner
 
     def _find_plugins(self, package: ModuleType):
-
         for _, name, _ in pkgutil.iter_modules(package.__path__, package.__name__ + "."):
             module = importlib.import_module(name)
             for _, plugin_type in inspect.getmembers(module):
-
                 if not inspect.isclass(plugin_type) or not plugin_type.__name__.endswith("Plugin"):
                     continue
 
                 self.register_plugin(plugin_type)
 
     def register_plugin(self, plugin_type: type):
-
         self.logger.info(f"potential plugin: {plugin_type.__name__} found")
         if not hasattr(plugin_type, "triggers"):
             self.logger.warning(f"plugin: {plugin_type.__name__} has no class attr triggers .. not loading")
@@ -224,7 +219,6 @@ class Messaging:
         return created
 
     async def on_event(self, event: str, event_args: dict[str, Any], exception: Optional[Exception] = None):
-
         instances = self._plugin_instances.get(event, [])
         if not instances:
             registered = self._plugin_registry.get(event, [])
@@ -245,7 +239,6 @@ class Messaging:
 
     @_TriggersEvent(event_name="send_message")
     async def send_message(self, message: Message, body: bytes, background_tasks: BackgroundTasks) -> Message:
-
         if message.total_chunks > 0:
             await self.save_chunk(message=message, chunk_number=1, chunk=body, background_tasks=background_tasks)
 
@@ -261,7 +254,6 @@ class Messaging:
     @_TriggersEvent(event_name="accept_message")
     @_IfNotReadonly()
     async def accept_message(self, message: Message, file_size: int, background_tasks: BackgroundTasks):
-
         if message.status != MessageStatus.ACCEPTED:
             message.events.insert(0, MessageEvent(status=MessageStatus.ACCEPTED))
 
@@ -284,7 +276,6 @@ class Messaging:
     async def add_message_event(
         self, message: Message, event: MessageEvent, background_tasks: BackgroundTasks
     ) -> Message:
-
         message.events.insert(0, event)
         await self.save_message(message=message, background_tasks=background_tasks)
 
@@ -342,7 +333,6 @@ class Messaging:
         return await self.get_inbox_messages(mailbox_id, _accepted_messages)
 
     async def _validate_auth_token(self, mailbox_id: str, authorization: str) -> Optional[Mailbox]:
-
         if self.config.auth_mode == "none":
             return await self.get_mailbox(mailbox_id, accessed=True)
 
@@ -358,7 +348,6 @@ class Messaging:
             raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_MAILBOX_TOKEN_MISMATCH)
 
         if self.config.auth_mode == "canned":
-
             if header_parts.nonce.upper() != "VALID":
                 raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=constants.ERROR_INVALID_AUTH_TOKEN)
             return await self.get_mailbox(mailbox_id, accessed=True)
@@ -386,7 +375,6 @@ class Messaging:
         return mailbox
 
     async def authorise_mailbox(self, mailbox_id: str, authorization: str) -> Optional[Mailbox]:
-
         mailbox = await self._validate_auth_token(mailbox_id, authorization)
 
         if not mailbox:

mesh_sandbox/common/mex_headers.py

@@ -10,7 +10,6 @@ from .constants import Headers
 
 
 def ensure_text(text: str, encoding="utf-8", errors="strict"):
-
     if isinstance(text, str):
         return text
 

mesh_sandbox/conftest.py

@@ -15,9 +15,8 @@ from .dependencies import get_env_config, get_messaging, get_store
 from .tests.helpers import temp_env_vars
 
 
-@pytest.fixture(scope="function", autouse=True)
+@pytest.fixture(autouse=True)
 def setup():
-
     get_store.cache_clear()
     get_env_config.cache_clear()
     get_messaging.cache_clear()
@@ -32,9 +31,8 @@ def setup():
         yield
 
 
-@pytest.fixture(scope="function", name="app")
+@pytest.fixture(name="app")
 def test_app() -> TestClient:
-
     return TestClient(app)
 
 
@@ -58,7 +56,6 @@ class StoppableServer:
 
 @pytest.fixture(scope="session", name="base_uri")
 def create_server(unused_tcp_port_factory: Callable[[], int]):
-
     port = unused_tcp_port_factory()
 
     server = StoppableServer(port)
@@ -66,7 +63,6 @@ def create_server(unused_tcp_port_factory: Callable[[], int]):
     server_thread = Thread(target=server.run)
     server_thread.start()
     try:
-
         base_uri = f"http://localhost:{port}"
         timeout = time() + 1
         with httpx.Client(base_url=base_uri) as client:

mesh_sandbox/dependencies.py

@@ -18,7 +18,6 @@ _ACCEPTABLE_ACCEPTS = re.compile(r"^application/vnd\.mesh\.v(\d+)\+json$")
 
 
 def parse_accept_header(accept: Optional[str]) -> Optional[int]:
-
     if not accept:
         return 1
 
@@ -107,17 +106,17 @@ async def normalise_content_type(
     return (content_type or "").strip().lower()
 
 
-@lru_cache()
+@lru_cache
 def get_env_config() -> EnvConfig:
     return EnvConfig()
 
 
-@lru_cache()
+@lru_cache
 def get_logger() -> logging.Logger:
     return logging.getLogger("mesh-sandbox")
 
 
-@lru_cache()
+@lru_cache
 def get_store() -> Store:
     logger = get_logger()
     config = get_env_config()
@@ -133,12 +132,12 @@ def get_store() -> Store:
     raise ValueError(f"unrecognised store mode {config.store_mode}")
 
 
-@lru_cache()
+@lru_cache
 def get_messaging() -> Messaging:
     return Messaging(store=get_store())
 
 
-@lru_cache()
+@lru_cache
 def get_fernet() -> FernetHelper:
     return FernetHelper()
 

mesh_sandbox/handlers/admin.py

@@ -22,7 +22,6 @@ class AdminHandler:
         self.messaging = messaging
 
     async def reset(self, mailbox_id: Optional[str] = None):
-
         if self.messaging.readonly:
             raise HTTPException(
                 status_code=status.HTTP_405_METHOD_NOT_ALLOWED,
@@ -91,7 +90,6 @@ class AdminHandler:
     async def add_message_event(
         self, message_id: str, new_event: AddMessageEventRequest, background_tasks: BackgroundTasks
     ):
-
         message = await self.messaging.get_message(message_id)
         if not message:
             raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)

mesh_sandbox/handlers/handshake.py

@@ -6,7 +6,6 @@ from ..models.mailbox import Mailbox
 
 
 class HandshakeHandler:
-
     # pylint: disable=too-many-arguments
     async def handshake(
         self,
@@ -20,7 +19,6 @@ class HandshakeHandler:
         mex_osarchitecture: str,
         accepts_api_version: int = 1,
     ):
-
         if accepts_api_version < 2:
             return {"mailboxId": mailbox.mailbox_id}
 

mesh_sandbox/handlers/inbox.py

@@ -42,7 +42,6 @@ class InboxHandler:
 
     @staticmethod
     def _get_status_headers(message: Message) -> dict[str, Optional[str]]:
-
         status_timestamp = (
             message.status_timestamp(MessageStatus.ACCEPTED, MessageStatus.ERROR) or datetime.utcnow()
         ).strftime("%Y%m%d%H%M%S")
@@ -50,7 +49,6 @@ class InboxHandler:
         error_event = message.error_event
 
         if message.message_type == MessageType.DATA and not error_event:
-
             return {
                 Headers.Mex_StatusCode: "00",
                 Headers.Mex_StatusEvent: "TRANSFER",
@@ -76,7 +74,6 @@ class InboxHandler:
 
     @staticmethod
     def _get_response_headers(message: Message, chunk_number: int):
-
         headers = {
             Headers.Mex_From: message.sender.mailbox_id,
             Headers.Mex_To: message.recipient.mailbox_id,
@@ -108,7 +105,6 @@ class InboxHandler:
         return {h: v for h, v in headers.items() if v}
 
     async def head_message(self, mailbox: Mailbox, message_id: str):
-
         message = await self.messaging.get_message(message_id)
 
         if not message:
@@ -211,7 +207,6 @@ class InboxHandler:
     async def acknowledge_message(
         self, background_tasks: BackgroundTasks, mailbox: Mailbox, message_id: str, accepts_api_version: int = 1
     ):
-
         message = await self.messaging.get_message(message_id)
         if not message:
             raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=constants.ERROR_MESSAGE_DOES_NOT_EXIST)
@@ -240,7 +235,6 @@ class InboxHandler:
         message_filter: Optional[Callable[[Message], bool]] = None,
         rich: bool = False,
     ) -> tuple[list[Message], Optional[dict]]:
-
         messages = (
             sorted(
                 await self.messaging.get_inbox_messages(mailbox.mailbox_id),
@@ -270,8 +264,7 @@ class InboxHandler:
         return messages, last_key
 
     @staticmethod
-    def _get_workflow_filter(workflow_filter: Optional[str]) -> Optional[Callable[[Message], bool]]:
-
+    def _get_workflow_filter(workflow_filter: Optional[str]) -> Optional[Callable[[Message], bool]]:  # noqa: C901
         workflow_id_filter = (workflow_filter or "").strip()
         if not workflow_id_filter:
             return None
@@ -332,7 +325,6 @@ class InboxHandler:
         continue_from: Optional[str] = None,
         workflow_filter: Optional[str] = None,
     ) -> Response:
-
         last_key: Optional[dict] = None
 
         if continue_from:
@@ -379,7 +371,6 @@ class InboxHandler:
         continue_from: Optional[str],
         max_results: int = 100,
     ) -> JSONResponse:
-
         last_key: Optional[dict] = None
         if continue_from:
             last_key = self.fernet.decode_dict(continue_from)

mesh_sandbox/handlers/lookup.py

@@ -10,7 +10,6 @@ class LookupHandler:
         self.messaging = messaging
 
     async def lookup_by_ods_code_and_workflow(self, ods_code: str, workflow_id: str, accepts_api_version: int = 1):
-
         if not ods_code or (ods_code and not ods_code.strip()):
             raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="ods code missing")
 
@@ -22,7 +21,6 @@ class LookupHandler:
         return endpoint_lookup_response(mailboxes, accepts_api_version)
 
     async def lookup_by_workflow_id(self, workflow_id: str, accepts_api_version: int = 1):
-
         if not workflow_id or (workflow_id and not workflow_id.strip()):
             raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="workflow id missing")
 

mesh_sandbox/handlers/outbox.py

@@ -43,7 +43,7 @@ def get_chunk_range(chunk_range: str, request_chunk_no: int) -> tuple[Optional[s
         return "bad headers", 0, 0
 
     try:
-        chunk_no, total_chunks = [int(val.strip()) for val in parts]
+        chunk_no, total_chunks = (int(val.strip()) for val in parts)
     except ValueError:
         return "bad header value - chunk values should be numeric", 0, 0
 
@@ -78,7 +78,6 @@ class OutboxHandler:
         content_type: str,
         accepts_api_version: int = 1,
     ):  # pylint: disable=too-many-locals
-
         if not mex_headers.mex_to:
             raise HTTPException(status_code=http_status.HTTP_400_BAD_REQUEST, detail=constants.ERROR_MISSING_TO_ADDRESS)
 
@@ -146,11 +145,9 @@ class OutboxHandler:
         await self.messaging.send_message(message=message, body=body, background_tasks=background_tasks)
 
         self.logger.info(
-            (
-                f"created message: message_id={message.message_id} "
-                f"from={message.sender.mailbox_id} to={message.recipient.mailbox_id} "
-                f"workflow={message.workflow_id or ''}"
-            )
+            f"created message: message_id={message.message_id} "
+            f"from={message.sender.mailbox_id} to={message.recipient.mailbox_id} "
+            f"workflow={message.workflow_id or ''}"
         )
 
         return send_message_response(message, accepts_api_version)
@@ -166,7 +163,6 @@ class OutboxHandler:
         content_encoding: str,
         accepts_api_version: int = 1,
     ):
-
         chunk_range = (mex_chunk_range or "").strip()
         if not chunk_range:
             raise MessagingException(

mesh_sandbox/handlers/tracking.py

@@ -17,7 +17,6 @@ class TrackingHandler:
         self.messaging = messaging
 
     async def tracking_by_message_id(self, sender_mailbox: Mailbox, message_id: str, accepts_api_version: int = 1):
-
         message: Optional[Message] = await self.messaging.get_message(message_id)
 
         if not message:
@@ -35,7 +34,6 @@ class TrackingHandler:
         return JSONResponse(content=exclude_none_json_encoder(model), media_type=MESH_MEDIA_TYPES[accepts_api_version])
 
     async def tracking_by_local_id(self, sender_mailbox: Mailbox, local_id: str):
-
         messages: list[Message] = await self.messaging.get_by_local_id(sender_mailbox.mailbox_id, local_id)
 
         if len(messages) == 0:

mesh_sandbox/models/mailbox.py

@@ -5,7 +5,6 @@ from typing import Optional
 
 @dataclass
 class Mailbox:
-
     mailbox_id: str
     mailbox_name: str
     billing_entity: Optional[str] = field(default=None)
@@ -35,5 +34,4 @@ class Mailbox:
         self._inbox_count = inbox_count
 
     def __post_init__(self):
-
         self.mailbox_id = self.mailbox_id.upper()

mesh_sandbox/models/message.py

@@ -1,12 +1,12 @@
+from collections.abc import Generator
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Callable, Final, Generator, Optional
+from typing import Callable, Final, Optional
 
 from dateutil.relativedelta import relativedelta
 
 
 class MessageStatus:
-
     UPLOADING: Final[str] = "uploading"  # still uploading chunks
     ACCEPTED: Final[str] = "accepted"  # finished uploading
     ACKNOWLEDGED: Final[str] = "acknowledged"  # client has acknowledged the message
@@ -17,7 +17,6 @@ class MessageStatus:
 
 
 class MessageType:
-
     REPORT: Final[str] = "REPORT"
     DATA: Final[str] = "DATA"
 
@@ -31,7 +30,6 @@ class MessageDeliveryStatus:
 
 @dataclass
 class MessageMetadata:
-
     subject: Optional[str] = field(default=None)
     content_type: Optional[str] = field(default=None)
     content_encoding: Optional[str] = field(default=None)
@@ -133,6 +131,5 @@ class Message:  # pylint: disable=too-many-public-methods,too-many-instance-attr
                 yield event
 
     def __post_init__(self):
-
         self.message_id = self.message_id.upper()
         self.events = self.events or [MessageEvent(status=MessageStatus.ACCEPTED, timestamp=self.created_timestamp)]

mesh_sandbox/models/workflow.py

@@ -3,13 +3,11 @@ from dataclasses import dataclass, field
 
 @dataclass
 class Workflow:
-
     workflow_id: str
     senders: list[str] = field(default_factory=list)
     receivers: list[str] = field(default_factory=list)
 
     def __post_init__(self):
-
         self.workflow_id = (self.workflow_id or "").strip()
 
         self.senders = [mailbox for mailbox in ((mb or "").strip().upper() for mb in self.senders) if mailbox]

mesh_sandbox/routers/inbox.py

@@ -35,8 +35,8 @@ router = APIRouter(
     responses={
         status.HTTP_200_OK: {
             "content": {
-                MESH_MEDIA_TYPES[2]: {"schema": InboxV2.schema()},
-                MESH_MEDIA_TYPES[1]: {"schema": InboxV1.schema()},
+                MESH_MEDIA_TYPES[2]: {"schema": InboxV2.model_json_schema()},
+                MESH_MEDIA_TYPES[1]: {"schema": InboxV1.model_json_schema()},
             }
         },
         status.HTTP_403_FORBIDDEN: {"description": "Authentication failed", "content": None},
@@ -149,7 +149,7 @@ async def head_message(
         status.HTTP_200_OK: {
             "content": {
                 MESH_MEDIA_TYPES[2]: {
-                    "schema": RichInboxView.schema(),
+                    "schema": RichInboxView.model_json_schema(),
                 }
             },
         }
@@ -205,7 +205,7 @@ async def rich_inbox(
         },
         status.HTTP_206_PARTIAL_CONTENT: {
             "description": (
-                "Partial Content – Indicates that chunk has been downloaded "
+                "Partial Content - Indicates that chunk has been downloaded "
                 "successfully and that there are further chunks."
             ),
             "content": {"application/octet-stream": None},
@@ -244,7 +244,7 @@ async def retrieve_message(
         },
         status.HTTP_206_PARTIAL_CONTENT: {
             "description": (
-                "Partial Content – Indicates that chunk has been downloaded "
+                "Partial Content - Indicates that chunk has been downloaded "
                 "successfully and that there are further chunks."
             ),
             "content": {"application/octet-stream": None},

mesh_sandbox/routers/inbox_count.py

@@ -24,10 +24,10 @@ router = APIRouter(
         200: {
             "content": {
                 MESH_MEDIA_TYPES[2]: {
-                    "schema": InboxCountV2.schema(),
+                    "schema": InboxCountV2.model_json_schema(),
                 },
                 MESH_MEDIA_TYPES[1]: {
-                    "schema": InboxCountV1.schema(),
+                    "schema": InboxCountV1.model_json_schema(),
                 },
             }
         }

mesh_sandbox/routers/lookup.py

@@ -19,10 +19,10 @@ router = APIRouter(
         status.HTTP_200_OK: {
             "content": {
                 MESH_MEDIA_TYPES[2]: {
-                    "schema": MailboxLookupV2.schema(),
+                    "schema": MailboxLookupV2.model_json_schema(),
                 },
                 MESH_MEDIA_TYPES[1]: {
-                    "schema": EndpointLookupV1.schema(),
+                    "schema": EndpointLookupV1.model_json_schema(),
                 },
             }
         }
@@ -35,7 +35,6 @@ async def lookup_by_ods_code_and_workflow_id(
     accepts_api_version: int = Depends(get_accepts_api_version),
     handler: LookupHandler = Depends(LookupHandler),
 ):
-
     return await handler.lookup_by_ods_code_and_workflow(ods_code, workflow_id, accepts_api_version)
 
 
@@ -46,7 +45,7 @@ async def lookup_by_ods_code_and_workflow_id(
         status.HTTP_200_OK: {
             "content": {
                 MESH_MEDIA_TYPES[2]: {
-                    "schema": MailboxLookupV2.schema(),
+                    "schema": MailboxLookupV2.model_json_schema(),
                 }
             }
         }

mesh_sandbox/routers/outbox.py

@@ -40,10 +40,10 @@ router = APIRouter(
         status.HTTP_202_ACCEPTED: {
             "content": {
                 MESH_MEDIA_TYPES[2]: {
-                    "schema": SendMessageV2.schema(),
+                    "schema": SendMessageV2.model_json_schema(),
                 },
                 MESH_MEDIA_TYPES[1]: {
-                    "schema": SendMessageV1.schema(),
+                    "schema": SendMessageV1.model_json_schema(),
                 },
             }
         },
@@ -111,7 +111,7 @@ async def send_chunk(
         200: {
             "content": {
                 MESH_MEDIA_TYPES[2]: {
-                    "schema": RichOutboxView.schema(),
+                    "schema": RichOutboxView.model_json_schema(),
                 }
             }
         }

mesh_sandbox/routers/tracking.py

@@ -27,10 +27,10 @@ router = APIRouter(
         200: {
             "content": {
                 MESH_MEDIA_TYPES[2]: {
-                    "schema": TrackingV2.schema(),
+                    "schema": TrackingV2.model_json_schema(),
                 },
                 MESH_MEDIA_TYPES[1]: {
-                    "schema": TrackingV1.schema(),
+                    "schema": TrackingV1.model_json_schema(),
                 },
             }
         }

mesh_sandbox/store/base.py

@@ -8,7 +8,6 @@ from ..models.message import Message
 
 
 class Store(ABC):
-
     readonly = True
 
     def __init__(self, config: EnvConfig, logger: logging.Logger):