mms-client 1.6.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

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/services/report.py

@@ -1,18 +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"))
+    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])

mms_client/types/base.py

@@ -8,10 +8,12 @@ from typing import List
 from typing import Optional
 from typing import TypeVar
 
+from lxml.etree import _Element as Element
 from pydantic import PrivateAttr
 from pydantic_extra_types.pendulum_dt import DateTime
 from pydantic_xml import BaseXmlModel
 from pydantic_xml import attr
+from pydantic_xml import computed_element
 from pydantic_xml import element
 
 from mms_client.types.fields import transaction_id
@@ -34,17 +36,48 @@ class Message(BaseXmlModel):
     code: str = attr(default="", name="Code", min_length=2, max_length=50, pattern=r"^[a-zA-Z_0-9\-]*$")
 
 
-class Messages(BaseXmlModel, search_mode="unordered"):
+class Messages(BaseXmlModel, search_mode="unordered", arbitrary_types_allowed=True):
     """Represents a collection of messages returned with a payload."""
 
-    # A list of information messages returned with a payload
-    information: List[Message] = element(default=[], tag="Information", nillable=True)
+    # The raw information messages returned with a payload
+    information_raw: List[Element] = element(default=[], tag="Information", nillable=True, exclude=True)
 
-    # A list of warning messages returned with a payload
-    warnings: List[Message] = element(default=[], tag="Warning", nillable=True)
+    # The raw warning messages returned with a payload
+    warnings_raw: List[Element] = element(default=[], tag="Warning", nillable=True, exclude=True)
 
-    # A list of error messages returned with a payload
-    errors: List[Message] = element(default=[], tag="Error", nillable=True)
+    # The raw error messages returned with a payload
+    errors_raw: List[Element] = element(default=[], tag="Error", nillable=True, exclude=True)
+
+    @computed_element
+    def information(self) -> List[str]:
+        """Return the information messages."""
+        return self._parse_messages(self.information_raw)
+
+    @computed_element
+    def warnings(self) -> List[str]:
+        """Return the warning messages."""
+        return self._parse_messages(self.warnings_raw)
+
+    @computed_element
+    def errors(self) -> List[str]:
+        """Return the error messages."""
+        return self._parse_messages(self.errors_raw)
+
+    def _parse_messages(self, raw: List[Element]) -> List[str]:
+        """Parse the messages from the XML tree.
+
+        Arguments:
+        raw (List[Element]): The raw XML tree to parse.
+
+        Returns:    A list of message codes.
+        """
+        messages = []
+        for item in raw:
+            if message := item.attrib.get("Code"):
+                messages.append(message)
+            else:
+                messages.append(item.text or "")
+        return messages
 
 
 class ProcessingStatistics(BaseXmlModel):
@@ -87,7 +120,16 @@ class ResponseCommon(BaseXmlModel, search_mode="unordered"):
 
     # The status of the validation check done on the element. This field is not required for requests, and will be
     # populated in responses. For responses, the default value is "NOT_DONE".
-    validation: ValidationStatus = attr(default=ValidationStatus.NOT_DONE, name="Validation")
+    base_validation: Optional[ValidationStatus] = attr(default=None, name="Validation")
+
+    # The status of the validation check done on the element, specifically for reports. This field is not required for
+    # requests, and will be populated in responses. For responses, the default value is "NOT_DONE".
+    report_validation: Optional[ValidationStatus] = attr(default=None, name="ValidationStatus")
+
+    @property
+    def validation(self) -> ValidationStatus:
+        """Return the validation status of the element."""
+        return self.base_validation or self.report_validation or ValidationStatus.NOT_DONE
 
 
 class Payload(BaseXmlModel, search_mode="unordered"):
@@ -111,23 +153,21 @@ class SchemaType(Enum):
 
     MARKET = "mi-market.xsd"
     REPORT = "mi-report.xsd"
+    REPORT_RESPONSE = "mi-outbnd-reports.xsd"
     REGISTRATION = "mpr.xsd"
     OMI = "omi.xsd"
 
 
-class PayloadBase(BaseXmlModel, nsmap={"xsi": "http://www.w3.org/2001/XMLSchema-instance"}):
+class PayloadBase(BaseXmlModel):
     """Represents the base fields for an MMS request payload."""
 
-    # The XML schema to use for validation
-    location: SchemaType = attr(name="noNamespaceSchemaLocation", ns="xsi")
-
 
 class BaseResponse(BaseXmlModel, Generic[E], tag="BaseResponse"):
     """Contains the base data extracted from the MMS response in a format we can use."""
 
     # The processing statistics returned with the payload. This will not be present in requests, and will be populated
     # in responses.
-    statistics: ProcessingStatistics = element(tag="ProcessingStatistics")
+    statistics: Optional[ProcessingStatistics] = element(default=None, tag="ProcessingStatistics")
 
     # The request payload, containing the request data
     _envelope: E = PrivateAttr()

mms_client/types/enums.py

@@ -53,6 +53,26 @@ class ResourceType(Enum):
     VPP_DEM = "07"
 
 
+class RemainingReserveAvailability(Enum):
+    """Describes the availability of remaining reserves for a power generation unit."""
+
+    NOT_AVAILABLE = "0"
+    AVAILABLE_FOR_UP_ONLY = "1"
+    AVAILABLE_FOR_DOWN_ONLY = "2"
+    AVAILABLE_FOR_UP_AND_DOWN = "3"
+
+
+class ContractType(Enum):
+    """Describes the type of contract for a power generation unit."""
+
+    MARKET = "1"
+    MARKET_AND_POWER_SUPPLY_2 = "2"
+    POWER_SUPPLY_2 = "3"
+    ONLY_POWER_SUPPLY_1 = "4"
+    MARKET_AND_REMAINING_RESERVE_UTILIZATION = "5"
+    REMAINING_RESERVE_UTILIZATION = "6"
+
+
 class CommandMonitorMethod(Enum):
     """Describes how the power generation unit is monitored and commanded."""
 
@@ -61,6 +81,20 @@ class CommandMonitorMethod(Enum):
     OFFLINE = "3"
 
 
+class BaseLineSettingMethod(Enum):
+    """Describe how the baseline is set for a power generation unit."""
+
+    PREDICTION_BASE = "1"
+    MEASUREMENT_BASE = "2"
+
+
+class SignalType(Enum):
+    """Describes the type of signal used to monitor and command a power generation unit."""
+
+    ACTUAL_OUTPUT_ORDER = "1"
+    DIFFERENTIAL_OUTPUT_ORDER = "2"
+
+
 class BooleanFlag(Enum):
     """Represents a Boolean value as an enumeration.