mms-client 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

mms_client/services/base.py

@@ -10,6 +10,7 @@ from typing import Optional
 from typing import Protocol
 from typing import Tuple
 from typing import Type
+from typing import Union
 
 from mms_client.security.crypto import Certificate
 from mms_client.security.crypto import CryptoWrapper
@@ -119,7 +120,7 @@ class ClientProto(Protocol):
     def request_many(
         self,
         envelope: E,
-        data: P,
+        data: Union[P, List[P]],
         config: EndpointConfiguration,
     ) -> Tuple[MultiResponse[E, P], Dict[str, bytes]]:
         """Submit a request to the MMS server and return the multi-response.
@@ -361,7 +362,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
     def request_many(
         self,
         envelope: E,
-        payload: P,
+        payload: Union[P, List[P]],
         config: EndpointConfiguration[E, P],
     ) -> Tuple[MultiResponse[E, P], Dict[str, bytes]]:
         """Submit a request to the MMS server and return the multi-response.
@@ -374,13 +375,20 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         Returns:    The multi-response from the MMS server.
         """
         # 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(
             (
                 f"{config.name}: Starting multi-request. Envelope: {type(envelope).__name__}, "
-                f"Data: {type(payload).__name__}"
+                f"Data: {data_type.__name__}"
             ),
         )
-        request = self._to_mms_request(config.request_type, config.service.serializer.serialize(envelope, payload))
+        serialized = (
+            config.service.serializer.serialize_multi(envelope, payload, data_type)  # type: ignore[arg-type]
+            if is_list
+            else config.service.serializer.serialize(envelope, payload)  # type: ignore[type-var]
+        )
+        request = self._to_mms_request(config.request_type, serialized)
 
         # Next, submit the request to the MMS server and get and verify the response.
         resp = self._get_wrapper(config.service).submit(request)
@@ -391,8 +399,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 type(payload)
-        data: MultiResponse[E, P] = config.service.serializer.deserialize_multi(resp.payload, envelope_type, data_type)
+        data_type = config.response_data_type or data_type
+        data: MultiResponse[E, P] = config.service.serializer.deserialize_multi(
+            resp.payload,
+            envelope_type,
+            data_type,  # type: ignore[arg-type]
+        )
         self._verify_multi_response(data, config)
 
         # Return the response data and any attachments

mms_client/services/market.py

@@ -8,6 +8,8 @@ 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.award import AwardQuery
+from mms_client.types.award import AwardResponse
 from mms_client.types.market import MarketCancel
 from mms_client.types.market import MarketQuery
 from mms_client.types.market import MarketSubmit
@@ -45,7 +47,33 @@ class MarketClientMixin:  # pylint: disable=unused-argument
 
         Returns:    The offer 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
+        # 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,
+            market_type=market_type,
+            days=days,
+        )
+
+    @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]:
+        """Submit multiple offers to the MMS server.
+
+        This endpoint is only accessible to BSPs.
+
+        Arguments:
+        requests (List[OfferData]): The offers to submit to the MMS server.
+        market_type (MarketType):   The type of market for which the offers are being submitted.
+        days (int):                 The number of days ahead for which the offers are being submitted.
+        date (Date):                The date of the transaction in the format "YYYY-MM-DD". This value defaults to the
+                                    current date.
+
+        Returns:    A list of offers 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,
@@ -57,28 +85,24 @@ class MarketClientMixin:  # pylint: disable=unused-argument
     @mms_multi_endpoint(
         "MarketQuery_OfferQuery", config, RequestType.INFO, resp_envelope_type=MarketSubmit, resp_data_type=OfferData
     )
-    def query_offers(
-        self: ClientProto, request: OfferQuery, market_type: MarketType, days: int, date: Optional[Date] = None
-    ) -> List[OfferData]:
+    def query_offers(self: ClientProto, request: OfferQuery, days: int, date: Optional[Date] = None) -> List[OfferData]:
         """Query the MMS server for offers.
 
         This endpoint is accessible to all client types.
 
         Arguments:
         request (OfferQuery):       The query to submit to the MMS server.
-        market_type (MarketType):   The type of market for which the offer was submitted.
         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:    A list of offers that match the query.
         """
-        # Note: the return type does not match the method definition but the decorator will return the correct type
+        # 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,
-            market_type=market_type,
             days=days,
         )
 
@@ -97,7 +121,7 @@ class MarketClientMixin:  # pylint: disable=unused-argument
         date (Date):                The date of the transaction in the format "YYYY-MM-DD". This value defaults to the
                                     current date.
         """
-        # Note: the return type does not match the method definition but the decorator will return the correct type
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
         return MarketCancel(  # type: ignore[return-value]
             date=date or Date.today(),
             participant=self.participant,
@@ -105,3 +129,30 @@ class MarketClientMixin:  # pylint: disable=unused-argument
             market_type=market_type,
             days=days,
         )
+
+    @mms_endpoint("MarketQuery_AwardResultsQuery", config, RequestType.INFO, resp_data_type=AwardResponse)
+    def query_awards(self: ClientProto, request: AwardQuery, days: int, date: Optional[Date] = None) -> AwardResponse:
+        """Query the MMS server for award results.
+
+        This endpoint is accessible to all client types.
+
+        If no values are specified for Area, Associated Area, Power Generation Unit Code, or GC Registration Flag,
+        the results for all areas will be retrieved. If one or more of these criteria are specified, the results will
+        be filtered according to the specified criteria. If no value is specified for the retrieval period, the default
+        value for this field is 1.
+
+        Arguments:
+        request (AwardQuery):       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 award 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_client/services/registration.py

@@ -38,6 +38,7 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
 
         Returns:    The resource 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
         # For some reason, the registration DTOs require that the participant ID exist on the payload rather than on
         # the envelope so we need to set it before we return the envelope.
         request.participant = self.participant
