mms-client 1.9.3__py3-none-any.whl → 1.11.0__py3-none-any.whl

mms_client/services/base.py

@@ -28,6 +28,7 @@ from mms_client.types.transport import RequestDataType
 from mms_client.types.transport import RequestType
 from mms_client.types.transport import ResponseDataType
 from mms_client.utils.errors import AudienceError
+from mms_client.utils.errors import EnvelopeNodeNotFoundError
 from mms_client.utils.errors import MMSClientError
 from mms_client.utils.errors import MMSServerError
 from mms_client.utils.errors import MMSValidationError
@@ -131,7 +132,7 @@ class ClientProto(Protocol):
         envelope: E,
         data: Union[P, List[P]],
         config: EndpointConfiguration,
-    ) -> Tuple[MultiResponse[E, P], Dict[str, bytes]]:
+    ) -> Tuple[MultiResponse[E, P], Dict[str, bytes], bool]:
         """Submit a request to the MMS server and return the multi-response.
 
         Arguments:
@@ -139,7 +140,10 @@ class ClientProto(Protocol):
         data (Payload):                 The data to submit to the MMS server.
         config (EndpointConfiguration): The configuration for the endpoint.
 
-        Returns:    The multi-response from the MMS server.
+        Returns:
+        MultiResponse[E, P]:    The multi-response from the MMS server.
+        Dict[str, bytes]:       The attachments returned with the response.
+        bool:                   Whether or not the response was found.
         """
 
 
@@ -244,15 +248,15 @@ def mms_multi_endpoint(**kwargs):
                 envelope, callback = result, None
 
             # Now, submit the request to the MMS server and get the response
-            resp, attachments = self.request_many(envelope, args[0], config)
+            resp, attachments, found = self.request_many(envelope, args[0], config)
 
             # Call the callback function if it was provided
             if callback:
-                callback(resp, attachments)  # pragma: no cover
+                callback(resp, attachments, found)  # pragma: no cover
 
             # Finally, extract the data from the response and return it
             logger.info(f"{config.name}: Returning {len(resp.data)} item(s).")
-            return resp.data
+            return resp.data if found else []
 
         return wrapper
 
@@ -382,7 +386,9 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         envelope_type = config.response_envelope_type or type(envelope)
         data_type = config.response_data_type or type(payload)
         deserializer = config.serializer or config.service.serializer
-        data: Response[E, P] = deserializer.deserialize(resp.payload, envelope_type, data_type, config.for_report)
+        data: Response[E, P] = deserializer.deserialize(
+            config.name, resp.payload, envelope_type, data_type, config.for_report
+        )
         self._verify_response(data, config)
 
         # Return the response data and any attachments
@@ -391,12 +397,12 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         )
         return data, attachments
 
-    def request_many(
+    def request_many(  # pylint: disable=too-many-locals
         self,
         envelope: E,
         payload: Union[P, List[P]],
         config: EndpointConfiguration[E, P],
-    ) -> Tuple[MultiResponse[E, P], Dict[str, bytes]]:
+    ) -> Tuple[MultiResponse[E, P], Dict[str, bytes], bool]:
         """Submit a request to the MMS server and return the multi-response.
 
         Arguments:
@@ -404,14 +410,17 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         payload (Payload):              The data to submit to the MMS server.
         config (EndpointConfiguration): The configuration for the endpoint.
 
-        Returns:    The multi-response from the MMS server.
+        Returns:
+        MultiResponse[E, P]:    The multi-response from the MMS server.
+        Dict[str, bytes]:       The attachments returned with the response.
+        bool:                   Whether or not the response was found.
         """
         # Create a new ZWrapper for the given service
         wrapper = self._get_wrapper(config.service)
 
         # 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]
