mms-client 1.4.0__tar.gz → 1.5.0__tar.gz

{mms_client-1.4.0 → mms_client-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mms-client
-Version: 1.4.0
+Version: 1.5.0
 Summary: API client for accessing the MMS
 Home-page: https://github.com/ElectroRoute-Japan/mms-client
 Author: Ryan Wood
@@ -33,7 +33,7 @@ Description-Content-Type: text/markdown
 [![Unit Tests Status](https://github.com/ElectroRoute-Japan/mms-client/actions/workflows/check.yml/badge.svg)](https://github.com/ElectroRoute-Japan/mms-client/actions)
 
 # Overview
-This repository contains a Python client that is capable of communication with the Market Management System (MMS), which handles requests related to Flex or Virtual Power Plant (VPP) trading. The underlying library is relies on SOAP communication, which is a pain to work with at the best of times. This particular SOAP API adds its own special layer of obnoxiousness, however. As such, it was deemed useful to have a client which would obfuscate most, if not all of this away from the user.
+This repository contains a Python client that is capable of communication with the Market Management System (MMS), which handles requests related to Flex or Virtual Power Plant (VPP) trading. The underlying library relies on SOAP communication, which is a pain to work with at the best of times. This particular SOAP API adds its own special layer of obnoxiousness, however. As such, it was deemed useful to have a client which would obfuscate most, if not all of this away from the user.
 
 # Communication
 The underlying API sends and receives XML documents. Each of these request or responses, which we will hereafter refer to as *outer* requests and responses, contains metadata about the request/response as well as three fields which are extremely important to successful communication with the API:
@@ -47,7 +47,9 @@ After the data has been converted and added to the outer request object, it is s
 This library relies on Pydantic 2 and the pydantic-xml library for serialization/deserialization. As such, any type in this library can be converted to not only XML, but to JSON as well. This is extremely useful if you're trying to build a pass-through API service or something similar.
 
 ## Client Types
-Clients cannot call any and all endpoints in this API, willy-nilly. Some endpoints are restricted to particular clients. At the moment, there are two clients: Balance Service Providers (BSPs) and Transmission Service Operators (TSOs). Most likely you're operating as a BSP, in which case you'll have access to all endpoints. However, it makes little sense for a TSO to be able to submit bids on their own power, so they are restricted to a read-only role in most cases.
+Clients cannot call any and all endpoints in this API, willy-nilly. Some endpoints are restricted to particular clients. At the moment, there are three clients: Balance Service Providers (BSPs), Market Operators (MOs), and Transmission Service Operators (TSOs). Most likely you're operating as a BSP or MO, in which case you'll have access to most or all endpoints. However, it makes little sense for a TSO to be able to submit bids on their own power, so they are restricted to a read-only role in most cases.
+
+Note that MOs and BSPs access the MMS service using the same endpoints, but have distinct permissions. As such, both client types are supported explicitly here.
 
 Should you request an endpoint which you are not authorized for, you will receive an `mms_client.utils.errors.AudienceError`.
 
@@ -184,15 +186,6 @@ If you're connecting as a market operator (MO), you can connect in admin mode:
 client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert, is_admin=True)
 ```
 
-## Log Settings
-The client also supports injection of a custom logger. The default logger is named "MMS Client".
-
-```python
-client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert, logger=my_logger)
-```
-
-The client currently logs a number of informational, debug and error messages. You can freely change the logging level yourself.
-
 ## Auditing XML Requests & Responses
 A common requirement for this sort of library is recording or saving the raw XML requests and responses for audit/logging purposes. This library supports this workflow through the `mms_client.utils.auditing.AuditPlugin` object. This object intercepts the XML request at the Zeep client level right before it is sent to the MMS and, similarly, intercepts the XML response immediately after it is received from the MMS. Before passing these objects on, without modifying them, it records the XML data as a byte string and passes it to two methods: `audit_request` and `audit_response`. These can be overridden by any object that inherits from this class, allowing the user to direct this data to whatever store they prefer to use for auditing or logging.
 

{mms_client-1.4.0 → mms_client-1.5.0}/README.md

@@ -1,7 +1,7 @@
 [![Unit Tests Status](https://github.com/ElectroRoute-Japan/mms-client/actions/workflows/check.yml/badge.svg)](https://github.com/ElectroRoute-Japan/mms-client/actions)
 
 # Overview
-This repository contains a Python client that is capable of communication with the Market Management System (MMS), which handles requests related to Flex or Virtual Power Plant (VPP) trading. The underlying library is relies on SOAP communication, which is a pain to work with at the best of times. This particular SOAP API adds its own special layer of obnoxiousness, however. As such, it was deemed useful to have a client which would obfuscate most, if not all of this away from the user.
+This repository contains a Python client that is capable of communication with the Market Management System (MMS), which handles requests related to Flex or Virtual Power Plant (VPP) trading. The underlying library relies on SOAP communication, which is a pain to work with at the best of times. This particular SOAP API adds its own special layer of obnoxiousness, however. As such, it was deemed useful to have a client which would obfuscate most, if not all of this away from the user.
 
 # Communication
 The underlying API sends and receives XML documents. Each of these request or responses, which we will hereafter refer to as *outer* requests and responses, contains metadata about the request/response as well as three fields which are extremely important to successful communication with the API:
@@ -15,7 +15,9 @@ After the data has been converted and added to the outer request object, it is s
 This library relies on Pydantic 2 and the pydantic-xml library for serialization/deserialization. As such, any type in this library can be converted to not only XML, but to JSON as well. This is extremely useful if you're trying to build a pass-through API service or something similar.
 
 ## Client Types
-Clients cannot call any and all endpoints in this API, willy-nilly. Some endpoints are restricted to particular clients. At the moment, there are two clients: Balance Service Providers (BSPs) and Transmission Service Operators (TSOs). Most likely you're operating as a BSP, in which case you'll have access to all endpoints. However, it makes little sense for a TSO to be able to submit bids on their own power, so they are restricted to a read-only role in most cases.
+Clients cannot call any and all endpoints in this API, willy-nilly. Some endpoints are restricted to particular clients. At the moment, there are three clients: Balance Service Providers (BSPs), Market Operators (MOs), and Transmission Service Operators (TSOs). Most likely you're operating as a BSP or MO, in which case you'll have access to most or all endpoints. However, it makes little sense for a TSO to be able to submit bids on their own power, so they are restricted to a read-only role in most cases.
+
+Note that MOs and BSPs access the MMS service using the same endpoints, but have distinct permissions. As such, both client types are supported explicitly here.
 
 Should you request an endpoint which you are not authorized for, you will receive an `mms_client.utils.errors.AudienceError`.
 
@@ -152,15 +154,6 @@ If you're connecting as a market operator (MO), you can connect in admin mode:
 client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert, is_admin=True)
 ```
 
-## Log Settings
-The client also supports injection of a custom logger. The default logger is named "MMS Client".
-
-```python
-client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert, logger=my_logger)
-```
-
-The client currently logs a number of informational, debug and error messages. You can freely change the logging level yourself.
-
 ## Auditing XML Requests & Responses
 A common requirement for this sort of library is recording or saving the raw XML requests and responses for audit/logging purposes. This library supports this workflow through the `mms_client.utils.auditing.AuditPlugin` object. This object intercepts the XML request at the Zeep client level right before it is sent to the MMS and, similarly, intercepts the XML response immediately after it is received from the MMS. Before passing these objects on, without modifying them, it records the XML data as a byte string and passes it to two methods: `audit_request` and `audit_response`. These can be overridden by any object that inherits from this class, allowing the user to direct this data to whatever store they prefer to use for auditing or logging.
 

{mms_client-1.4.0 → mms_client-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mms_client"
-version = "v1.4.0"
+version = "v1.5.0"
 description = "API client for accessing the MMS"
 authors = ["Ryan Wood <ryan.wood@electroroute.co.jp>"]
 readme = "README.md"

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/client.py

@@ -1,11 +1,16 @@
 """Contains the client layer for communicating with the MMS server."""
 
+from logging import getLogger
+
 from mms_client.services.base import BaseClient
 from mms_client.services.market import MarketClientMixin
 from mms_client.services.omi import OMIClientMixin
 from mms_client.services.registration import RegistrationClientMixin
 from mms_client.services.report import ReportClientMixin
 
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
+
 
 class MmsClient(BaseClient, MarketClientMixin, RegistrationClientMixin, ReportClientMixin, OMIClientMixin):
     """User client for the MMS server.

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/services/base.py

@@ -1,7 +1,6 @@
 """Contains the client layer for communicating with the MMS server."""
 
 from dataclasses import dataclass
-from logging import Logger
 from logging import getLogger
 from typing import Dict
 from typing import Generic
@@ -37,7 +36,7 @@ from mms_client.utils.web import Plugin
 from mms_client.utils.web import ZWrapper
 
 # Set the default logger for the MMS client
-default_logger = getLogger("MMS Client")
+logger = getLogger(__name__)
 
 
 @dataclass
@@ -59,7 +58,7 @@ class EndpointConfiguration(Generic[E, P]):
     name: str
 
     # The allowed client types for the endpoint
-    allowed_client: Optional[ClientType]
+    allowed_clients: Optional[List[ClientType]]
 
     # The service for the endpoint
     service: ServiceConfiguration
@@ -85,10 +84,6 @@ class ClientProto(Protocol):
     def user(self) -> str:
         """Return the user name of the person making the request."""
 
-    @property
-    def logger(self) -> Logger:
-        """Return the logger for the client."""
-
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -139,7 +134,7 @@ def mms_endpoint(
     name: str,
     service: ServiceConfiguration,
     request_type: RequestType,
-    allowed_client: Optional[ClientType] = None,
+    allowed_clients: Optional[List[ClientType]] = None,
     resp_envelope_type: Optional[Type[E]] = None,
     resp_data_type: Optional[Type[P]] = None,
 ):
@@ -150,22 +145,23 @@ def mms_endpoint(
     Decorated functions will only be responsible for creating the payload envelope to submit to the MMS server.
 
     Arguments:
-    name (str):                     The name of the endpoint.
-    service (ServiceConfiguration): The configuration for the service.
-    request_type (RequestType):     The type of request to submit to the MMS server.
-    allowed_client (ClientType):    The type of client that is allowed to access the endpoint. If this is not provided,
-                                    then any client type is allowed.
-    resp_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then the
-                                    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 will be assumed to have the same type as the request data.
+    name (str):                         The name of the endpoint.
+    service (ServiceConfiguration):     The configuration for the service.
+    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 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 will be assumed to have the same type as the request data.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_client, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
         def wrapper(self: ClientProto, *args, **kwargs) -> Optional[P]:
+            logger.info(f"{config.name}: Called with args: {args[1:]}...")
 
             # First, verify that the client type is allowed
             self.verify_audience(config)
@@ -177,6 +173,7 @@ def mms_endpoint(
             resp, _ = self.request_one(envelope, args[0], config)
 
             # Finally, extract the data from the response and return it
+            logger.info(f"{config.name}: Returning {type(resp.data).__name__} data.")
             return resp.data
 
         return wrapper
@@ -189,7 +186,7 @@ def mms_multi_endpoint(
     name: str,
     service: ServiceConfiguration,
     request_type: RequestType,
-    allowed_client: Optional[ClientType] = None,
+    allowed_clients: Optional[List[ClientType]] = None,
     resp_envelope_type: Optional[Type[E]] = None,
     resp_data_type: Optional[Type[P]] = None,
 ):
@@ -201,26 +198,27 @@ def mms_multi_endpoint(
     the MMS server.
 
     Arguments:
-    name (str):                     The name of the endpoint.
-    service (ServiceConfiguration): The configuration for the service.
-    request_type (RequestType):     The type of request to submit to the MMS server.
-    allowed_client (ClientType):    The type of client that is allowed to access the endpoint. If this is not provided,
-                                    then any client type is allowed.
-    resp_envelope_type (Type[E]):   The type of payload to expect in the response. If this is not provided, then the
-                                    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 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.
+    name (str):                         The name of the endpoint.
+    service (ServiceConfiguration):     The configuration for the service.
+    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 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 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.
     """
     # First, create the endpoint configuration from the given parameters
-    config = EndpointConfiguration(name, allowed_client, service, request_type, resp_envelope_type, resp_data_type)
+    config = EndpointConfiguration(name, allowed_clients, service, request_type, resp_envelope_type, resp_data_type)
 
     # Next, create a decorator that will add the endpoint configuration to the function
     def decorator(func):
         def wrapper(self: ClientProto, *args, **kwargs) -> List[P]:
-            self.logger.info(f"{config.name}: Called with args: {args[1:]}...")
+            logger.info(f"{config.name}: Called with args: {args[1:]}...")
 
             # First, verify that the client type is allowed
             self.verify_audience(config)
@@ -232,7 +230,7 @@ def mms_multi_endpoint(
             resp, _ = self.request_many(envelope, args[0], config)
 
             # Finally, extract the data from the response and return it
-            self.logger.info(f"{config.name}: Returning {len(resp.data)} item(s).")
+            logger.info(f"{config.name}: Returning {len(resp.data)} item(s).")
             return resp.data
 
         return wrapper
@@ -253,7 +251,6 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         user: str,
         client_type: ClientType,
         cert: Certificate,
-        logger: Optional[Logger] = None,
         plugins: Optional[List[Plugin]] = None,
         is_admin: bool = False,
         test: bool = False,
@@ -265,8 +262,6 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         user (str):                 The user name of the person making the request.
         client_type (ClientType):   The type of client to use for making requests to the MMS server.
         cert (Certificate):         The certificate to use for signing requests.
-        logger (Logger):            The logger to use for instrumentation. If this is not provided, then the default
-                                    logger will be used.
         plugins (List[Plugin]):     A list of plugins to add to the Zeep client. This can be useful for auditing or
                                     other purposes.
         is_admin (bool):            Whether the user is an admin (i.e. is a market operator).
@@ -283,8 +278,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         self._cert = cert
         self._signer = CryptoWrapper(cert)
 
-        # Now, set our logger to either the provided logger or the default logger
-        self._logger = logger or default_logger
+        # Now, set the plugins we'll inject into the Zeep client
         self._plugins = plugins or []
 
         # Finally, create a list of wrappers for the different interfaces
@@ -300,11 +294,6 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """Return the user name of the person making the request."""
         return self._user
 
-    @property
-    def logger(self) -> Logger:
-        """Return the logger for the client."""
-        return self._logger
-
     def verify_audience(self, config: EndpointConfiguration) -> None:
         """Verify that the client type is allowed.
 
@@ -317,12 +306,12 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         Raises:
         ValueError: If the client type is not allowed.
         """
-        self._logger.debug(
-            f"{config.name}: Verifying audience. Allowed client: "
-            f"{config.allowed_client.name if config.allowed_client else 'Any'}."
+        logger.debug(
+            f"{config.name}: Verifying audience. Allowed clients: "
+            f"{config.allowed_clients if config.allowed_clients else 'Any'}."
         )
-        if config.allowed_client and self._client_type != config.allowed_client:
-            raise AudienceError(config.name, config.allowed_client, self._client_type)
+        if config.allowed_clients and (self._client_type not in config.allowed_clients):
+            raise AudienceError(config.name, config.allowed_clients, self._client_type)
 
     def request_one(
         self,
@@ -340,7 +329,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         Returns:    The response from the MMS server.
         """
         # First, create the MMS request from the payload and data.
-        self._logger.debug(
+        logger.debug(
             f"{config.name}: Starting request. Envelope: {type(envelope).__name__}, Data: {type(payload).__name__}",
         )
         request = self._to_mms_request(config.request_type, config.service.serializer.serialize(envelope, payload))
@@ -359,7 +348,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         self._verify_response(data, config)
 
         # Return the response data and any attachments
-        self._logger.debug(
+        logger.debug(
             f"{config.name}: Returning response. Envelope: {envelope_type.__name__}, Data: {data_type.__name__}",
         )
         return data, attachments
@@ -382,7 +371,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         # First, create the MMS request from the payload and data.
         is_list = isinstance(payload, list)
         data_type = type(payload[0]) if is_list else type(payload)  # type: ignore[index]
-        self._logger.debug(
+        logger.debug(
             (
                 f"{config.name}: Starting multi-request. Envelope: {type(envelope).__name__}, "
                 f"Data: {data_type.__name__}"
@@ -413,7 +402,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         self._verify_multi_response(data, config)
 
         # Return the response data and any attachments
-        self._logger.debug(
+        logger.debug(
             f"{config.name}: Returning multi-response. Envelope: {envelope_type.__name__}, Data: {data_type.__name__}",
         )
         return data, attachments
@@ -446,7 +435,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         )
 
         # Embed the data and the attachments in the MMS request and return it
-        self._logger.debug(
+        logger.debug(
             f"Creating MMS request of type {req_type.name} to send {len(data)} bytes of data and "
             f"{len(attachment_data)} attachments."
         )
@@ -480,9 +469,9 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
 
         # Check the response status flags and log any warnings or errors
         if resp.warnings:
-            self._logger.warning(f"{config.name}: MMS response contained warnings.")
+            logger.warning(f"{config.name}: MMS response contained warnings.")
         if not resp.success:
-            self._logger.error(f"{config.name}: MMS response was unsuccessful.")
+            logger.error(f"{config.name}: MMS response was unsuccessful.")
 
     def _verify_response(self, resp: Response[E, P], config: EndpointConfiguration) -> None:
         """Verify that the given response is valid.
@@ -543,7 +532,7 @@ 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
-        self._logger.info(
+        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} "
@@ -565,11 +554,11 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """
         for path, messages in resp.messages.items():
             for info in messages.information:
-                self._logger.info(f"{config.name} - {path}: {info.code}")
+                logger.info(f"{config.name} - {path}: {info.code}")
             for warning in messages.warnings:
-                self._logger.warning(f"{config.name} - {path}: {warning.code}")
+                logger.warning(f"{config.name} - {path}: {warning.code}")
             for error in messages.errors:
-                self._logger.error(f"{config.name} - {path}: {error.code}")
+                logger.error(f"{config.name} - {path}: {error.code}")
 
     def _verify_response_common(
         self, config: EndpointConfiguration, payload_type: type, resp: ResponseCommon, index: Optional[int] = None
@@ -586,7 +575,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         Returns:    True to indicate that the response is valid, False otherwise.
         """
         # Log the status of the response validation
-        self._logger.info(
+        logger.info(
             f"{config.name}: {payload_type.__name__}{f'[{index}]' if index is not None else ''} was valid? "
             f"{resp.success} ({resp.validation.value})",
         )
@@ -601,12 +590,11 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         service (ServiceConfiguration):  The service for which to get the wrapper.
         """
         if service.interface not in self._wrappers:
-            self._logger.debug(f"Creating wrapper for {service.interface.name} interface.")
+            logger.debug(f"Creating wrapper for {service.interface.name} interface.")
             self._wrappers[service.interface] = ZWrapper(
                 self._client_type,
                 service.interface,
                 self._cert.to_adapter(),
-                self._logger,
                 self._plugins,
                 True,
                 self._test,

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/services/market.py

@@ -1,6 +1,7 @@
 """Contains the client layer for making market requests to the MMS server."""
 
 from datetime import date as Date
+from logging import getLogger
 from typing import List
 from typing import Optional
 
@@ -23,6 +24,9 @@ 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__)
+
 
 class MarketClientMixin:  # pylint: disable=unused-argument
     """Market client for the MMS server."""
@@ -30,7 +34,7 @@ class MarketClientMixin:  # pylint: disable=unused-argument
     # The configuration for the market service
     config = ServiceConfiguration(Interface.MI, Serializer(SchemaType.MARKET, "MarketData"))
 
-    @mms_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, ClientType.BSP)
+    @mms_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
     def put_offer(
         self: ClientProto, request: OfferData, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferData:
@@ -56,7 +60,7 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_multi_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, ClientType.BSP)
+    @mms_multi_endpoint("MarketSubmit_OfferData", config, RequestType.INFO, [ClientType.BSP])
     def put_offers(
         self: ClientProto, requests: List[OfferData], market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> List[OfferData]:
@@ -106,7 +110,7 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             days=days,
         )
 
-    @mms_endpoint("MarketCancel_OfferCancel", config, RequestType.INFO, ClientType.BSP)
+    @mms_endpoint("MarketCancel_OfferCancel", config, RequestType.INFO, [ClientType.BSP])
     def cancel_offer(
         self: ClientProto, request: OfferCancel, market_type: MarketType, days: int, date: Optional[Date] = None
     ) -> OfferCancel:

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/services/omi.py

@@ -1,10 +1,15 @@
 """Contains the client layer for making OMI requests to the MMS server."""
 
+from logging import getLogger
+
 from mms_client.services.base import ServiceConfiguration
 from mms_client.utils.serialization import SchemaType
 from mms_client.utils.serialization import Serializer
 from mms_client.utils.web import Interface
 
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
+
 
 class OMIClientMixin:  # pylint: disable=unused-argument
     """OMI client for the MMS server."""

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/services/registration.py

@@ -1,6 +1,7 @@
 """Contains the client layer for making registration requests to the MMS server."""
 
 from datetime import date as Date
+from logging import getLogger
 from typing import List
 from typing import Optional
 
@@ -20,6 +21,9 @@ 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__)
+
 
 class RegistrationClientMixin:  # pylint: disable=unused-argument
     """Registration client for the MMS server."""
@@ -27,7 +31,7 @@ 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("RegistrationSubmit_Resource", config, RequestType.REGISTRATION, [ClientType.BSP])
     def put_resource(self: ClientProto, request: ResourceData) -> ResourceData:
         """Submit a new resource to the MMS server.
 
@@ -50,6 +54,7 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
         "RegistrationQuery_Resource",
         config,
         RequestType.REGISTRATION,
+        allowed_clients=[ClientType.BSP, ClientType.TSO],
         resp_envelope_type=RegistrationSubmit,
         resp_data_type=ResourceData,
     )

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/services/report.py

@@ -1,10 +1,15 @@
 """Contains the client layer for making report requests to the MMS server."""
 
+from logging import getLogger
+
 from mms_client.services.base import ServiceConfiguration
 from mms_client.utils.serialization import SchemaType
 from mms_client.utils.serialization import Serializer
 from mms_client.utils.web import Interface
 
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
+
 
 class ReportClientMixin:  # pylint: disable=unused-argument
     """Report client for the MMS server."""

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/utils/auditing.py

@@ -2,11 +2,15 @@
 
 from abc import ABC
 from abc import abstractmethod
+from logging import getLogger
 
 from lxml.etree import _Element as Element
 from lxml.etree import tostring
 from zeep import Plugin
 
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
+
 
 class AuditPlugin(ABC, Plugin):
     """Base class for audit plugins."""

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/utils/errors.py

@@ -1,5 +1,6 @@
 """Contains error classes for the MMS client."""
 
+from logging import getLogger
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -10,11 +11,14 @@ from mms_client.types.base import Messages
 from mms_client.types.base import P
 from mms_client.utils.web import ClientType
 
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
+
 
 class AudienceError(ValueError):
     """Error raised when an invalid audience is provided."""
 
-    def __init__(self, method: str, allowed: ClientType, audience: ClientType):
+    def __init__(self, method: str, allowed: List[ClientType], audience: ClientType):
         """Initialize the error.
 
         Arguments:
@@ -22,8 +26,13 @@ class AudienceError(ValueError):
         allowed (str):  The allowed audience.
         audience (str): The invalid audience.
         """
+        inner = (
+            f"'{allowed[0].name}' is"
+            if len(allowed) == 1
+            else f"""{" or ".join([f"'{a.name}'" for a in allowed])} are"""
+        )
         self.method = method
-        self.message = f"{method}: Invalid client type, '{audience.name}' provided. Only '{allowed.name}' is supported."
+        self.message = f"{method}: Invalid client type, '{audience.name}' provided. Only {inner} supported."
         self.allowed = allowed
         self.audience = audience
         super().__init__(self.message)

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/utils/serialization.py

@@ -2,6 +2,7 @@
 
 from functools import lru_cache
 from io import BytesIO
+from logging import getLogger
 from pathlib import Path
 from typing import Dict
 from typing import List
@@ -32,6 +33,9 @@ from mms_client.types.base import SchemaType
 # Directory containing all our XML schemas
 XSD_DIR = Path(__file__).parent.parent / "schemas" / "xsd"
 
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
+
 
 class Serializer:
     """Contains methods for serializing and deserializing MMS data."""

{mms_client-1.4.0 → mms_client-1.5.0}/src/mms_client/utils/web.py

@@ -1,7 +1,7 @@
 """Contains the HTTP/web layer for communicating with the MMS server."""
 
-from enum import Enum
-from logging import Logger
+from enum import StrEnum
+from logging import getLogger
 from pathlib import Path
 from typing import List
 from typing import Optional
@@ -20,18 +20,23 @@ from zeep.xsd.valueobjects import CompoundValue
 from mms_client.types.transport import MmsRequest
 from mms_client.types.transport import MmsResponse
 
+# Set the default logger for the MMS client
+logger = getLogger(__name__)
 
-class ClientType(Enum):
+
+class ClientType(StrEnum):
     """Identifies the type of client to use.
 
-    The client can be either "bsp" (Balancing Service Provider) or "tso" (Transmission System Operator).
+    The client can be either "bsp" (Balancing Service Provider), "mo" (Market Operator), or "tso" (Transmission System
+    Operator).
     """
 
     BSP = "bsp"
+    MO = "mo"
     TSO = "tso"
 
 
-class Interface(Enum):
+class Interface(StrEnum):
     """Identifies the type of interface to use.
 
     The interface can be either "omi" (Other Market Initiator) or "mi" (Market Initiator).
@@ -76,32 +81,30 @@ class ServiceEndpoint:
             self._selected = self.main
 
 
-# Defines the service endpoints for the BSP and TSO clients for the OMI and MI web services, respectively.
-URLS = {
-    ClientType.BSP: {
-        Interface.OMI: ServiceEndpoint(
-            main="https://www5.tdgc.jp/axis2/services/OmiWebService",
-            backup="https://www6.tdgc.jp/axis2/services/OmiWebService",
-            test="https://www7.tdgc.jp/axis2/services/OmiWebService",
-        ),
-        Interface.MI: ServiceEndpoint(
-            main="https://www2.tdgc.jp/axis2/services/MiWebService",
-            backup="https://www3.tdgc.jp/axis2/services/MiWebService",
-            test="https://www4.tdgc.jp/axis2/services/MiWebService",
-        ),
-    },
-    ClientType.TSO: {
-        Interface.OMI: ServiceEndpoint(
-            main="https://maiwlba103v07.tdgc.jp/axis2/services/OmiWebService",
-            backup="https://mbiwlba103v07.tdgc.jp/axis2/services/OmiWebService",
-            test="https://mbiwlba103v08.tdgc.jp/axis2/services/OmiWebService",
-        ),
-        Interface.MI: ServiceEndpoint(
-            main="https://maiwlba103v03.tdgc.jp/axis2/services/MiWebService",
-            backup="https://mbiwlba103v03.tdgc.jp/axis2/services/MiWebService",
-            test="https://mbiwlba103v06.tdgc.jp/axis2/services/MiWebService",
-        ),
-    },
+# Defines the service endpoints for the BSP, MO and TSO clients for the OMI and MI web services, respectively.
+BSP_MO_URLS = {
+    Interface.OMI: ServiceEndpoint(
+        main="https://www5.tdgc.jp/axis2/services/OmiWebService",
+        backup="https://www6.tdgc.jp/axis2/services/OmiWebService",
+        test="https://www7.tdgc.jp/axis2/services/OmiWebService",
+    ),
+    Interface.MI: ServiceEndpoint(
+        main="https://www2.tdgc.jp/axis2/services/MiWebService",
+        backup="https://www3.tdgc.jp/axis2/services/MiWebService",
+        test="https://www4.tdgc.jp/axis2/services/MiWebService",
+    ),
+}
+TSO_URLS = {
+    Interface.OMI: ServiceEndpoint(
+        main="https://maiwlba103v07.tdgc.jp/axis2/services/OmiWebService",
+        backup="https://mbiwlba103v07.tdgc.jp/axis2/services/OmiWebService",
+        test="https://mbiwlba103v08.tdgc.jp/axis2/services/OmiWebService",
+    ),
+    Interface.MI: ServiceEndpoint(
+        main="https://maiwlba103v03.tdgc.jp/axis2/services/MiWebService",
+        backup="https://mbiwlba103v03.tdgc.jp/axis2/services/MiWebService",
+        test="https://mbiwlba103v06.tdgc.jp/axis2/services/MiWebService",
+    ),
 }
 
 
@@ -134,7 +137,6 @@ class ZWrapper:
         client: ClientType,
         interface: Interface,
         adapter: Pkcs12Adapter,
-        logger: Logger,
         plugins: Optional[List[Plugin]] = None,
         cache: bool = True,
         test: bool = False,
@@ -150,7 +152,6 @@ class ZWrapper:
                                     as the service and port to use.
         adapter (Pkcs12Adapter):    The PKCS12 adapter containing the certificate and private key to use for
                                     authenticating with the MMS server.
-        logger (Logger):            The logger to use for instrumentation.
         plugins (List[Plugin]):     A list of Zeep plugins to use with the client. This is useful for adding additional
                                     functionality to the client, such as auditing or logging.
         cache (bool):               If True, use a cache for the Zeep client. This is useful for avoiding repeated
@@ -158,8 +159,12 @@ class ZWrapper:
         test (bool):                If True, use the test service endpoint. This is useful for testing the client.
         """
         # First, we'll check that the client is valid. If it's not, we'll raise a ValueError.
-        if client not in URLS:
-            raise ValueError(f"Invalid client, '{client}'. Only 'bsp' and 'tso' are supported.")
+        if client in [ClientType.BSP, ClientType.MO]:
+            urls = BSP_MO_URLS
+        elif client == ClientType.TSO:
+            urls = TSO_URLS
+        else:
+            raise ValueError(f"Invalid client, '{client}'. Only 'bsp', 'mo', and 'tso' are supported.")
 
         # We need to determine the service port and location of the WSDL file based on the given interface. If the
         # interface is neither "omi" nor "mi", we raise a ValueError.
@@ -172,7 +177,7 @@ class ZWrapper:
             raise ValueError(f"Invalid interface, '{self._interface}'. Only 'mi' and 'omi' are supported.")
 
         # Next, we need to select the correct service endpoint based on the given client and interface.
-        self._endpoint = URLS[client][self._interface]
+        self._endpoint = urls[self._interface]
         self._endpoint.select(test=test)
 
         # Now, we need to create a new session and mount the PKCS12 adapter to it. This is necessary for
@@ -186,7 +191,6 @@ class ZWrapper:
 
         # Finally, we create the Zeep client with the given WSDL file location, session, and cache settings and then,
         # from that client, we create the SOAP service with the given service binding and selected endpoint.
-        self._logger = logger
         self._client = Client(
             wsdl=str(location.resolve()),
             transport=Transport(cache=SqliteCache() if cache else None, session=sess),
@@ -194,11 +198,11 @@ class ZWrapper:
         )
         self._create_service()
 
-    @on_exception(expo, TransportError, max_tries=3, giveup=fatal_code)  # type: ignore[arg-type]
+    @on_exception(expo, TransportError, max_tries=3, giveup=fatal_code, logger=logger)  # type: ignore[arg-type]
     def submit(self, req: MmsRequest) -> MmsResponse:
         """Submit the given request to the MMS server and return the response."""
         try:
-            self._logger.debug(f"Submitting MMS request request to {self._interface.name} service")
+            logger.debug(f"Submitting MMS request request to {self._interface.name} service")
 
             # Submit the request to the MMS server and retrieve the response
             resp: CompoundValue = self._service["submitAttachment"](**req.to_arguments())
@@ -208,12 +212,12 @@ class ZWrapper:
         except TransportError as e:
             # If we got a server fault error, then we'll switch to the backup endpoint. In any case, we'll raise the
             # exception so that our back-off can handle it or pass the exception up the stack.
-            self._logger.error(
+            logger.error(
                 f"MMS request to {self._interface.name} service failed with status code: {e.status_code}",
                 exc_info=e,
             )
             if e.status_code >= 500:
-                self._logger.warning(f"MMS server error, switching to backup endpoint: {self._endpoint.backup}")
+                logger.warning(f"MMS server error, switching to backup endpoint: {self._endpoint.backup}")
                 self._endpoint.select(error=True)
                 self._create_service()
             raise
@@ -223,5 +227,5 @@ class ZWrapper:
 
         This is useful for switching between the main and backup endpoints in case of an error.
         """
-        self._logger.debug(f"Creating new {self._interface.name} service with endpoint: {self._endpoint.selected}")
+        logger.debug(f"Creating new {self._interface.name} service with endpoint: {self._endpoint.selected}")
         self._service = self._client.create_service(SERVICE_BINDINGS[self._interface], self._endpoint.selected)