@@ -65,6 +66,7 @@ class RegistrationClientMixin:  # pylint: disable=unused-argument
 
         Returns:    A list of resources that match the query.
         """
+        # NOTE: The return type does not match the method definition but the decorator will return the correct type
         # For some reason, the registration DTOs require that the participant ID exist on the payload rather than on
         # the envelope so we need to set it before we return the envelope.
         request.participant = self.participant

mms_client/types/award.py

@@ -0,0 +1,310 @@
+"""Contains objects for MMS award results."""
+
+from decimal import Decimal
+from enum import Enum
+from typing import List
+from typing import Optional
+
+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.enums import BooleanFlag
+from mms_client.types.enums import CommandMonitorMethod
+from mms_client.types.enums import ContractResult
+from mms_client.types.enums import Direction
+from mms_client.types.enums import ResourceType
+from mms_client.types.fields import company_short_name
+from mms_client.types.fields import contract_id
+from mms_client.types.fields import dr_patter_number
+from mms_client.types.fields import dr_pattern_name
+from mms_client.types.fields import jbms_id
+from mms_client.types.fields import offer_id
+from mms_client.types.fields import operator_code
+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
+from mms_client.types.market import MarketType
+
+
+def baseload_file_name(alias: str, optional: bool = False):
+    """Create a field for a baseload file name.
+
+    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 baseload file name.
+    """
+    return attr(
+        default=None if optional else PydanticUndefined,
+        name=alias,
+        min_length=31,
+        max_length=40,
+        pattern=r"^W9_[0-9]{4}_[0-9]{8}_[0-9]{2}_[A-Z0-9]{5}_[A-Z0-9_\-]{1,10}\.xml$",
+    )
+
+
+class SubRequirement(Enum):
+    """Commodity combination categories."""
+
+    PRIMARY = "PRI"
+    SECONDARY_1 = "SEC1"
+    SECONDARY_2 = "SEC2"
+    TERTIARY_1 = "TER1"
+    PRIMARY_SECONDARY_1 = "PRI-SEC1"
+    PRIMARY_SECONDARY_2 = "PRI-SEC2"
+    PRIMARY_TERTIARY_1 = "PRI-TER1"
+    SECONDARY = "SEC1-SEC2"
+    SECONDARY_1_TERTIARY_1 = "SEC1-TER1"
+    SECONDARY_2_TERTIARY_1 = "SEC2-TER1"
+    PRIAMRY_SECONDARY = "PRI-SEC1-SEC2"
+    PRIMARY_SECONDARY_1_TERTIARY_1 = "PRI-SEC1-TER1"
+    PRIMARY_SECONDARY_2_TERTIARY_1 = "PRI-SEC2-TER1"
+    SECONDARY_TERTIARY_1 = "SEC1-SEC2-TER1"
+    PRIMARY_SECONDARY_TERTIARY_1 = "PRI-SEC1-SEC2-TER1"
+
+
+class ContractSource(Enum):
+    """Describes the source of the contract."""
+
+    MA = "1"
+    SWITCHING = "2"
+
+
+class AwardQuery(Payload, tag="AwardResultsQuery"):
+    """Query object for bid awards."""
+
+    # The market for which results should be retrieved
+    market_type: MarketType = attr(name="MarketType")
+
+    # The area for which results should be retrieved. If this isn't provided, then all results will be retrieved
+    area: Optional[AreaCode] = attr(default=None, name="Area")
+
+    # The associated area. If the API user is a BSP, this field cannot be set
+    linked_area: Optional[AreaCode] = attr(default=None, name="LinkedArea")
+
+    # The name of the resource for which results should be retrieved. If this isn't provided, then all results will be
+    # retrieved for all resources
+    resource: Optional[str] = resource_name("ResourceName", True)
+
+    # The start date and time for which results should be retrieved. Should conform with the start of a block
+    start: DateTime = attr(name="StartTime")
+
+    # The end date and time for which results should be retrieved. Should conform with the end of a block. You can
+    # specify the end date and time of any block within the period from the transaction date to the number of days to
+    # get multiple blocks.
+    end: DateTime = attr(name="EndTime")
+
+    # Whether we are before gate close or after gate close. If this isn't provided, then all results will be retrieved
+    # regardless of gate closure.
+    gate_closed: Optional[BooleanFlag] = attr(default=None, name="AfterGC")
+
+
+class Award(Payload):
+    """Represents the details of a bid award."""
+
+    # Unique identifier assigned to the contract
+    contract_id: str = contract_id("ContractId")
+
+    # Unique identifier assigned to the contract by the JBMS
+    jbms_id: int = jbms_id("JbmsId")
+
+    # The area of the power generation unit generating the electricity
+    area: AreaCode = attr(name="Area")
+
+    # The associated area. If the API user is a BSP, it is not set.
+    linked_area: Optional[AreaCode] = attr(default=None, name="LinkedArea")
+
+    # A code identifying the power generation unit for which this bid was awarded
+    resource: str = resource_name("ResourceName")
+
+    # An abbreviated name for the power generation unit for which this bid was awarded
+    resource_short_name: str = resource_short_name("ResourceShortName")
+
+    # The grid code of the resource being traded
+    system_code: str = system_code("SystemCode")
+
+    # How the power generation unit produces electricity
+    resource_type: ResourceType = attr(name="ResourceType")
+
+    # The type of market for which the offer is being submitted. Must be a valid pattern number for the submission date
+    # Required for VPP resources. Ensure there are no duplicate pattern numbers for the same resource and start time.
+    pattern_number: Optional[int] = dr_patter_number("DrPatternNumber", True)
+
+    # The name of the list pattern with which this award is associated
+    pattern_name: Optional[str] = dr_pattern_name("DrPatternName", True)
+
+    # The participant ID of the BSP associated with this bid award
+    bsp_participant: str = participant("BspParticipantName")
+
+    # The abbreviated name of the counterparty
+    company_short_name: str = company_short_name("CompanyShortName")
+
+    # A code identifying the TSO or MO
+    operator: str = operator_code("OperatorCode")
+
+    # Primary-Secondary 1 command-and-control and monitoring method. Refers to the methodology or system utilized for
+    # regulating and overseeing power generation units' operations in response to external commands or signals. This
+    # method encompasses the process by which instructions are transmitted to power generation units, and their
+    # performance is monitored to ensure compliance with these instructions. If has_secondary_1 is set to True, then
+    # it must be set to DEDICATED_LINE. At least one of the following combinations must be set:
+    #   primary_secondary_1_control_method
+    #   secondary_2_tertiary_control_method
+    primary_secondary_1_control_method: Optional[CommandMonitorMethod] = attr(
+        default=None, name="CommandOperationMethodPriSec1"
+    )
+
+    # Secondary 2-Tertiary command-and-control and monitoring method. Refers to the methodology or system utilized for
+    # regulating and overseeing power generation units' operations in response to external commands or signals. This
+    # method encompasses the process by which instructions are transmitted to power generation units, and their
+    # performance is monitored to ensure compliance with these instructions.
+    secondary_2_tertiary_control_method: Optional[CommandMonitorMethod] = attr(
+        default=None, name="CommandOperationMethodSec2Ter1Ter2"
+    )
+
+    # Bid unit price, in JPY/kW/segment
+    offer_price: Decimal = price("OfferPrice", 10000.00)
+
+    # The contract price, in JPY/kW/segment
+    contract_price: Decimal = price("ContractPrice", 10000.00)
+
+    # The performance evaluation coefficient, alpha
+    performance_evaluation_coefficient: Decimal = attr(name="PerfEvalCoeff", ge=0.00, le=100.0, decimal_places=2)
+
+    # The corrected unit price, in JPY/kW/segment
+    corrected_unit_price: Decimal = price("CorrectedUnitPrice", 1000000.00)
+
+    # The commodity combination category. This is only set for non-BSP users.
+    sub_requirement: Optional[SubRequirement] = attr(default=None, name="SubRequirementType")
+
+    # The primary offer quantity in kW. If the API user is a BSP, this field is not set for the contract results
+    # generated by the TSO's power source exchange.
+    primary_offer_qty: Optional[int] = power_positive("PrimaryOfferQuantityInKw", True)
+
+    # The secondary 1 offer quantity, in kW. If the API user is a BSP, this field is not set for the contract results
+    # generated by the TSO's power source exchange.
+    secondary_1_offer_qty: Optional[int] = power_positive("Secondary1OfferQuantityInKw", True)
+
+    # The secondary 2 offer quantity, in kW. If the API user is a BSP, this field is not set for the contract results
+    # generated by the TSO's power source exchange.
+    secondary_2_offer_qty: Optional[int] = power_positive("Secondary2OfferQuantityInKw", True)
+
+    # The tertiary 1 offer quantity, in kW. If the API user is a BSP, this field is not set for the contract results
+    # generated by the TSO's power source exchange.
+    tertiary_1_offer_qty: Optional[int] = power_positive("Tertiary1OfferQuantityInKw", True)
+
+    # The tertiary 2 offer quantity, in kW. If the API user is a BSP, this field is not set for the contract results
+    # generated by the TSO's power source exchange.
+    tertiary_2_offer_qty: Optional[int] = power_positive("Tertiary2OfferQuantityInKw", True)
+
+    # The primary award quantity, in kW
+    primary_award_qty: Optional[int] = power_positive("PrimaryAwardQuantityInKw", True)
+
+    # The secondary 1 award quantity, in kW
+    secondary_1_award_qty: Optional[int] = power_positive("Secondary1AwardQuantityInKw", True)
+
+    # The secondary 2 award quantity, in kW
+    secondary_2_award_qty: Optional[int] = power_positive("Secondary2AwardQuantityInKw", True)
+
+    # The tertiary 1 award quantity, in kW
+    tertiary_1_award_qty: Optional[int] = power_positive("Tertiary1AwardQuantityInKw", True)
+
+    # The tertiary 2 award quantity, in kW
+    tertiary_2_award_qty: Optional[int] = power_positive("Tertiary2AwardQuantityInKw", True)
+
+    # The primary contract quantity, in kW
+    primary_contract_qty: Optional[int] = power_positive("PrimaryContractQuantityInKw", True)
+
+    # The secondary 1 contract quantity, in kW
+    secondary_1_contract_qty: Optional[int] = power_positive("Secondary1ContractQuantityInKw", True)
+
+    # The secondary 2 contract quantity, in kW
+    secondary_2_contract_qty: Optional[int] = power_positive("Secondary2ContractQuantityInKw", True)
+
+    # The tertiary 1 contract quantity, in kW
+    tertiary_1_contract_qty: Optional[int] = power_positive("Tertiary1ContractQuantityInKw", True)
+
+    # The tertiary 2 contract quantity, in kW
+    tertiary_2_contract_qty: Optional[int] = power_positive("Tertiary2ContractQuantityInKw", True)
+
+    # The primary effective contracted quantity, in kW
+    primary_valid_qty: Optional[int] = power_positive("PrimaryValidQuantityInKw", True)
+
+    # The secondary 1 effective contracted quantity, in kW
+    secondary_1_valid_qty: Optional[int] = power_positive("Secondary1ValidQuantityInKw", True)
+
+    # The secondary 2 effective contracted quantity, in kW
+    secondary_2_valid_qty: Optional[int] = power_positive("Secondary2ValidQuantityInKw", True)
+
+    # The tertiary 1 effective contracted quantity, in kW
+    tertiary_1_valid_qty: Optional[int] = power_positive("Tertiary1ValidQuantityInKw", True)
+
+    # The compound fulfillment quantity, in kW
+    compound_valid_qty: Optional[int] = power_positive("CompoundValidQuantityInKw", True)
+
+    # The primary invalid contract quantity, in kW
+    primary_invalid_qty: Optional[int] = power_positive("PrimaryInvalidQuantityInKw", True)
+
+    # The secondary 1 invalid contract quantity, in kW
+    secondary_1_invalid_qty: Optional[int] = power_positive("Secondary1InvalidQuantityInKw", True)
+
+    # The secondary 2 invalid contract quantity, in kW
+    secondary_2_invalid_qty: Optional[int] = power_positive("Secondary2InvalidQuantityInKw", True)
+
+    # The tertiary 1 invalid contract quantity, in kW
+    tertiary_1_invalid_qty: Optional[int] = power_positive("Tertiary1InvalidQuantityInKw", True)
+
+    # Name of the file containing the negative baseload data
+    negative_baseload_file: Optional[str] = baseload_file_name("BaselineLoadFileNameNeg", True)
+
+    # Name of the file containing the positive baseload data
+    positive_baseload_file: Optional[str] = baseload_file_name("BaselineLoadFileNamePos", True)
+
+    # The date and time when the offer was submitted. If the API user is a BSP, this attribute is not set for the
+    # contract results generated by the TSO's power source exchange.
+    submission_time: Optional[DateTime] = attr(default=None, name="SubmissionTime")
+
+    # Contract result (full, partial)
+    offer_award_level: ContractResult = attr(name="OfferAwardedLevel")
+
+    # The ID of the offer to which this stack belongs
+    offer_id: Optional[str] = offer_id("OfferId", True)
+
+    # The source of the contract
+    contract_source: ContractSource = attr(name="ContractSource")
+
+    # Whether we are before gate close or after gate close
+    gate_closed: BooleanFlag = attr(name="AfterGC")
+
+
+class AwardResult(Payload, tag="AwardResults"):
+    """Contains a number of bid rewards associated with a block of time and trade direction."""
+
+    # The start date and time of the block associated with the awards
+    start: DateTime = attr(name="StartTime")
+
+    # The end date and time of the block associated with the awards
+    end: DateTime = attr(name="EndTime")
+
+    # The direction of the associated trades
+    direction: Direction = attr(name="Direction")
+
+    # The bid awards associated with these parameters
+    data: List[Award] = element(tag="AwardResultsData", min_length=1)
+
+
+class AwardResponse(AwardQuery, tag="AwardResultsQuery"):
+    """Contains the results of a bid award query."""
+
+    # The bid awards associated with the query
+    results: Optional[List[AwardResult]] = wrapped(default=None, path="AwardResultsQueryResponse")

mms_client/types/enums.py

@@ -19,8 +19,55 @@ class AreaCode(Enum):
     OKINAWA = "10"
 
 
+class Direction(Enum):
+    """Represents the reserve direction of the offer."""
+
+    SELL = "1"  # Increasing the reserves (sell)
+    # Note: Support for the BUY direction was removed from the MMS API
+    # BUY = "2"  # Decreasing the reserves (buy)
+
+
+class ContractResult(Enum):
+    """Represents the result of a contract."""
+
+    FULL = "1"
+    PARTIAL = "2"
+
+
 class Frequency(IntEnum):
     """Represents the frequency of power sources."""
 
     EAST = 50
     WEST = 60
+
+
+class ResourceType(Enum):
+    """How the power generation unit produces electricity."""
+
+    THERMAL = "01"
+    HYDRO = "02"
+    PUMP = "03"
+    BATTERY = "04"
+    VPP_GEN = "05"
+    VPP_GEN_AND_DEM = "06"
+    VPP_DEM = "07"
+
+
+class CommandMonitorMethod(Enum):
+    """Describes how the power generation unit is monitored and commanded."""
+
+    DEDICATED_LINE = "1"
+    SIMPLE_COMMAND = "2"
+    OFFLINE = "3"
+
+
+class BooleanFlag(Enum):
+    """Represents a Boolean value as an enumeration.
+
+    There are many places throughout the MMS documenation where Boolean values are treated as enums for reasons that are
+    not clear. This is a common pattern and this class is provided to make it easier to handle these cases without
+    having many different enum classes
+    """
+
+    YES = "1"
+    NO = "0"

mms_client/types/fields.py

@@ -69,6 +69,26 @@ def transaction_id(alias: str, optional: bool = False):
     )
 
 
+def offer_id(alias: str, optional: bool = False):
+    """Create a field for an offer ID.
+
+    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 offer ID.
+    """
+    return attr(
+        default=None if optional else PydanticUndefined,
+        name=alias,
+        min_length=1,
+        max_length=30,
+        pattern=r"^[a-zA-Z0-9_-]*$",
+    )
+
+
 def capacity(alias: str, minimum: int, optional: bool = False):
     """Create a field for a capacity value.
 