+        data_type: type = type(payload[0]) if is_list else type(payload)  # type: ignore[index]
         logger.debug(
             (
                 f"{config.name}: Starting multi-request. Envelope: {type(envelope).__name__}, "
@@ -434,23 +443,41 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         # Now, extract the attachments from the response
         attachments = {a.name: b64decode(a.data) for a in resp.attachments}
 
-        # Finally, deserialize and verify the response
-        envelope_type = config.response_envelope_type or type(envelope)
-        data_type = config.response_data_type or data_type
+        # Finally, deserialize the response and verify it
         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,
-        )
+        try:
+            found = True
+            envelope_type = config.response_envelope_type or type(envelope)
+            resp_data_type = config.response_data_type or data_type
+            data: MultiResponse[E, P] = deserializer.deserialize_multi(
+                config.name,
+                resp.payload,
+                envelope_type,
+                resp_data_type,  # type: ignore[arg-type]
+                config.for_report,
+            )
+        except EnvelopeNodeNotFoundError:
+            logger.warning(
+                f"{config.name}: Failed to deserialize multi-response. Attempting to deserialize as the request object."
+            )
+            found = False
+            envelope_type = type(envelope)
+            resp_data_type = data_type
+            data = deserializer.deserialize_multi(
+                config.name,
+                resp.payload,
+                envelope_type,
+                data_type,  # type: ignore[arg-type]
+                config.for_report,
+            )
         self._verify_multi_response(data, config)
 
         # Return the response data and any attachments
         logger.debug(
-            f"{config.name}: Returning multi-response. Envelope: {envelope_type.__name__}, Data: {data_type.__name__}",
+            f"{config.name}: Returning multi-response. Envelope: {envelope_type.__name__}, Data: "
+            f"{resp_data_type.__name__}"
         )
-        return data, attachments
+        return data, attachments, found
 
     def _to_mms_request(
         self,

mms_client/services/market.py

@@ -12,6 +12,9 @@ from mms_client.services.base import mms_endpoint
 from mms_client.services.base import mms_multi_endpoint
 from mms_client.types.award import AwardQuery
 from mms_client.types.award import AwardResponse
+from mms_client.types.bup import BalancingUnitPriceQuery
+from mms_client.types.bup import BalancingUnitPriceSubmit
+from mms_client.types.market import Defaults
 from mms_client.types.market import MarketCancel
 from mms_client.types.market import MarketQuery
 from mms_client.types.market import MarketSubmit
@@ -21,6 +24,8 @@ from mms_client.types.offer import OfferData
 from mms_client.types.offer import OfferQuery
 from mms_client.types.reserve import ReserveRequirement
 from mms_client.types.reserve import ReserveRequirementQuery
+from mms_client.types.settlement import SettlementQuery
+from mms_client.types.settlement import SettlementResults
 from mms_client.types.transport import RequestType
 from mms_client.utils.serialization import SchemaType
 from mms_client.utils.serialization import Serializer
@@ -40,7 +45,7 @@ class MarketClientMixin:  # pylint: disable=unused-argument
     @mms_multi_endpoint(
         name="MarketQuery_ReserveRequirementQuery",
         service=config,
-        request_type=RequestType.INFO,
+        request_type=RequestType.MARKET,
         response_envelope_type=MarketSubmit,
         response_data_type=ReserveRequirement,
     )
@@ -213,3 +218,120 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             user=self.user,
             days=days,
         )
+
+    @mms_endpoint(
+        name="MarketQuery_SettlementResultsFileListQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_envelope_type=MarketSubmit,
+        response_data_type=SettlementResults,
+        allowed_clients=[ClientType.BSP, ClientType.TSO],
+    )
+    def get_settlement_results(
+        self: ClientProto, request: SettlementQuery, days: int, date: Optional[Date] = None
+    ) -> SettlementResults:
+        """Query the MMS server for settlement results.
+
+        This endpoint is only accessible to BSPs and TSOs.
+
+        Arguments:
+        request (SettlementQuery):  The query to submit to the MMS server.
+        days (int):                 The number of days ahead for which the data is being queried.
+        date (Date):                The date of the transaction in the format "YYYY-MM-DD". This value defaults to the
+                                    current date.
+
+        Returns:    The settlement results that match the query.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return MarketQuery(  # type: ignore[return-value]
+            date=date or Date.today(),
+            participant=self.participant,
+            user=self.user,
+            days=days,
+        )
+
+    @mms_multi_endpoint(
+        name="MarketSubmit_BupSubmit", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
+    def put_bups(
+        self: ClientProto,
+        requests: List[BalancingUnitPriceSubmit],
+        date: Optional[Date] = None,
+        default: bool = False,
+    ) -> List[BalancingUnitPriceSubmit]:
+        """Submit multiple balancing unit prices to the MMS server.
+
+        This endpoint is only accessible to BSPs.
+
+        Arguments:
+        requests (List[BalancingUnitPriceSubmit]):  The balancing unit prices to submit to the MMS server.
+        date (Date):                                The date of the transaction in the format "YYYY-MM-DD". This value
+                                                    defaults to the current date.
+        default (bool):                             Whether or not the balancing unit prices are the default.
+
+        Returns:    A list of balancing unit prices that have been registered with the MMS server.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return MarketSubmit(  # type: ignore[return-value]
+            date=date or Date.today(),
+            participant=self.participant,
+            user=self.user,
+            defaults=Defaults(is_default=default),
+        )
+
+    @mms_endpoint(
+        name="MarketSubmit_BupSubmit", service=config, request_type=RequestType.MARKET, allowed_clients=[ClientType.BSP]
+    )
+    def put_bup(
+        self: ClientProto,
+        request: BalancingUnitPriceSubmit,
+        date: Optional[Date] = None,
+        default: bool = False,
+    ) -> BalancingUnitPriceSubmit:
+        """Submit a balancing unit price to the MMS server.
+
+        This endpoint is only accessible to BSPs.
+
+        Arguments:
+        request (BalancingUnitPriceSubmit): The balancing unit price to submit to the MMS server.
+        date (Date):                        The date of the transaction in the format "YYYY-MM-DD". This value defaults
+                                            to the current date.
+        default (bool):                     Whether or not the balancing unit price is the default.
+
+        Returns:    The balancing unit price that has been registered with the MMS server.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return MarketSubmit(  # type: ignore[return-value]
+            date=date or Date.today(),
+            participant=self.participant,
+            user=self.user,
+            defaults=Defaults(is_default=default),
+        )
+
+    @mms_multi_endpoint(
+        name="MarketQuery_BupQuery",
+        service=config,
+        request_type=RequestType.MARKET,
+        response_envelope_type=MarketSubmit,
+        response_data_type=BalancingUnitPriceSubmit,
+    )
+    def query_bups(
+        self: ClientProto, request: BalancingUnitPriceQuery, date: Optional[Date] = None
+    ) -> List[BalancingUnitPriceSubmit]:
+        """Query the MMS server for balancing unit prices.
+
+        This endpoint is accessible to all client types.
+
+        Arguments:
+        request (BalancingUnitPriceSubmit): The query to submit to the MMS server.
+        date (Date):                        The date of the transaction in the format "YYYY-MM-DD". This value defaults
+                                            to the current date.
+
+        Returns:    A list of balancing unit prices that match the query.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return MarketQuery(  # type: ignore[return-value]
+            date=date or Date.today(),
+            participant=self.participant,
+            user=self.user,
+        )

mms_client/services/omi.py

@@ -1,10 +1,24 @@
 """Contains the client layer for making OMI requests to the MMS server."""
 
 from logging import getLogger
+from typing import List
+from typing import Optional
 
+from pydantic_extra_types.pendulum_dt import Date
+
+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.omi import MarketQuery
+from mms_client.types.omi import MarketSubmit
+from mms_client.types.surplus_capcity import SurplusCapacityData
+from mms_client.types.surplus_capcity import SurplusCapacityQuery
+from mms_client.types.surplus_capcity import SurplusCapacitySubmit
+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
@@ -16,3 +30,88 @@ class OMIClientMixin:  # pylint: disable=unused-argument
 
     # The configuration for the OMI service
     config = ServiceConfiguration(Interface.OMI, Serializer(SchemaType.OMI, "MarketData"))
+
+    @mms_endpoint(
+        name="MarketSubmit_RemainingReserveData",
+        service=config,
+        request_type=RequestType.OMI,
+        response_data_type=SurplusCapacityData,
+        allowed_clients=[ClientType.BSP],
+    )
+    def put_surplus_capacity(
+        self: ClientProto, request: SurplusCapacitySubmit, date: Optional[Date] = None
+    ) -> SurplusCapacityData:
+        """Submit an offer to the MMS server.
+
+        This endpoint is only accessible to BSPs.
+
+        Arguments:
+        request (SurplusCapacitySubmit):    The surplus capacity data to submit to the MMS server.
+        date (Date):                        The date of the transaction in the format "YYYY-MM-DD". This value defaults
+                                            to the current date.
+
+        Returns:    The surplus capacity data that has been registered with the MMS server.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return MarketSubmit(  # type: ignore[return-value]
+            date=date or Date.today(),
+            participant=self.participant,
+            user=self.user,
+        )
+
+    @mms_multi_endpoint(
+        name="MarketSubmit_RemainingReserveData",
+        service=config,
+        request_type=RequestType.OMI,
+        response_data_type=SurplusCapacityData,
+        allowed_clients=[ClientType.BSP],
+    )
+    def put_surplus_capacities(
+        self: ClientProto, requests: List[SurplusCapacitySubmit], date: Optional[Date] = None
+    ) -> List[SurplusCapacityData]:
+        """Submit multiple surplus capacity data to the MMS server.
+
+        This endpoint is only accessible to BSPs.
+
+        Arguments:
+        requests (list[SurplusCapacitySubmit]): The surplus capacity data to submit to the MMS server.
+        date (Date):                            The date of the transaction in the format "YYYY-MM-DD". This value
+                                                defaults to the current date.
+
+        Returns:    A list of surplus capacity data that have been registered with the MMS server.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return MarketSubmit(  # type: ignore[return-value]
+            date=date or Date.today(),
+            participant=self.participant,
+            user=self.user,
+        )
+
+    @mms_multi_endpoint(
+        name="MarketQuery_RemainingReserveDataQuery",
+        service=config,
+        request_type=RequestType.OMI,
+        response_envelope_type=MarketSubmit,
+        response_data_type=SurplusCapacityData,
+        allowed_clients=[ClientType.BSP, ClientType.TSO],
+    )
+    def query_surplus_capacity(
+        self: ClientProto, request: SurplusCapacityQuery, date: Optional[Date] = None
+    ) -> List[SurplusCapacityData]:
+        """Query the MMS server for surplus capacity data.
+
+        This endpoint is only accessible to BSPs and TSOs.
+
+        Arguments:
+        request (SurplusCapacityQuery): The query to submit to the MMS server.
+        date (Date):                    The date of the transaction in the format "YYYY-MM-DD". This value defaults to
+                                        the current date.
+
+        Returns:    A list of surplus capacity data that match the query.
+        """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
+        return MarketQuery(  # type: ignore[return-value]
+            date=date or Date.today(),
+            participant=self.participant,
+            user=self.user,
+        )

mms_client/types/award.py

@@ -192,6 +192,12 @@ class Award(Payload):
     # The contract price, in JPY/kW/segment
     contract_price: Decimal = price("ContractPrice", 10000.00)
 
+    # The unit price charged for the start up cost of the power, in JPY/kW/segment
+    start_up_unit_price: Decimal = price("StartUpUnitPrice", 10000.00, True)
+
+    # The unit price charged for the ramp down cost of the power, in JPY/kW/segment
+    ramp_down_unit_price: Decimal = price("RampDownUnitPrice", 10000.00, True)
+
     # The performance evaluation coefficient, alpha
     performance_evaluation_coefficient: Decimal = attr(name="PerfEvalCoeff", ge=0.00, le=100.0, decimal_places=2)
 

mms_client/types/base.py

@@ -35,6 +35,9 @@ class Message(BaseXmlModel):
     # The message text. Not sure why this is called code in the XML.
     code: str = attr(default="", name="Code", min_length=2, max_length=50, pattern=r"^[a-zA-Z_0-9\-]*$")
 
+    # A human-readable description of the message
+    description: str
+
 
 class Messages(BaseXmlModel, search_mode="unordered", arbitrary_types_allowed=True):
     """Represents a collection of messages returned with a payload."""
@@ -49,21 +52,21 @@ class Messages(BaseXmlModel, search_mode="unordered", arbitrary_types_allowed=Tr
     errors_raw: List[Element] = element(default=[], tag="Error", nillable=True, exclude=True)
 
     @computed_element
-    def information(self) -> List[str]:
+    def information(self) -> List[Message]:
         """Return the information messages."""
         return self._parse_messages(self.information_raw)
 
     @computed_element
-    def warnings(self) -> List[str]:
+    def warnings(self) -> List[Message]:
         """Return the warning messages."""
         return self._parse_messages(self.warnings_raw)
 
     @computed_element
-    def errors(self) -> List[str]:
+    def errors(self) -> List[Message]:
         """Return the error messages."""
         return self._parse_messages(self.errors_raw)
 
-    def _parse_messages(self, raw: List[Element]) -> List[str]:
+    def _parse_messages(self, raw: List[Element]) -> List[Message]:
         """Parse the messages from the XML tree.
 
         Arguments:
@@ -73,10 +76,11 @@ class Messages(BaseXmlModel, search_mode="unordered", arbitrary_types_allowed=Tr
         """
         messages = []
         for item in raw:
+            text = item.text or ""
             if message := item.attrib.get("Code"):
-                messages.append(message)
+                messages.append(Message(description=text, code=message))
             else:
-                messages.append(item.text or "")
+                messages.append(Message(description=text))
         return messages
 
 

mms_client/types/bup.py

@@ -0,0 +1,207 @@
+"""Contains objects for BUPs."""
+
+from decimal import Decimal
+from enum import Enum
+from typing import Annotated
+from typing import List
+from typing import Optional
+
+from pendulum import Timezone
+from pydantic import field_serializer
+from pydantic import field_validator
+from pydantic_core import PydanticUndefined
+from pydantic_extra_types.pendulum_dt import DateTime
+from pydantic_xml import attr
+from pydantic_xml import element
+from pydantic_xml import wrapped
+
+from mms_client.types.base import Payload
+from mms_client.types.enums import AreaCode
+from mms_client.types.fields import capacity
+from mms_client.types.fields import company_short_name
+from mms_client.types.fields import participant
+from mms_client.types.fields import power_positive
+from mms_client.types.fields import price
+from mms_client.types.fields import resource_name
+from mms_client.types.fields import resource_short_name
+from mms_client.types.fields import system_code
+
+
+def abc_price(alias: str, optional: bool = False):
+    """Create a field for an abc price.
+
+    Arguments:
+    alias (str):        The name of the alias to assign to the Pydanitc field. This value will be used to map the field
+                        to the JSON/XML key.
+    optional (bool):    If True, the field will be optional with a default of None. If False, the field will be
+                        required, with no default.
+
+    Returns:    A Pydantic Field object for the abc price.
+    """
+    return attr(
+        default=None if optional else PydanticUndefined, name=alias, gt=-100000.0, lt=100000.0, decimal_places=1
+    )
+
+
+class Status(Enum):
+    """Enum representing the possible statuses of a pattern."""
+
+    INACTIVE = "0"
+    ACTIVE = "1"
+
+
+class StartupCostBand(Payload, tag="BandStartup"):
+    """Represents a band of a startup cost."""
+
+    # The band number which must be unique within the startup cost and will identify this band in sequence.
+    number: int = attr(name="CaseNo", ge=1, le=10)
+
+    # The time at which the startup cost is applied. This value must be greater than or equal to 0.
+    stop_time_hours: int = attr(name="StopTime", ge=0, lt=1000)
+
+    # The V3 unit price charged for this band.
+    v3_unit_price: int = attr(name="V3", ge=0, lt=100000000)
+
+    # The remarks associated with this band.
+    remarks: Optional[str] = attr(default=None, name="Remark", min_length=1, max_length=30)
+
+
+class AbcBand(Payload, tag="BandAbc"):
+    """Represents a band of an ABC, whatever that is."""
+
+    # The band number which must be unique within the ABC and will identify this band in sequence.
+    number: int = attr(name="Band", ge=1, le=5)
+
+    # The capacity from which the band is allowed to operate.
+    from_capacity: int = power_positive("FromCap")
+
+    # The a term of the band.
+    a: Decimal = abc_price("a")
+
+    # The b term of the band.
+    b: Decimal = abc_price("b")
+
+    # The c term of the band.
+    c: Decimal = abc_price("c")
+
+
+class BalancingUnitPriceBand(Payload):
+    """Represents a band of a balancing unit price."""
+
+    # The band number which must be unique within the balancing unit price and will identify this band in sequence.
+    number: int = attr(name="Band", ge=1, le=20)
+
+    # The capacity from which the band is allowed to operate. If the resource_type on the associated resource is set to
+    # THERMAL or HYDRO then the value of this field must be greater than or equal to 0. Otherwise, the value of this
+    # field is unrestricted.
+    from_capacity: int = capacity("FromCap", -10000000)
+
+    # The V1 unit price charged for this band.
+    v1_unit_price: Decimal = price("V1", 10000.00)
+
+    # The V2 unit price charged for this band. This value is only valid when the contract_type on the associated
+    # resource is set to anything other than ONLY_POWER_SUPPLY_1.
+    v2_unit_price: Annotated[Decimal, price("V2", 10000.00, True)]
+
+
+class BalancingUnitPrice(Payload):
+    """Represents a balancing unit profile."""
+
+    # The V4 unit price charged for this pattern. This value is only valid when the contract_type on the associated
+    # resource is set to anything other than ONLY_POWER_SUPPLY_1.
+    v4_unit_price: Annotated[Decimal, price("V4", 10000.00, True)]
+
+    # The bands associated with this BUP.
+    bands: Annotated[List[BalancingUnitPriceBand], element(tag="BandBup", min_length=1, max_length=20)]
+
+
+class Pattern(Payload):
+    """Represents a pattern associated with a BUP."""
+
+    # A number identifying this pattern in the overall sequence of patterns
+    number: int = attr(name="PatternNo", ge=1, le=10)
+
+    # The status of the pattern
+    status: Status = attr(name="PatternStatus")
+
+    # Any comments associated with the pattern
+    remarks: Optional[str] = attr(default=None, name="PatternRemark", min_length=1, max_length=50)
+
+    # The balancing unit profile associated with this pattern
+    balancing_unit_profile: Optional[BalancingUnitPrice] = element(default=None, tag="Bup")
+
+    # The quadratic pricing bands associated with this pattern
+    abc: Annotated[Optional[List[AbcBand]], wrapped(default=None, path="Abc", min_length=1, max_length=5)]
+
+    # The startup cost bands associated with this pattern
+    startup_costs: Annotated[
+        Optional[List[StartupCostBand]], wrapped(default=None, path="StartupCost", min_length=1, max_length=10)
+    ]
+
+
+class BalancingUnitPriceSubmit(Payload, tag="BupSubmit"):
+    """Represents the data included with a BUP."""
+
+    # The resource with which the BUP is associated
+    resource_code: str = resource_name("ResourceName")
+
+    # The start date and time for the validity period of the BUP
+    start: DateTime = attr(name="StartTime")
+
+    # The end date and time for the validity period of the BUP
+    end: DateTime = attr(name="EndTime")
+
+    # The patterns associated with this BUP
+    patterns: Annotated[List[Pattern], element(tag="PatternData", max_length=10)]
+
+    # The name of the BSP participant submitting the BUP. This will only be populated when the object is returned.
+    participant_name: Optional[str] = participant("BspParticipantName", True)
+
+    # The name of the company submitting the BUP. This will only be populated when the object is returned.
+    company: Optional[str] = company_short_name("CompanyShortName", True)
+
+    # The area associated with the BUP. This will only be populated when the object is returned.
+    area: Optional[AreaCode] = attr(default=None, name="Area")
+
+    # The name of the resource being traded. This will only be populated when the object is returned.
+    resource_name: Optional[str] = resource_short_name("ResourceShortName", True)
+
+    # The MMS code of the business entity to which the registration applies. This will only be populated when the
+    # object is returned.
+    system_code: Optional[str] = system_code("SystemCode", True)
+
+    @field_serializer("start", "end")
+    def encode_datetime(self, value: DateTime) -> str:
+        """Encode the datetime to an MMS-compliant ISO 8601 string."""
+        return value.replace(tzinfo=None).isoformat() if value else ""
+
+    @field_validator("start", "end")
+    def decode_datetime(cls, value: DateTime) -> DateTime:  # pylint: disable=no-self-argument
+        """Decode the datetime from an MMS-compliant ISO 8601 string."""
+        return value.replace(tzinfo=Timezone("Asia/Tokyo"))
+
+
+class BalancingUnitPriceQuery(Payload, tag="BupQuery"):
+    """Represents the data included with a BUP query."""
+
+    # Whether or not the BUP is the default
+    is_default: Optional[bool] = attr(default=None, name="StandingFlag")
+
+    # The resource with which the BUP is associated
+    resource_code: str = resource_name("ResourceName")
+
+    # The start date and time for the validity period of the BUP
+    start: Annotated[DateTime, attr(default=None, name="StartTime")]
+
+    # The end date and time for the validity period of the BUP
+    end: Annotated[DateTime, attr(default=None, name="EndTime")]
+
+    @field_serializer("start", "end")
+    def encode_datetime(self, value: DateTime) -> str:
+        """Encode the datetime to an MMS-compliant ISO 8601 string."""
+        return value.replace(tzinfo=None).isoformat() if value else ""
+
+    @field_validator("start", "end")
+    def decode_datetime(cls, value: DateTime) -> DateTime:  # pylint: disable=no-self-argument
+        """Decode the datetime from an MMS-compliant ISO 8601 string."""
+        return value.replace(tzinfo=Timezone("Asia/Tokyo"))