mms-client 1.7.0__tar.gz → 1.8.0__tar.gz

{mms_client-1.7.0 → mms_client-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mms-client
-Version: 1.7.0
+Version: 1.8.0
 Summary: API client for accessing the MMS
 Home-page: https://github.com/ElectroRoute-Japan/mms-client
 Author: Ryan Wood
@@ -24,6 +24,7 @@ Requires-Dist: lxml (>=5.1.0,<6.0.0)
 Requires-Dist: pendulum (>=3.0.0,<4.0.0)
 Requires-Dist: pycryptodomex (>=3.20.0,<4.0.0)
 Requires-Dist: pydantic (>=2.6.3,<3.0.0)
+Requires-Dist: pydantic-extra-types (>=2.7.0,<3.0.0)
 Requires-Dist: pydantic-xml (>=2.9.0,<3.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: requests-pkcs12 (>=1.24,<2.0)
@@ -220,6 +221,10 @@ This client is not complete. Currently, it supports the following endpoints:
 - MarketQuery_AwardResultsQuery
 - RegistrationSubmit_Resource
 - RegistrationQuery_Resource
+- ReportCreateRequest
+- ReportListRequest
+- ReportDownloadRequestTrnID
+- BSP_ResourceList
 
 We can add support for additional endpoints as time goes on, and independent contribution is, of course, welcome. However, support for attachments is currently limited because none of the endpoints we support currently require them. We have implemented attachment support up to the client level, but we haven't developed an architecture for submitting them through an endpoint yet.
 

{mms_client-1.7.0 → mms_client-1.8.0}/README.md

@@ -187,6 +187,10 @@ This client is not complete. Currently, it supports the following endpoints:
 - MarketQuery_AwardResultsQuery
 - RegistrationSubmit_Resource
 - RegistrationQuery_Resource
+- ReportCreateRequest
+- ReportListRequest
+- ReportDownloadRequestTrnID
+- BSP_ResourceList
 
 We can add support for additional endpoints as time goes on, and independent contribution is, of course, welcome. However, support for attachments is currently limited because none of the endpoints we support currently require them. We have implemented attachment support up to the client level, but we haven't developed an architecture for submitting them through an endpoint yet.
 

{mms_client-1.7.0 → mms_client-1.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mms_client"
-version = "v1.7.0"
+version = "v1.8.0"
 description = "API client for accessing the MMS"
 authors = ["Ryan Wood <ryan.wood@electroroute.co.jp>"]
 readme = "README.md"
@@ -33,6 +33,7 @@ pydantic-xml = "^2.9.0"
 lxml = "^5.1.0"
 backoff = "^2.2.1"
 pycryptodomex = "^3.20.0"
+pydantic-extra-types = "^2.7.0"
 
 [tool.poetry.group.dev.dependencies]
 black = "^24.2.0"
@@ -49,7 +50,6 @@ pytest-mock = "^3.12.0"
 mock = "^5.1.0"
 lxml-stubs = "^0.5.1"
 pyfakefs = "^5.3.5"
-pydantic-extra-types = "^2.6.0"
 responses = "^0.25.0"
 types-urllib3 = "^1.26.25.14"
 

{mms_client-1.7.0 → mms_client-1.8.0}/src/mms_client/services/base.py

@@ -53,26 +53,33 @@ class ServiceConfiguration:
 
 
 @dataclass
-class EndpointConfiguration(Generic[E, P]):
+class EndpointConfiguration(Generic[E, P]):  # pylint: disable=too-many-instance-attributes
     """Configuration for an endpoint on the MMS server."""
 
     # The name of the endpoint
     name: str
 
-    # The allowed client types for the endpoint
-    allowed_clients: Optional[List[ClientType]]
-
     # The service for the endpoint
     service: ServiceConfiguration
 
     # The type of request to submit to the MMS server
     request_type: RequestType
 
+    # The allowed client types for the endpoint
+    allowed_clients: Optional[List[ClientType]] = None
+
     # The type of payload to expect in the response
-    response_envelope_type: Optional[Type[E]]
+    response_envelope_type: Optional[Type[E]] = None
 
     # The type of data to expect in the response
-    response_data_type: Optional[Type[P]]
+    response_data_type: Optional[Type[P]] = None
+
+    # Whether the endpoint is for a report request
+    for_report: bool = False
+
+    # An optional serializer used to deserialize the response data for the service. This is only used for report
+    # requests because they have a separate XSD file for responses.
+    serializer: Optional[Serializer] = None
 
 
 class ClientProto(Protocol):
@@ -86,6 +93,10 @@ class ClientProto(Protocol):
     def user(self) -> str:
         """Return the user name of the person making the request."""
 
+    @property
+    def client_type(self) -> ClientType:
+        """Return the type of client to use for making requests to the MMS server."""
+
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -132,14 +143,7 @@ class ClientProto(Protocol):
         """
 
 
-def mms_endpoint(
-    name: str,
-    service: ServiceConfiguration,
-    request_type: RequestType,
-    allowed_clients: Optional[List[ClientType]] = None,
-    resp_envelope_type: Optional[Type[E]] = None,
-    resp_data_type: Optional[Type[P]] = None,
-):
+def mms_endpoint(**kwargs):
     """Create a decorator for an MMS endpoint.
 
     This decorator is used to mark a method as an MMS endpoint. It will add the endpoint configuration to the function
@@ -152,13 +156,16 @@ def mms_endpoint(
     request_type (RequestType):         The type of request to submit to the MMS server.
     allowed_clients (List[ClientType]): The types of clients that are allowed to access the endpoint. If this is not
                                         provided, then any client will be allowed.
-    resp_envelope_type (Type[E]):       The type of payload to expect in the response. If this is not provided, then the
+    response_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then the
                                         response envelope will be assumed to have the same type as the request envelope.
-    resp_data_type (Type[P]):           The type of data to expect in the response. If this is not provided, then the
+    response_data_type (Type[P]):       The type of data to expect in the response. If this is not provided, then the
                                         response data will be assumed to have the same type as the request data.
+    for_report (bool):                  If True, the endpoint is for a report request.
+    serializer (Serializer):            The serializer to use for responses from the endpoint. Overrides the default
+                                        serializer for the service.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(**kwargs)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
@@ -169,10 +176,18 @@ def mms_endpoint(
             self.verify_audience(config)
 
             # Next, call the wrapped function to get the envelope
-            envelope = func(self, *args, **kwargs)
+            result = func(self, *args, **kwargs)
+            if isinstance(result, tuple):
+                envelope, callback = result
+            else:
+                envelope, callback = result, None
 
             # Now, submit the request to the MMS server and get the response
-            resp, _ = self.request_one(envelope, args[0], config)
+            resp, attachments = self.request_one(envelope, args[0], config)
+
+            # Call the callback function if it was provided
+            if callback:
+                callback(resp, attachments)
 
             # Finally, extract the data from the response and return it
             logger.info(f"{config.name}: Returning {type(resp.data).__name__} data.")
@@ -184,14 +199,7 @@ def mms_endpoint(
     return decorator
 
 
-def mms_multi_endpoint(
-    name: str,
-    service: ServiceConfiguration,
-    request_type: RequestType,
-    allowed_clients: Optional[List[ClientType]] = None,
-    resp_envelope_type: Optional[Type[E]] = None,
-    resp_data_type: Optional[Type[P]] = None,
-):
+def mms_multi_endpoint(**kwargs):
     """Create a decorator for an MMS multi-response endpoint.
 
     This decorator is used to mark a method as an MMS multi-response endpoint. It will add the endpoint configuration to
@@ -205,17 +213,20 @@ def mms_multi_endpoint(
     request_type (RequestType):         The type of request to submit to the MMS server.
     allowed_clients (List[ClientType]): The types of clients that are allowed to access the endpoint. If this is not
                                         provided, then any client will be allowed.
-    resp_envelope_type (Type[E]):       The type of payload to expect in the response. If this is not provided, then
+    response_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then
                                         the response envelope will be assumed to have the same type as the request
                                         envelope.
-    resp_data_type (Type[P]):           The type of data to expect in the response. If this is not provided, then the
+    response_data_type (Type[P]):       The type of data to expect in the response. If this is not provided, then the
                                         response data will be assumed to have the same type as the request data. Note,
                                         that this is not intended to account for the expected sequence type of the
                                         response data. That is already handled in the wrapped function, so this should
                                         only be set if the inner data type being returned differs from what was sent.
+    for_report (bool):                  If True, the endpoint is for a report request.
+    serializer (Serializer):            The serializer to use for responses from the endpoint. Overrides the default
+                                        serializer for the service.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(**kwargs)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
@@ -226,10 +237,18 @@ def mms_multi_endpoint(
             self.verify_audience(config)
 
             # Next, call the wrapped function to get the envelope
-            envelope = func(self, *args, **kwargs)
+            result = func(self, *args, **kwargs)
+            if isinstance(result, tuple):
+                envelope, callback = result  # pragma: no cover
+            else:
+                envelope, callback = result, None
 
             # Now, submit the request to the MMS server and get the response
-            resp, _ = self.request_many(envelope, args[0], config)
+            resp, attachments = self.request_many(envelope, args[0], config)
+
+            # Call the callback function if it was provided
+            if callback:
+                callback(resp, attachments)  # pragma: no cover
 
             # Finally, extract the data from the response and return it
             logger.info(f"{config.name}: Returning {len(resp.data)} item(s).")
@@ -299,6 +318,11 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """Return the user name of the person making the request."""
         return self._user
 
+    @property
+    def client_type(self) -> ClientType:
+        """Return the type of client to use for making requests to the MMS server."""
+        return self._client_type
+
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -341,7 +365,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             f"{config.name}: Starting request. Envelope: {type(envelope).__name__}, Data: {type(payload).__name__}",
         )
         request = self._to_mms_request(
-            wrapper, config.request_type, config.service.serializer.serialize(envelope, payload)
+            wrapper, config.request_type, config.service.serializer.serialize(envelope, payload, config.for_report)
         )
 
         # Next, submit the request to the MMS server and get and verify the response.
@@ -354,7 +378,8 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         # Finally, deserialize and verify the response
         envelope_type = config.response_envelope_type or type(envelope)
         data_type = config.response_data_type or type(payload)
-        data: Response[E, P] = config.service.serializer.deserialize(resp.payload, envelope_type, data_type)
+        deserializer = config.serializer or config.service.serializer
+        data: Response[E, P] = deserializer.deserialize(resp.payload, envelope_type, data_type, config.for_report)
         self._verify_response(data, config)
 
         # Return the response data and any attachments
@@ -391,9 +416,11 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             ),
         )
         serialized = (
-            config.service.serializer.serialize_multi(envelope, payload, data_type)  # type: ignore[arg-type]
+            config.service.serializer.serialize_multi(
+                envelope, payload, data_type, config.for_report  # type: ignore[arg-type]
+            )
             if is_list
-            else config.service.serializer.serialize(envelope, payload)  # type: ignore[type-var]
+            else config.service.serializer.serialize(envelope, payload, config.for_report)  # type: ignore[type-var]
         )
         request = self._to_mms_request(wrapper, config.request_type, serialized)
 
@@ -407,10 +434,12 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         # Finally, deserialize and verify the response
         envelope_type = config.response_envelope_type or type(envelope)
         data_type = config.response_data_type or data_type
-        data: MultiResponse[E, P] = config.service.serializer.deserialize_multi(
+        deserializer = config.serializer or config.service.serializer
+        data: MultiResponse[E, P] = deserializer.deserialize_multi(
             resp.payload,
             envelope_type,
             data_type,  # type: ignore[arg-type]
+            config.for_report,
         )
         self._verify_multi_response(data, config)
 
@@ -574,18 +603,18 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         Returns:    True to indicate that the response is valid, False otherwise.
         """
         # Log the request's processing statistics
-        logger.info(
-            f"{config.name} ({resp.statistics.timestamp_xml}): Recieved {resp.statistics.received}, "
-            f"Valid: {resp.statistics.valid}, Invalid: {resp.statistics.invalid}, "
-            f"Successful: {resp.statistics.successful}, Unsuccessful: {resp.statistics.unsuccessful} "
-            f"in {resp.statistics.time_ms}ms"
-        )
+        if resp.statistics is not None:
+            logger.info(
+                f"{config.name} ({resp.statistics.timestamp_xml}): Recieved {resp.statistics.received}, "
+                f"Valid: {resp.statistics.valid}, Invalid: {resp.statistics.invalid}, "
+                f"Successful: {resp.statistics.successful}, Unsuccessful: {resp.statistics.unsuccessful} "
+                f"in {resp.statistics.time_ms}ms"
+            )
 
         # Check if the response is invalid and if the envelope had any validation issues. If not, then we have a
         # valid base response so return True. Otherwise, return False.
-        return resp.statistics.invalid == 0 and self._verify_response_common(
-            config, type(resp.envelope), resp.envelope_validation
-        )
+        is_invalid = resp.statistics is not None and resp.statistics.invalid
+        return not is_invalid and self._verify_response_common(config, type(resp.envelope), resp.envelope_validation)
 
     def _verify_messages(self, config: EndpointConfiguration, resp: BaseResponse[E]) -> None:
         """Verify the messages in the given response.
@@ -595,12 +624,12 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         resp (BaseResponse):            The response to verify.
         """
         for path, messages in resp.messages.items():
-            for info in messages.information:
-                logger.info(f"{config.name} - {path}: {info.code}")
-            for warning in messages.warnings:
-                logger.warning(f"{config.name} - {path}: {warning.code}")
-            for error in messages.errors:
-                logger.error(f"{config.name} - {path}: {error.code}")
+            for info in messages.information:  # type: ignore[union-attr]
+                logger.info(f"{config.name} - {path}: {info}")
+            for warning in messages.warnings:  # type: ignore[union-attr]
+                logger.warning(f"{config.name} - {path}: {warning}")
+            for error in messages.errors:  # type: ignore[union-attr]
+                logger.error(f"{config.name} - {path}: {error}")
 
     def _verify_response_common(
         self, config: EndpointConfiguration, payload_type: type, resp: ResponseCommon, index: Optional[int] = None

{mms_client-1.7.0 → mms_client-1.8.0}/src/mms_client/services/market.py

@@ -37,11 +37,11 @@ class MarketClientMixin:  # pylint: disable=unused-argument
     config = ServiceConfiguration(Interface.MI, Serializer(SchemaType.MARKET, "MarketData"))
 
     @mms_endpoint(
-        "MarketQuery_ReserveRequirementQuery",
-        config,
-        RequestType.INFO,
-        resp_envelope_type=MarketSubmit,
-        resp_data_type=ReserveRequirement,
+        name="MarketQuery_ReserveRequirementQuery",
+        service=config,
+        request_type=RequestType.INFO,
+        response_envelope_type=MarketSubmit,
+        response_data_type=ReserveRequirement,
     )
     def query_reserve_requirements(
         self: ClientProto, request: ReserveRequirementQuery, days: int, date: Optional[Date] = None
@@ -66,7 +66,9 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
+    @mms_endpoint(
+        name="MarketSubmit_OfferData", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
     def put_offer(
         self: ClientProto, request: OfferData, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferData:
@@ -92,7 +94,9 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_multi_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
+    @mms_multi_endpoint(
+        name="MarketSubmit_OfferData", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
     def put_offers(
         self: ClientProto, requests: List[OfferData], market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> List[OfferData]:
@@ -119,7 +123,11 @@ class MarketClientMixin:  # pylint: disable=unused-argument
         )
 
     @mms_multi_endpoint(
-        "MarketQuery_OfferQuery", config, RequestType.INFO, resp_envelope_type=MarketSubmit, resp_data_type=OfferData
+        name="MarketQuery_OfferQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_envelope_type=MarketSubmit,
+        response_data_type=OfferData,
     )
     def query_offers(self: ClientProto, request: OfferQuery, days: int, date: Optional[Date] = None) -> List[OfferData]:
         """Query the MMS server for offers.
@@ -142,7 +150,12 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketCancel_OfferCancel", config, RequestType.INFO, [ClientType.BSP])
+    @mms_endpoint(
+        name="MarketCancel_OfferCancel",
+        service=config,
+        request_type=RequestType.MARKET,
+        allowed_clients=[ClientType.BSP],
+    )
     def cancel_offer(
         self: ClientProto, request: OfferCancel, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferCancel:
@@ -168,7 +181,12 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketQuery_AwardResultsQuery", config, RequestType.MARKET, resp_data_type=AwardResponse)
+    @mms_endpoint(
+        name="MarketQuery_AwardResultsQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_data_type=AwardResponse,
+    )
     def query_awards(self: ClientProto, request: AwardQuery, days: int, date: Optional[Date] = None) -> AwardResponse:
         """Query the MMS server for award results.
 

{mms_client-1.7.0 → mms_client-1.8.0}/src/mms_client/services/registration.py

@@ -10,7 +10,6 @@ from mms_client.services.base import ServiceConfiguration
 from mms_client.services.base import mms_endpoint
 from mms_client.services.base import mms_multi_endpoint
 from mms_client.types.registration import QueryAction
-from mms_client.types.registration import QueryType
 from mms_client.types.registration import RegistrationQuery
 from mms_client.types.registration import RegistrationSubmit
 from mms_client.types.resource import ResourceData
@@ -31,7 +30,12 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
     # The configuration for the registration service
     config = ServiceConfiguration(Interface.MI, Serializer(SchemaType.REGISTRATION, "RegistrationData"))
 
-    @mms_endpoint("RegistrationSubmit_Resource", config, RequestType.REGISTRATION, [ClientType.BSP])
+    @mms_endpoint(
+        name="RegistrationSubmit_Resource",
+        service=config,
+        request_type=RequestType.REGISTRATION,
+        allowed_clients=[ClientType.BSP],
+    )
     def put_resource(self: ClientProto, request: ResourceData) -> ResourceData:
         """Submit a new resource to the MMS server.
 
@@ -51,12 +55,12 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
         return RegistrationSubmit()  # type: ignore[return-value]
 
     @mms_multi_endpoint(
-        "RegistrationQuery_Resource",
-        config,
-        RequestType.REGISTRATION,
+        name="RegistrationQuery_Resource",
+        service=config,
+        request_type=RequestType.REGISTRATION,
         allowed_clients=[ClientType.BSP, ClientType.TSO],
-        resp_envelope_type=RegistrationSubmit,
-        resp_data_type=ResourceData,
+        response_envelope_type=RegistrationSubmit,
+        response_data_type=ResourceData,
     )
     def query_resources(
         self: ClientProto, request: ResourceQuery, action: QueryAction, date: Optional[Date] = None
@@ -79,6 +83,5 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
         # Inject our parameters into the query and return it.
         return RegistrationQuery(  # type: ignore[return-value]
             action=action,
-            query_type=QueryType.TRADE,
-            date=date or Date.today(),
+            date=date,
         )

mms_client-1.8.0/src/mms_client/services/report.py

@@ -0,0 +1,161 @@
+"""Contains the client layer for making report requests to the MMS server."""
+
+from logging import getLogger
+from typing import Dict
+from typing import List
+from typing import Type
+from typing import TypeVar
+
+from mms_client.services.base import ClientProto
+from mms_client.services.base import ServiceConfiguration
+from mms_client.services.base import mms_endpoint
+from mms_client.services.base import mms_multi_endpoint
+from mms_client.types.base import Response
+from mms_client.types.report import ApplicationType
+from mms_client.types.report import BSPResourceListItem
+from mms_client.types.report import ListReportRequest
+from mms_client.types.report import ListReportResponse
+from mms_client.types.report import NewReportRequest
+from mms_client.types.report import NewReportResponse
+from mms_client.types.report import OutboundData
+from mms_client.types.report import ReportBase
+from mms_client.types.report import ReportDownloadRequestTrnID
+from mms_client.types.report import ReportLineBase
+from mms_client.types.transport import RequestType
+from mms_client.utils.serialization import SchemaType
+from mms_client.utils.serialization import Serializer
+from mms_client.utils.web import ClientType
+from mms_client.utils.web import Interface
+
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
+
+
+# The type variable we'll use to represent report line items
+R = TypeVar("R", bound=ReportLineBase)
+
+
+def attach_transaction_id(
+    resp: Response[ReportBase, NewReportResponse],
+    attachments: Dict[str, bytes],  # pylint: disable=unused-argument
+) -> None:
+    """Attach the transaction ID to the response.
+
+    Arguments:
+    resp (Response[ReportBase, NewReportResponse]): The MMS response.
+    attachments (Dict[str, bytes]):                 Attachements to the response.
+    """
+    if resp.data and resp.statistics is not None:
+        resp.data.transaction_id = resp.statistics.transaction_id or ""
+
+
+def report_getter_factory(config: ServiceConfiguration, resp_data_type: Type[R], allowed_clients: List[ClientType]):
+    """Create a function for getting a report with a transaction ID.
+
+    Arguments:
+    config (ServiceConfiguration):      The configuration for the report service.
+    resp_data_type (Type[R]):           The type of report data to return.
+    allowed_clients (List[ClientType]): The allowed client types for the report service.
+
+    Returns:    A function for getting a report with a transaction ID.
+    """
+
+    @mms_multi_endpoint(
+        name="ReportDownloadRequestTrnID",
+        service=config,
+        request_type=RequestType.REPORT,
+        allowed_clients=allowed_clients,
+        response_envelope_type=OutboundData,
+        response_data_type=resp_data_type,
+        serializer=Serializer(SchemaType.REPORT_RESPONSE, "OutboundData"),
+        for_report=True,
+    )
+    def get_report_with_transaction_id(
+        self: ClientProto,
+        request: ReportDownloadRequestTrnID,  # pylint: disable=unused-argument
+    ) -> List[resp_data_type]:  # type: ignore[valid-type]
+        """Request download of a report with a transaction ID.
+
+        This endpoint is accessible to any client, but may be rejected depending on the type of report being requested.
+
+        Arguments:
+        self (ClientProto):                     The client to use for making the request.
+        request (ReportDownloadRequestTrnID):   The request to download the report.
+
+        Returns:    The request to download the report.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return ReportBase(  # type: ignore[return-value]
+            application_type=ApplicationType.MARKET_REPORT,
+            participant=self.participant,
+        )
+
+    return get_report_with_transaction_id
+
+
+class ReportClientMixin:  # pylint: disable=unused-argument
+    """Report client for the MMS server."""
+
+    # The configuration for the report service
+    config = ServiceConfiguration(
+        Interface.MI,
+        Serializer(SchemaType.REPORT, "MarketReport"),
+    )
+
+    @mms_endpoint(
+        name="ReportCreateRequest",
+        service=config,
+        request_type=RequestType.REPORT,
+        response_envelope_type=ReportBase,
+        response_data_type=NewReportResponse,
+        for_report=True,
+    )
+    def create_report(self: ClientProto, request: NewReportRequest) -> NewReportResponse:
+        """Request creation of a new report.
+
+        This endpoint is only accessible to BSPs.
+
+        Arguments:
+        request (NewReportRequest): The request to create the report.
+
+        Returns:    The request to create the report.
+        """
+        # If the client type is BSP, then we can't set the BSP name
+        if self.client_type == ClientType.BSP:
+            request.bsp_name = None
+
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        # Return the envelope and the callback function
+        return (
+            ReportBase(  # type: ignore[return-value]
+                application_type=ApplicationType.MARKET_REPORT,
+                participant=self.participant,
+            ),
+            attach_transaction_id,
+        )
+
+    @mms_endpoint(
+        name="ReportListRequest",
+        service=config,
+        request_type=RequestType.REPORT,
+        response_envelope_type=ReportBase,
+        response_data_type=ListReportResponse,
+        for_report=True,
+    )
+    def list_reports(self: ClientProto, request: ListReportRequest) -> ListReportResponse:
+        """Query the existing reports.
+
+        Arguments:
+        request (ListReportRequest): The request to query the reports.
+
+        Returns:    A list of reports that match the query.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        # Return the envelope and the callback function
+        return ReportBase(  # type: ignore[return-value]
+            application_type=ApplicationType.MARKET_REPORT,
+            participant=self.participant,
+        )
+
+    # Define the individual report getter functions here
+    list_bsp_resources = report_getter_factory(config, BSPResourceListItem, [ClientType.BSP])