@@ -98,18 +118,19 @@ def power_positive(alias: str, optional: bool = False):
     return attr(default=None if optional else PydanticUndefined, name=alias, gt=0, le=10000000)
 
 
-def price(alias: str, optional: bool = False):
+def price(alias: str, limit: float, optional: bool = False):
     """Create a field for a price value.
 
     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.
+    limit (int):        The maximum value for the price field.
     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 price value.
     """
-    return attr(default=None if optional else PydanticUndefined, name=alias, ge=0.00, lt=10000.00, decimal_places=2)
+    return attr(default=None if optional else PydanticUndefined, name=alias, ge=0.00, le=limit, decimal_places=2)
 
 
 def percentage(alias: str, optional: bool = False):
@@ -140,6 +161,22 @@ def dr_patter_number(alias: str, optional: bool = False):
     return attr(default=None if optional else PydanticUndefined, name=alias, ge=1, le=20)
 
 
+def dr_pattern_name(alias: str, optional: bool = False):
+    """Create a field for a DR pattern name.
+
+    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 DR pattern name.
+    """
+    return attr(
+        default=None if optional else PydanticUndefined, name=alias, min_length=1, max_length=20, pattern=JAPANESE_TEXT
+    )
+
+
 def pattern_name(alias: str, optional: bool = False):
     """Create a field for a pattern name.
 
@@ -246,6 +283,40 @@ def resource_short_name(alias: str, optional: bool = False):
     )
 
 
+def contract_id(alias: str, optional: bool = False):
+    """Create a field for a contract ID.
+
+    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 contract ID.
+    """
+    return attr(
+        default=None if optional else PydanticUndefined,
+        name=alias,
+        min_length=19,
+        max_length=19,
+        pattern=r"^[a-zA-Z0-9]**$",
+    )
+
+
+def jbms_id(alias: str, optional: bool = False):
+    """Create a field for a JBMS ID.
+
+    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 JBMS ID.
+    """
+    return attr(default=None if optional else PydanticUndefined, name=alias, ge=1, lt=1000000000000000000)
+
+
 def system_code(alias: str, optional: bool = False):
     """Create a field for a system code.
 

mms_client/types/market.py

@@ -33,9 +33,6 @@ class BaseMarketRequest(Envelope):
     # will be checked against the certificate used to make the request.
     user: str = attr(name="UserName", min_length=1, max_length=12, pattern=r"^[A-Z0-9]*$")
 
-    # The type of market for which the data is being submitted
-    market_type: Optional[MarketType] = attr(default=None, name="MarketType")
-
 
 class MarketQuery(BaseMarketRequest):
     """Represents the base fields for a market query."""
@@ -48,6 +45,9 @@ class MarketQuery(BaseMarketRequest):
 class MarketSubmit(BaseMarketRequest):
     """Represents the base fields for a market registration request."""
 
+    # The type of market for which the data is being submitted
+    market_type: Optional[MarketType] = attr(default=None, name="MarketType")
+
     # If the market type is specified as "DAM" (day-ahead market), the number of days should be specified as "1".
     # Otherwise, this field indicates the number of days ahead for which the data is being submitted.
     days: int = attr(default=1, name="NumOfDays", ge=1, le=31)
@@ -56,6 +56,9 @@ class MarketSubmit(BaseMarketRequest):
 class MarketCancel(BaseMarketRequest):
     """Represents the base fields for a market cancellation request."""
 
+    # The type of market for which the data is being submitted
+    market_type: MarketType = attr(name="MarketType")
+
     # If the market type is specified as "DAM" (day-ahead market), the number of days should be specified as "1".
     # Otherwise, this field indicates the number of days ahead for which the data is being cancelled.
     days: int = attr(default=1, name="NumOfDays", ge=1, le=31)

mms_client/types/offer.py

@@ -1,19 +1,19 @@
 """Contains objects for MMS offers."""
 
 from decimal import Decimal
-from enum import Enum
 from typing import List
 from typing import Optional
 
-from pydantic_core import PydanticUndefined
 from pydantic_extra_types.pendulum_dt import DateTime
 from pydantic_xml import attr
 from pydantic_xml import element
 
 from mms_client.types.base import Payload
 from mms_client.types.enums import AreaCode
+from mms_client.types.enums import Direction
 from mms_client.types.fields import company_short_name
 from mms_client.types.fields import dr_patter_number
+from mms_client.types.fields import offer_id
 from mms_client.types.fields import operator_code
 from mms_client.types.fields import participant
 from mms_client.types.fields import power_positive
@@ -24,34 +24,6 @@ from mms_client.types.fields import system_code
 from mms_client.types.market import MarketType
 
 
-def offer_id(alias: str, optional: bool = False):
-    """Create a field for an offer ID.
-
-    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 offer ID.
-    """
-    return attr(
-        default=None if optional else PydanticUndefined,
-        name=alias,
-        min_length=1,
-        max_length=30,
-        pattern=r"^[a-zA-Z0-9_-]*$",
-    )
-
-
-class Direction(Enum):
-    """Represents the reserve direction of the offer."""
-
-    SELL = "1"  # Increasing the reserves (sell)
-    # Note: Support for the BUY direction was removed from the MMS API
-    # BUY = "2"  # Decreasing the reserves (buy)
-
-
 class OfferStack(Payload):
     """Represents a single price-quantity pair in an offer request.
 
@@ -94,7 +66,7 @@ class OfferStack(Payload):
     tertiary_2_qty_kw: Optional[int] = power_positive("Tertiary2OfferQuantityInKw", True)
 
     # The unit price of the power, in JPY/kW/segment
-    unit_price: Decimal = price("OfferUnitPrice")
+    unit_price: Decimal = price("OfferUnitPrice", 10000.00)
 
     # The ID of the offer to which this stack belongs
     id: Optional[str] = offer_id("OfferId", True)

mms_client/types/resource.py

@@ -16,7 +16,10 @@ from pydantic_xml import wrapped
 
 from mms_client.types.base import Payload
 from mms_client.types.enums import AreaCode
+from mms_client.types.enums import BooleanFlag
+from mms_client.types.enums import CommandMonitorMethod
 from mms_client.types.enums import Frequency
+from mms_client.types.enums import ResourceType
 from mms_client.types.fields import ASCII_TEXT
 from mms_client.types.fields import JAPANESE_ASCII_TEXT
 from mms_client.types.fields import JAPANESE_TEXT
@@ -180,18 +183,6 @@ class ContractType(Enum):
     REMAINING_RESERVE_UTILIZATION = "6"
 
 
-class ResourceType(Enum):
-    """How the power generation unit produces electricity."""
-
-    THERMAL = "01"
-    HYDRO = "02"
-    PUMP = "03"
-    BATTERY = "04"
-    VPP_GEN = "05"
-    VPP_GEN_AND_DEM = "06"
-    VPP_DEM = "07"
-
-
 class RemainingReserveAvailability(Enum):
     """Describes the availability of remaining reserves for a power generation unit."""
 
@@ -201,14 +192,6 @@ class RemainingReserveAvailability(Enum):
     AVAILABLE_FOR_UP_AND_DOWN = "3"
 
 
-class CommandMonitorMethod(Enum):
-    """Describes how the power generation unit is monitored and commanded."""
-
-    DEDICATED_LINE = "1"
-    SIMPLE_COMMAND = "2"
-    OFFLINE = "3"
-
-
 class SignalType(Enum):
     """Describes the type of signal used to monitor and command a power generation unit."""
 
@@ -231,17 +214,6 @@ class ThermalType(Enum):
     OTHER = "9"
 
 
-class BooleanFlag(Enum):
-    """Describes a boolean flag.
-
-    This could literally be a Boolean value but it's coded in the reference as an enum and I don't want to create a
-    custom serializer for it.
-    """
-
-    YES = "1"
-    NO = "0"
-
-
 class OverrideOption(Enum):
     """Describes the override option for a power generation unit."""
 
@@ -761,7 +733,7 @@ class ResourceData(Payload, tag="Resource"):
     has_contract: Optional[BooleanFlag] = attr(default=None, name="ContractExistence")
 
     # The maximum bid price for POWER_SUPPLY_1 power, in JPY/kW/hr
-    declared_maximum_unit_price_kWh: Annotated[Decimal, price("DeclaredMaximumUnitPrice", True)]
+    declared_maximum_unit_price_kWh: Annotated[Decimal, price("DeclaredMaximumUnitPrice", 10000.00, True)]
 
     # Presence of voltage regulation function.
     voltage_adjustable: Optional[BooleanFlag] = attr(default=None, name="VoltageAdjustment")

mms_client/types/transport.py

@@ -25,7 +25,7 @@ class RequestType(Enum):
 class RequestDataType(Enum):
     """Represents the type of data to be sent to the MMS server.
 
-    Note that JSON is currently not supported and has been left in for future use.
+    NOTE: JSON is currently not supported and has been left in for future use.
     """
 
     JSON = "JSON"
@@ -35,7 +35,7 @@ class RequestDataType(Enum):
 class ResponseDataType(Enum):
     """Represents the type of data to be received from the MMS server.
 
-    Note that JSON is currently not supported and has been left in for future use.
+    NOTE: JSON is currently not supported and has been left in for future use.
     """
 
     XML = "XML"

mms_client/utils/serialization.py

@@ -4,6 +4,7 @@ from functools import lru_cache
 from io import BytesIO
 from pathlib import Path
 from typing import Dict
+from typing import List
 from typing import Optional
 from typing import Tuple
 from typing import Type
@@ -15,6 +16,7 @@ from lxml.etree import XMLSchema
 from lxml.etree import _Element as Element
 from lxml.etree import parse
 from pydantic_xml import element
+from pydantic_xml.typedefs import EntityLocation
 
 from mms_client.types.base import E
 from mms_client.types.base import Messages
@@ -62,17 +64,42 @@ class Serializer:
         # First, create our payload class from the payload and data types
         payload_cls = _create_request_payload_type(
             self._payload_key,
-            type(request_envelope),  # type: ignore[arg-type]
-            type(request_data),  # type: ignore[arg-type]
+            type(request_envelope),
+            type(request_data),
+            False,  # type: ignore[arg-type]
         )
 
         # Next, inject the payload and data into the payload class
-        # Note: this returns a type that inherits from PayloadBase and the arguments provided to the initializer
+        # NOTE: this returns a type that inherits from PayloadBase and the arguments provided to the initializer
         # here are correct, but mypy thinks they are incorrect because it doesn't understand the the inherited type
         payload = payload_cls(request_envelope, request_data, self._xsd.value)  # type: ignore[call-arg, misc]
 
         # Finally, convert the payload to XML and return it
-        # Note: we provided the encoding here so this will return bytes, not a string
+        # NOTE: we provided the encoding here so this will return bytes, not a string
+        return payload.to_xml(skip_empty=True, encoding="utf-8", xml_declaration=True)  # type: ignore[return-value]
+
+    def serialize_multi(self, request_envelope: E, request_data: List[P], request_type: Type[P]) -> bytes:
+        """Serialize the envelope and data to a byte string for sending to the MMS server.
+
+        Arguments:
+        request_envelope (Envelope):    The envelope to be serialized.
+        request_data (List[Payload]):    The data to be serialized.
+        request_type (Type[Payload]):    The type of data to be serialized.
+
+        Returns:    A byte string containing the XML-formatted data to be sent to the MMS server.
+        """
+        # First, create our payload class from the payload and data types
+        payload_cls = _create_request_payload_type(
+            self._payload_key, type(request_envelope), request_type, True  # type: ignore[arg-type]
+        )
+
+        # Next, inject the payload and data into the payload class
+        # NOTE: this returns a type that inherits from PayloadBase and the arguments provided to the initializer
+        # here are correct, but mypy thinks they are incorrect because it doesn't understand the the inherited type
+        payload = payload_cls(request_envelope, request_data, self._xsd.value)  # type: ignore[call-arg, misc]
+
+        # Finally, convert the payload to XML and return it
+        # NOTE: we provided the encoding here so this will return bytes, not a string
         return payload.to_xml(skip_empty=True, encoding="utf-8", xml_declaration=True)  # type: ignore[return-value]
 
     def deserialize(self, data: bytes, envelope_type: Type[E], data_type: Type[P]) -> Response[E, P]:
@@ -164,7 +191,7 @@ class Serializer:
 
         # Now, verify that the response doesn't contain an unexpected data type and then retrieve the payload data
         # from within the envelope
-        # Note: apparently, mypy doesn't know about setter-getter properties either...
+        # NOTE: apparently, mypy doesn't know about setter-getter properties either...
         self._verify_tree_data_tag(env_node, data_type)
         resp.payload = [
             self._from_tree_data(item, data_type) for item in env_node.findall(get_tag(data_type))  # type: ignore[misc]
@@ -245,7 +272,13 @@ class Serializer:
         )
 
     def _from_tree_messages(
-        self, raw: Element, envelope_type: Type[E], current_type: Type[P], root: str, multi: bool
+        self,
+        raw: Element,
+        envelope_type: Type[E],
+        current_type: Type[P],
+        root: str,
+        multi: bool,
+        wrapped: bool = False,
     ) -> Dict[str, Messages]:
         """Attempt to extract the messages from within the payload.
 
@@ -261,6 +294,7 @@ class Serializer:
         multi (bool):                   Whether we're processing a list of nodes or a single node. If called with the
                                         payload root, this value will determine whether we're processing a multi-
                                         response or a single response.
+        wrapped (bool):                 Whether or not this type is referenced from a wrapped field.
         """
         # First, find the Messages node in the raw data
         message_node = raw.find("Messages")
@@ -283,40 +317,41 @@ class Serializer:
                     current_type,
                     f"{root}.{envelope_type.__name__}",
                     multi,
+                    False,
                 )
             )
-        elif root.endswith(envelope_type.__name__):
+        elif root.endswith(envelope_type.__name__) or wrapped:
             messages.update(
-                self._from_tree_messages_inner(raw, envelope_type, current_type, root, current_type.__name__, multi)
+                self._from_tree_messages_inner(
+                    raw, envelope_type, current_type, root, get_tag(current_type), multi, False
+                )
             )
         else:
             # Iterate over each field on the current type...
             for field in current_type.model_fields.values():
 
-                # First, get the arguments and origin of the field's annotation
-                args = get_args(field.annotation)
-                origin = get_origin(field.annotation)
-                has_args = len(args) > 0
+                # First, get the arguments and origin of the field's annotation. Occaisionally, we'll have an optional
+                # list. In this case, we'll have to do get_args twice to traverse the type tree.
+                arg, multi = _get_field_typing(field.annotation)  # type: ignore[arg-type]
 
                 # Next, check if the annotation is a subclass of Payload or else if it's a collection of Payload. If
                 # neither of these is the case, we can skip this field.
-                # Note: all our fields are annotated so there's no need to check if they're not
-                if not (
-                    (has_args and issubclass(args[0], Payload))
-                    or (not has_args and issubclass(field.annotation, Payload))  # type: ignore[arg-type]
-                ):
+                # NOTE: All our fields are annotated so there's no need to check if they're not
+                if not issubclass(arg, Payload):
                     continue
 
                 # Finally, call this method recursively for the field and update the messages with the results
-                # Note: All our fields are annotated as XmlEntityInfo, so they have the "path" attribute
+                # NOTE: All our fields are annotated as XmlEntityInfo, so they have the "path" and "location" attributes
+                print(field)
                 messages.update(
                     self._from_tree_messages_inner(
                         raw,
                         envelope_type,
-                        args[0],
+                        arg,
                         root,
                         field.path,  # type: ignore[attr-defined]
-                        origin is list,
+                        multi,
+                        field.location == EntityLocation.WRAPPED,  # type: ignore[attr-defined]
                     )
                 )
 
@@ -324,7 +359,14 @@ class Serializer:
         return messages
 
     def _from_tree_messages_inner(
-        self, raw: Element, envelope_type: Type[E], current_type: Type[P], root: str, tag: str, multi: bool
+        self,
+        raw: Element,
+        envelope_type: Type[E],
+        current_type: Type[P],
+        root: str,
+        tag: str,
+        multi: bool,
+        wrapped: bool,
     ) -> Dict[str, Messages]:
         """Attempt to extract the messages from within the payload at the current level.
 
@@ -336,6 +378,7 @@ class Serializer:
         tag (str):                      The tag of the current node being processed.
         multi (bool):                   If True, the payload will be a multi-response; otherwise, it will be a single
                                         response.
+        wrapped (bool):                 Whether or not this field is a wrapped field.
 
         Returns:    A dictionary mapping messages to where they were found in the response.
         """
@@ -353,12 +396,20 @@ class Serializer:
             # Otherwise, we'll call this method recursively for each node and update the messages with the results.
             messages = {}
             for i, node in enumerate(nodes):
-                messages.update(self._from_tree_messages(node, envelope_type, current_type, f"{path_base}[{i}]", True))
+                messages.update(
+                    self._from_tree_messages(
+                        node, envelope_type, current_type, path_base if wrapped else f"{path_base}[{i}]", True, wrapped
+                    )
+                )
             return messages
 
         # If we reached this point then we are processing a single item so find the associated
         child = raw.find(tag)
-        return {} if child is None else self._from_tree_messages(child, envelope_type, current_type, path_base, False)
+        return (
+            {}
+            if child is None
+            else self._from_tree_messages(child, envelope_type, current_type, path_base, False, wrapped)
+        )
 
     def _from_xml(self, data: bytes) -> Element:
         """Parse the XML file, returning the resulting XML tree.
@@ -439,7 +490,12 @@ def _create_response_common_type(tag_type: Type[Union[E, P]]) -> Type[ResponseCo
 
 
 @lru_cache(maxsize=None)
-def _create_request_payload_type(key: str, envelope_type: Type[E], data_type: Type[P]) -> Type[PayloadBase]:
+def _create_request_payload_type(
+    key: str,
+    envelope_type: Type[E],
+    data_type: Type[Union[P, List[P]]],
+    multi: bool,
+) -> Type[PayloadBase]:
     """Create a new payload type for the given payload and data types.
 
     This method is intended to save us the overhead of writing a new class for each payload type. Instead, we can
@@ -453,17 +509,21 @@ def _create_request_payload_type(key: str, envelope_type: Type[E], data_type: Ty
     key: str                        The tag to use for the parent element of the payload.
     envelope_type (Type[Envelope]): The type of payload to be constructed.
     data_type (Type[Payload]):      The type of data to be constructed.
+    multi (bool):                   If True, the payload will be a list; otherwise, it will be a singleton.
 
     Returns:    A new payload type that can be used for serialization.
     """  # fmt: skip
-    # First, create a wrapper for our data type that will be used to store the data in the payload
+    # First, create our data type
+    payload_type = List[data_type] if multi else data_type  # type: ignore[valid-type]
+
+    # Next, create a wrapper for our data type that will be used to store the data in the payload
     class Envelope(envelope_type):  # type: ignore[valid-type, misc]
         """Wrapper for the data type that will be used to store the data in the payload."""
 
         # The data to be stored in the payload
-        data: data_type = element(tag=get_tag(data_type))  # type: ignore[valid-type]
+        data: payload_type = element(tag=get_tag(data_type))  # type: ignore[valid-type, type-var]
 
-        def __init__(self, envelope: envelope_type, data: data_type):  # type: ignore[valid-type]
+        def __init__(self, envelope: envelope_type, data: payload_type):  # type: ignore[valid-type]
             """Create a new envelope to store payload data.
 
             Arguments:
@@ -474,14 +534,14 @@ def _create_request_payload_type(key: str, envelope_type: Type[E], data_type: Ty
             obj["data"] = data
             super().__init__(**obj)
 
-    # Next, create our payload type that actually contains all the XML data
+    # Now, create our payload type that actually contains all the XML data
     class RQPayload(PayloadBase, tag=key):  # type: ignore[call-arg]
         """The payload type that will be used for serialization."""
 
         # The payload containing our request object and any data
         envelope: Envelope = element(tag=envelope_type.__name__)
 
-        def __init__(self, envelope: envelope_type, data: data_type, schema: str):  # type: ignore[valid-type]
+        def __init__(self, envelope: envelope_type, data: payload_type, schema: str):  # type: ignore[valid-type]
             """Create a new payload containing the request object and any data.
 
             Arguments:
@@ -512,6 +572,45 @@ def _find_or_fail(node: Element, tag: str) -> Element:
     return found
 
 
+def _get_field_typing(typ: Type) -> Tuple[Type, bool]:
+    """Retrieve the field's actual type and whether or not the field is a collection.
+
+    This method is designed to find the inner type of fields in the following cases:
+    1. Fundamental types and classes (e.g. int, str, Award, Offer, etc.)
+    2. Nullable fundamental types and classes
+    3. Collections of fundamental types and classes
+    4. Nullable collections of fundamental types and classes
+
+    Arguments:
+    typ (Type): The type of the field to retrieve the inner type for.
+
+    Returns:
+    Type:   The inner type of the field.
+    bool:   Whether or not the field is a collection.
+    """
+    # First, check for the case where we have a fundamental type. If we do then we can return the type and False.
+    init = get_args(typ)
+    if len(init) == 0:
+        return typ, False
+
+    # Next, iterate over the type hierarchy and repeat the operation until we find the leaf type.
+    args = [get_args(typ)]
+    while len(args[-1]) > 1:
+        temp = get_args(args[-1][0])
+        if len(temp) == 0:
+            break
+        args.append(temp)
+
+    # Now, find the origin type of the field. This will be the lowest type in the hierarchy that isn't a multi-type.
+    # If there aren't any of these, then we'll just use the original type.
+    origin_type = next(
+        filter(lambda x: x is not None, map(lambda arg: arg[0] if len(arg) > 1 else None, reversed(args))), typ
+    )
+
+    # Finally, return the inner type and whether or not the origin type is a list
+    return args[-1][0] if len(args) > 0 else typ, get_origin(origin_type) is list  # typing: ignore[return-value]
+
+
 def get_tag(data_type: Type[P]) -> str:
     """Get the tag for the given data type.
 

{mms_client-1.1.0.dist-info → mms_client-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mms-client
-Version: 1.1.0
+Version: 1.3.0
 Summary: API client for accessing the MMS
 Home-page: https://github.com/ElectroRoute-Japan/mms-client
 Author: Ryan Wood
@@ -198,6 +198,7 @@ This client is not complete. Currently, it supports the following endpoints:
 - MarketSubmit_OfferData
 - MarketQuery_OfferQuery
 - MarketCancel_OfferCancel
+- MarketQuery_AwardResultsQuery
 - RegistrationSubmit_Resource
 - RegistrationQuery_Resource
 

{mms_client-1.1.0.dist-info → mms_client-1.3.0.dist-info}/RECORD

@@ -12,25 +12,26 @@ mms_client/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 mms_client/security/certs.py,sha256=kNCUFmy18YIxkWKu3mdMmlxmHdft4a6BvtyJ46rA9I4,1489
 mms_client/security/crypto.py,sha256=M7aIllM3_ZwZgm9nH6QQ6Ig14XCAd6e6WGwqqUbbI1Q,2149
 mms_client/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mms_client/services/base.py,sha256=8yWBeDoBimY9BZeMOkMDV-ggvPTzZHnlqXiv9eo8fIQ,25363
-mms_client/services/market.py,sha256=kwcbXz1Op4hwXbOn_Xsx_qBNuHfvWAxBH6G2f4AWzPI,4892
+mms_client/services/base.py,sha256=mcUL-AZpaJETVkzAOoazmKfI5O3cJ0KWzIYQ5bjpNuE,25839
+mms_client/services/market.py,sha256=aIWi52BFvDmtuipKnSZNprwbFYGYBcV6sZCQqMR_D2g,7574
 mms_client/services/omi.py,sha256=h6cM5U3-iSm0YiIaJwqYTZeI5uhLbA7FPxh_qy_3qww,521
-mms_client/services/registration.py,sha256=9pNZdgwRbJJCnmsVgESNnc3ywkn-wdQryumUhLn6Xvg,3419
+mms_client/services/registration.py,sha256=46Scntwlc9CtCO-tV6uEnr4NrVGJiUqhvksII13CGAE,3651
 mms_client/services/report.py,sha256=HYVJNwEHo6ZC6497UqO5y1IqZ2ga3kVH5AepdxhYfug,537
 mms_client/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mms_client/types/award.py,sha256=BWE9V_KHXpg_cW1LZsetVrPs2hZDOklvRpNnoZtmR3k,14139
 mms_client/types/base.py,sha256=wrDPn9io30in_w2qKa4A503gX_gAaMT7a1MpZ3HcmIc,9701
-mms_client/types/enums.py,sha256=wXlXvifWXWm9dowfG5iQlkax_6OX6z2nHid94WkhQwE,464
-mms_client/types/fields.py,sha256=SAvrDJGSvOVtbGvaaqLFBx2mCr0AxzqVFUTJgPSEDOY,12065
-mms_client/types/market.py,sha256=OKjBIx9aIgaLUci6b5WoB4NZbFncRbbd2FxeAvW1iWw,2588
-mms_client/types/offer.py,sha256=orlohxAWZlW2rwPJpGAoiy1knoCT2x2sXJyzThkXYVY,7693
+mms_client/types/enums.py,sha256=YJ58FbhyQ0TVlf8Z-Dg1UfVu8CurY5b21Cy5-WYkJ0I,1629
+mms_client/types/fields.py,sha256=pa5qvQVwEr8dh44IGHyYqgJYTYyTIeAjBW6CylXrkP0,14785
+mms_client/types/market.py,sha256=IbXsH4Q5MJI-CEvGvZlzv2S36mX_Ea02U11Ik-NwSxQ,2706
+mms_client/types/offer.py,sha256=KosFiKRMnt7XwlLBUfjHUGHiWzrMJUPPhGQMxgdeepM,6791
 mms_client/types/registration.py,sha256=Nir73S3ffpk0O_fnTD2alFaqV1k67_8dcyyduXvPBI4,1381
-mms_client/types/resource.py,sha256=_pRNAqOX8A0lUXmU8qO_8QwRtRx9BwZDdrN-w_Fnu38,66466
-mms_client/types/transport.py,sha256=vyosoeGSdYthqlmiyDAkZusYa8yVHUwOzfTqwZne2Ik,4407
+mms_client/types/resource.py,sha256=TQnY3JLHRgQhQrG6ISquw-BQgKSr8TGuqn9ItWxWz_w,65974
+mms_client/types/transport.py,sha256=DPjWs34UW915GkUCJWKuDZmsjS6mRdRXgcGISduN_Bc,4399
 mms_client/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mms_client/utils/errors.py,sha256=jYdlG4OPI82s0fJcXCRNlKeEixDUSSAxjs_7C16qVL4,2306
-mms_client/utils/serialization.py,sha256=7DW-xD89DNukcwk6rgS4eBHsMP5kBdiwkvVM4kv2_F8,25438
+mms_client/utils/serialization.py,sha256=vTJZSjhfTph2tDAYbLAhnz89i0qXJ8FINGdve67cJOU,29534
 mms_client/utils/web.py,sha256=fcdCtdDrHBPyhIlTcyiuAk3D3TlW8HmUw-wGfpG4KTA,9653
-mms_client-1.1.0.dist-info/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
-mms_client-1.1.0.dist-info/METADATA,sha256=jb3k6RPJGTpxMiIAaJTKzGfZcgoEgrrxeOPNrSoRoUM,14742
-mms_client-1.1.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-mms_client-1.1.0.dist-info/RECORD,,
+mms_client-1.3.0.dist-info/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+mms_client-1.3.0.dist-info/METADATA,sha256=7yCFpQBubFp8jx3Nd90fj0wfXwSiNIywKd61wV798qE,14774
+mms_client-1.3.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+mms_client-1.3.0.dist-info/RECORD,,