mms-client 1.0.5__py3-none-any.whl

mms_client/utils/web.py

@@ -0,0 +1,220 @@
+"""Contains the HTTP/web layer for communicating with the MMS server."""
+
+from enum import Enum
+from logging import Logger
+from pathlib import Path
+
+from backoff import expo
+from backoff import on_exception
+from requests import Session
+from requests_pkcs12 import Pkcs12Adapter
+from zeep import Client
+from zeep import Transport
+from zeep.cache import SqliteCache
+from zeep.exceptions import TransportError
+from zeep.xsd.valueobjects import CompoundValue
+
+from mms_client.types.transport import MmsRequest
+from mms_client.types.transport import MmsResponse
+
+
+class ClientType(Enum):
+    """Identifies the type of client to use.
+
+    The client can be either "bsp" (Balancing Service Provider) or "tso" (Transmission System Operator).
+    """
+
+    BSP = "bsp"
+    TSO = "tso"
+
+
+class Interface(Enum):
+    """Identifies the type of interface to use.
+
+    The interface can be either "omi" (Other Market Initiator) or "mi" (Market Initiator).
+    """
+
+    OMI = "omi"
+    MI = "mi"
+
+
+class ServiceEndpoint:
+    """Represents the endpoints for the main, backup, and test servers for a given web service."""
+
+    def __init__(self, main: str, backup: str, test: str):
+        """Create a new service endpoint with the given main, backup, and test URLs.
+
+        This object is meant to obfuscate the service endpoint so that the web client can automatically switch between
+        the main and backup endpoints in case of an error. Alternatively, this allows the client to switch to the test
+        endpoint for testing purposes.
+        """
+        self.main = main
+        self.backup = backup
+        self.test = test
+        self._selected = self.main
+
+    @property
+    def selected(self) -> str:
+        """Return the currently selected URL."""
+        return self._selected
+
+    def select(self, error: bool = False, test: bool = False):
+        """Select the main, backup, or test URL based on the given parameters.
+
+        Arguments:
+        error (bool):   If True, select the backup URL.
+        test (bool):    If True, select the test URL.
+        """
+        if error:
+            self._selected = self.backup
+        elif test:
+            self._selected = self.test
+        else:
+            self._selected = self.main
+
+
+# Defines the service endpoints for the BSP and TSO clients for the OMI and MI web services, respectively.
+URLS = {
+    ClientType.BSP: {
+        Interface.OMI: ServiceEndpoint(
+            main="https://www5.tdgc.jp/axis2/services/OmiWebService",
+            backup="https://www6.tdgc.jp/axis2/services/OmiWebService",
+            test="https://www7.tdgc.jp/axis2/services/OmiWebService",
+        ),
+        Interface.MI: ServiceEndpoint(
+            main="https://www2.tdgc.jp/axis2/services/MiWebService",
+            backup="https://www3.tdgc.jp/axis2/services/MiWebService",
+            test="https://www4.tdgc.jp/axis2/services/MiWebService",
+        ),
+    },
+    ClientType.TSO: {
+        Interface.OMI: ServiceEndpoint(
+            main="https://maiwlba103v07.tdgc.jp/axis2/services/OmiWebService",
+            backup="https://mbiwlba103v07.tdgc.jp/axis2/services/OmiWebService",
+            test="https://mbiwlba103v08.tdgc.jp/axis2/services/OmiWebService",
+        ),
+        Interface.MI: ServiceEndpoint(
+            main="https://maiwlba103v03.tdgc.jp/axis2/services/MiWebService",
+            backup="https://mbiwlba103v03.tdgc.jp/axis2/services/MiWebService",
+            test="https://mbiwlba103v06.tdgc.jp/axis2/services/MiWebService",
+        ),
+    },
+}
+
+
+# The original service binding names, to be mapped to our actual endpoints
+SERVICE_BINDINGS = {
+    Interface.MI: "{urn:abb.com:project/mms}MiWebServiceSOAP",
+    Interface.OMI: "{urn:ws.web.omi.co.jp}OmiWebServiceSOAP",
+}
+
+
+def fatal_code(e: TransportError) -> bool:
+    """Return True if the given exception is a fatal HTTP error code.
+
+    Arguments:
+    e (RequestException):   The exception to check.
+    """
+    return 400 <= e.status_code < 500
+
+
+class ZWrapper:
+    """Wrapper for the Zeep client that handles the HTTP/web layer for communicating with the MMS server.
+
+    Note that this is the lowest layer of the client, and is only responsible for handing off the final request to the
+    Zeep client. This class is meant to be used by the higher-level client classes that take in the actual request and
+    return the actual response.
+    """
+
+    def __init__(
+        self,
+        client: ClientType,
+        interface: Interface,
+        adapter: Pkcs12Adapter,
+        logger: Logger,
+        cache: bool = True,
+        test: bool = False,
+    ):
+        """Create a new Zeep wrapper object for a specific MMS service endpoint.
+
+        Arguments:
+        client (ClientType):        The type of client to use. This can be either "bsp" (Balancing Service Provider) or
+                                    "tso" (Transmission System Operator). This will determine which service endpoint to
+                                    use.
+        interface (Interface):      The type of interface to use. This can be either "omi" (Other Market Initiator) or
+                                    "mi" (Market Initiator). This will determine which service endpoint to use as well
+                                    as the service and port to use.
+        adapter (Pkcs12Adapter):    The PKCS12 adapter containing the certificate and private key to use for
+                                    authenticating with the MMS server.
+        logger (Logger):            The logger to use for instrumentation.
+        cache (bool):               If True, use a cache for the Zeep client. This is useful for avoiding repeated
+                                    lookups of the WSDL file, which should result in lower latency.
+        test (bool):                If True, use the test service endpoint. This is useful for testing the client.
+        """
+        # First, we'll check that the client is valid. If it's not, we'll raise a ValueError.
+        if client not in URLS:
+            raise ValueError(f"Invalid client, '{client}'. Only 'bsp' and 'tso' are supported.")
+
+        # We need to determine the service port and location of the WSDL file based on the given interface. If the
+        # interface is neither "omi" nor "mi", we raise a ValueError.
+        self._interface = interface
+        if self._interface == Interface.MI:
+            location = Path(__file__).parent.parent / "schemas" / "wsdl" / "mi-web-service-jbms.wsdl"
+        elif self._interface == Interface.OMI:
+            location = Path(__file__).parent.parent / "schemas" / "wsdl" / "omi-web-service.wsdl"
+        else:
+            raise ValueError(f"Invalid interface, '{self._interface}'. Only 'mi' and 'omi' are supported.")
+
+        # Next, we need to select the correct service endpoint based on the given client and interface.
+        self._endpoint = URLS[client][self._interface]
+        self._endpoint.select(test=test)
+
+        # Now, we need to create a new session and mount the PKCS12 adapter to it. This is necessary for
+        # authenticating with the MMS server. Note, that if we are not in test mode, we also need to mount the
+        # PKCS12 adapter to the backup endpoint to make sure we can switch between the main and backup endpoints in
+        # case of an error.
+        sess = Session()
+        sess.mount(self._endpoint.selected, adapter)
+        if not test:
+            sess.mount(self._endpoint.backup, adapter)
+
+        # Finally, we create the Zeep client with the given WSDL file location, session, and cache settings and then,
+        # from that client, we create the SOAP service with the given service binding and selected endpoint.
+        self._logger = logger
+        self._client = Client(
+            wsdl=str(location.resolve()),
+            transport=Transport(cache=SqliteCache() if cache else None, session=sess),
+        )
+        self._create_service()
+
+    @on_exception(expo, TransportError, max_tries=3, giveup=fatal_code)  # type: ignore[arg-type]
+    def submit(self, req: MmsRequest) -> MmsResponse:
+        """Submit the given request to the MMS server and return the response."""
+        try:
+            self._logger.debug(f"Submitting MMS request request to {self._interface.name} service")
+
+            # Submit the request to the MMS server and retrieve the response
+            resp: CompoundValue = self._service["submitAttachment"](**req.to_arguments())
+
+            # Validate the response and return it
+            return MmsResponse.model_validate(resp.__values__)
+        except TransportError as e:
+            # If we got a server fault error, then we'll switch to the backup endpoint. In any case, we'll raise the
+            # exception so that our back-off can handle it or pass the exception up the stack.
+            self._logger.error(
+                f"MMS request to {self._interface.name} service failed with status code: {e.status_code}",
+                exc_info=e,
+            )
+            if e.status_code >= 500:
+                self._logger.warning(f"MMS server error, switching to backup endpoint: {self._endpoint.backup}")
+                self._endpoint.select(error=True)
+                self._create_service()
+            raise
+
+    def _create_service(self):
+        """Create a new SOAP service with the currently selected endpoint.
+
+        This is useful for switching between the main and backup endpoints in case of an error.
+        """
+        self._logger.debug(f"Creating new {self._interface.name} service with endpoint: {self._endpoint.selected}")
+        self._service = self._client.create_service(SERVICE_BINDINGS[self._interface], self._endpoint.selected)

mms_client-1.0.5.dist-info/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

mms_client-1.0.5.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.1
+Name: mms-client
+Version: 1.0.5
+Summary: API client for accessing the MMS
+Author: Ryan Wood
+Author-email: ryan.wood@electroroute.co.jp
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: backoff (>=2.2.1,<3.0.0)
+Requires-Dist: cryptography (>=42.0.5,<43.0.0)
+Requires-Dist: lxml (>=5.1.0,<6.0.0)
+Requires-Dist: pendulum (>=3.0.0,<4.0.0)
+Requires-Dist: pydantic (>=2.6.3,<3.0.0)
+Requires-Dist: pydantic-xml (>=2.9.0,<3.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: requests-pkcs12 (>=1.24,<2.0)
+Requires-Dist: xmlschema (>=3.0.2,<4.0.0)
+Requires-Dist: zeep (>=4.2.1,<5.0.0)
+Description-Content-Type: text/markdown
+
+[![Unit Tests Status](https://github.com/ElectroRoute-Japan/mms-client/actions/workflows/check.yml/badge.svg)](https://github.com/ElectroRoute-Japan/mms-client/actions)
+
+# Overview
+This repository contains a Python client that is capable of communication with the Market Management System (MMS), which handles requests related to Flex or Virtual Power Plant (VPP) trading. The underlying library is relies on SOAP communication, which is a pain to work with at the best of times. This particular SOAP API adds its own special layer of obnoxiousness, however. As such, it was deemed useful to have a client which would obfuscate most, if not all of this away from the user.
+
+# Communication
+The underlying API sends and receives XML documents. Each of these request or responses, which we will hereafter refer to as *outer* requests and responses, contains metadata about the request/response as well as three fields which are extremely important to successful communication with the API:
+- Attachments data, included as a list of elements with the binary data in a base-64 encoded format
+- Payload data, encoded in a base-64 encoded format
+- Payload signature, which is the SHA256 hash of the payload XML data, then signed with an RSA key, in a base-64 encoded format
+
+After the data has been converted and added to the outer request object, it is sent to the appropriate server endpoint via a Zeep client. The client certificate is also injected into the request using a PCKS12 adaptor.
+
+## Client Types
+Clients cannot call any and all endpoints in this API, willy-nilly. Some endpoints are restricted to particular clients. At the moment, there are two clients: Balance Service Providers (BSPs) and Transmission Service Operators (TSOs). Most likely you're operating as a BSP, in which case you'll have access to all endpoints. However, it makes little sense for a TSO to be able to submit bids on their own power, so they are restricted to a read-only role in most cases.
+
+Should you request an endpoint which you are not authorized for, you will receive an `mms_client.utils.errors.AudienceError`.
+
+## Interface Type
+The MMS has two separate endpoints, depending on whether you want to access market information (MI), or other market information (OMI). Really informative, I know. Fortunately, we have designed this API in such a way that the distinction around which interface is which is unnecessary for you to know. However, note that separate Zeep clients will be maintained for each interface. These will be created as needed, which endpoints requiring the associated interface are first called. These are both setup to cache schemas to improve performance, as well. The memory required for these clients is still light, but you may want to reduce that further based on your application.
+
+# Object Hierarchy
+The object hierarchy contained in this project is not trivial, and perhaps that reflects a bit of overengineering on our part. However, we chose the paradigm we did to reduce the number of types which had to be exposed to the user. The diagram below indicates how this hierarchy works:
+
+![MMS Client Object Hierarchy](/docs/mmsclient_hierarchy.drawio.png)
+
+Note that there are some types here that are shared between the request and response: mainly, anything inheriting from `mms_client.types.base.Envelop` or `mms_client.types.base.Payload`. For users of the client, only the Payload types need ever be used. Everything else has been obfuscated away, so it is unecessary for the user to have access to these. However, we will explain our reasoning here to provide additional context.
+
+## Requests
+The primary request DTO is the `mms_client.types.transport.MmsRequest` object. The majority of the fields here are metadata specifying how the client should communicate with the MMS server. However, `requestData`, `requestSignature` and `attachmentData` do bear considering as these represent the actual request, a signature used to verify that the request was received, and any attachments to the request, respectively. As mentioned before, `requestData` and `attachementData` can each represent more complex objects, which should be serialized and then encoded as base-64 strings.
+
+## Responses
+The primary response DTO is the `mms_client.types.transport.MmsResponse` object. Similar to the request DTO, this object includes a number of fields containing metadata describing how the response should be interpretted. Currently, only uncompressed XML is supported and any other response type will result in an `mms_client.utils.errors.MmsClientError`. Again, the `requestData` and `attachmentData` fields contain the payload data, encoded as base-64 strings.
+
+### BaseResponse
+This object represents the top-level XML element contained within the `MmsResponse`. It contains all other response data. Note that the structure of this object will not mimic the structure of the XML response, as that structure is incompatible with the philosophy of this library. However, all the information has been preserved. This type contains a number of validation elements as well as the envelope.
+
+### Response & MultiResponse
+These objects contain the actual payload data and inherit from `BaseResponse`. These are what will actually be returned from the deserialization process. They also contain validation data for the top-level paylaod item(s). The difference between `Response` and `MultiResponse` is that the former contains a single item and the latter contains a list.
+
+## Envelopes
+Not to be confused with the SOAP envelope, this envelope contains the method parameters used to send requests to the MMS server. For example, if you wanted to send a market-related request, this would take on the form of a `MarketQuery`, `MarketSubmit` or `MarketCancel` object. This is combined with the payload during the serialization process to produce the final XML payload before injecting it into the `MmsRequest`. During the deserialization process, this is extracted from the XML paylod on the `MmsResponse` object. Each of these should inherit from `mms_client.types.base.Envelope`.
+
+## Payloads
+This is the actual data that is sent to and returned from client methods and represent the actual "data", as contained on the MMS server. As such, these represent the first-class objects within this library. During the serialization process, this data is inserted into the envelope before being serialized to XML. During the deserialization process, these objects are extracted from the envelope XML and converted to the object therein. Each of these should inherit from `mms_client.types.base.Payload`. Note, however, that not everything that inherits from this class will represent a top-level object.
+
+## Validation
+There are a number of validation objects returned with the response, each with its own purpose. Any case resulting in a validation failure will cause an `mms_client.utils.errors.MMSValidationError` to be raised.
+
+### ProcessingStatistics
+This object describes the number of items in the request that were received, the number of valid items, the number of invalid items, the number of items successfully and unsuccessfully returned, respectively. This object also features some information on the latency and receipt time of the request. Given how the MMS determines the values of these fields, this client will check that there are no invalid files and raise an exception otherwise.
+
+### ResponseCommon
+This object can be found on the envelope and top-level payload object(s) within the response. It contains a success flag and a value describing whether or not validation passed. If `success` is True, then `validation` should be either "PASSED" or "NOT_DONE". Any other status indicates a failure and will result in an exception.
+
+### Messages
+Each Payload object will have a collection of messages. These are organized into three categories: information, warnings and errors. Information and warnings will be logged, but will not cause validation failures. Errors will, however, result in an exception being raised.
+
+# Authentication
+The authentication scheme used by the MMS has been forced down to this client, but we have tried to make it nicer for our users to ingest. Essentially, to authenticate requests with the MMS server, three pieces of information are required.
+
+## Certificate
+The MMS should have made a certificate available to you when you signed up to access the system. This certificate should be a PCKS#12 file and should have a passphrase associated with it. We have created a convenience class to handle this objects, called `mms_client.security.certs.Certificate`. There are a number of ways the certificate can be created, as demonstrated below:
+
+```python
+
+from pathlib import Path
+from mms_client.security.certs import Certificate
+
+# Create a cert from a path to a certificate
+cert = Certificate("/path/to/my/cert.p12", "my_passphrase")
+
+# Create a cert using a Path object
+cert = Certificate(Path("/path/to/my") / "cert.p12", "my_passphrase")
+
+# Create a cert using the raw certificate data
+with open("/path/to/my/cert.p12", "rb") as f:
+    cert = Certificate(f.read(), "my_passphrase")
+```
+
+This object can then be used to generate signatures for requests, and also to create a `Pkcs12Adapter`, which is mounted to the HTTP sessions used to send those same requests. As such, this one object represents the single source of authentication for the entire package.
+
+## Participant Name
+This is a 4-digit alphanumerical code that can be used to identify the market participant to which a user belongs, and on behalf of whom a request is being made. This value must be provided when an MMS client is created, and it must match the value encoded in the certificate and also the participant to whom the certificate is registered on the MMS server.
+
+## User Name
+This is a 1-12 digit alphanumerical code that can be used to identify the user making the request. This value must be provided when an MMS client is created, and it must match the value encoded in the certificate and also the user to whom the certificate is registered on the MMS server.
+
+# Examples
+This section includes some examples of creating a client and requesting data.
+
+## Basic Example
+Create the base client and then add an offer.
+
+```python
+from pendulum import DateTime
+
+from mms_client.client import MmsClient
+from mms_client.security.certs import Certificate
+from mms_client.types.market import MarketType
+from mms_client.types.offer import Direction, OfferData, OfferStack
+from mms_client.utils.web import ClientType
+
+# Create a certificate
+cert = Certificate("/path/to/my/cert.p12", "fake_passphrase")
+
+# Create a new MMS client
+client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert)
+
+# Create our request offer
+request_offer = OfferData(
+    stack=[
+        OfferStack(
+            number=1,
+            unit_price=100,
+            minimum_quantity_kw=100,
+        ),
+    ],
+    resource="FAKE_RESO",
+    start=DateTime(2024, 3, 15, 12),
+    end=DateTime(2024, 3, 15, 21),
+    direction=Direction.SELL,
+)
+
+# Submit our offer to the client, returning the completed offer
+response_offer = client.put_offer(
+    request=request_offer,
+    market_type=MarketType.DAY_AHEAD,
+    days=1,
+)
+
+# Print out the response offer
+print(response_offer)
+```
+
+There's a lot of code here but it's not terribly difficult to understand. All this does is pull in the authentication data, create the client, create the payload, submit it to the server and retrieve the response.
+
+## Connecting to a Test Server
+If you want to test your MMS connection, you can try using the test server:
+
+```python
+client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert, is_admin=True)
+```
+
+## Connecting as a Market Admin
+If you're connecting as a market operator (MO), you can connect in admin mode:
+
+```python
+client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert, test=True)
+```
+
+## Log Settings
+The client also supports injection of a custom logger. The default logger is named "MMS Client".
+
+```python
+client = MmsClient(participant="F100", user="FAKEUSER", client_type=ClientType.BSP, cert, logger=my_logger)
+```
+
+The client currently logs a number of informational, debug and error messages. You can freely change the logging level yourself.
+
+# Completeness
+This client is not complete. Currently, it supports the following endpoints:
+- MarketSubmit_OfferData
+- MarketQuery_OfferQuery
+- MarketCancel_OfferCancel
+
+We can add support for additional endpoints as time goes on, and independent contribution is, of course, welcome. However, support for attachments is currently limited because none of the endpoints we support currently require them. We have implemented attachment support up to the client level, but we haven't developed an architecture for submitting them through an endpoint yet.
+
+# Installation
+We have a package on PyPI so installation is as easy as doing:
+
+```
+pip install mms-client
+```
+
+or
+
+```
+poetry add mms-client
+```
+

mms_client-1.0.5.dist-info/RECORD

@@ -0,0 +1,34 @@
+mms_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mms_client/client.py,sha256=e04kuyY2byONvLcc-etsdaV7mA6mBQLAhd4-wfDitlk,571
+mms_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mms_client/schemas/wsdl/mi-web-service-jbms.wsdl,sha256=4qSn52d-DF6COeI-53P85sSODQy-C4_yp30yYCjeI84,10702
+mms_client/schemas/wsdl/omi-web-service.wsdl,sha256=pIEKcUWzyChzPJnQ6IpnZYyJJ0_0j3yt8M-1l_su5Q8,9894
+mms_client/schemas/xsd/mi-market.xsd,sha256=YyA-84Ha95BfvbACLaALs7m5U-idV-5yQ8GZfmZS_M8,109679
+mms_client/schemas/xsd/mi-outbnd-reports.xsd,sha256=xdQ_9jekOnqs9YPx0Dg8wsZjoxEp-HLO_ZXhzZl2Qk0,76166
+mms_client/schemas/xsd/mi-report.xsd,sha256=XEHhHCGgK4aeYsmObIrlzkvV8UhbirgoysAEOglvUW8,13276
+mms_client/schemas/xsd/mpr.xsd,sha256=QcnuKFm1WkyZfT_56cINHldZkR-3pU4nHSbFKHkIQS0,69149
+mms_client/schemas/xsd/omi.xsd,sha256=benkYeno_HF6BOIv7gAT79dWz00JccS3XilPLBCKVIU,31524
+mms_client/security/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/omi.py,sha256=h6cM5U3-iSm0YiIaJwqYTZeI5uhLbA7FPxh_qy_3qww,521
+mms_client/services/registration.py,sha256=MUUp0SDE7F0d_lV5pXNqPhrU87CAZc6AA72AdmRAu6Q,571
+mms_client/services/report.py,sha256=HYVJNwEHo6ZC6497UqO5y1IqZ2ga3kVH5AepdxhYfug,537
+mms_client/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mms_client/types/base.py,sha256=EMGCDvf_B_8q1YMH-l31c_lV0OdxxAReFNU3zPs0K0Q,9681
+mms_client/types/enums.py,sha256=WzFD9fG9jKFsA91oKyXCAW0oKzUTH3NyUkV4A_N0sXg,329
+mms_client/types/fields.py,sha256=QaNnfU0goAld8VADD_DXZ6qEuUrxISY7rFg5gB6k948,6250
+mms_client/types/market.py,sha256=OKjBIx9aIgaLUci6b5WoB4NZbFncRbbd2FxeAvW1iWw,2588
+mms_client/types/offer.py,sha256=EdxgHlU9FWPuMq3tLYcbILBWnL5SWMsH5Qe7NRhGz9Y,6300
+mms_client/types/transport.py,sha256=SGzDGoTpUvhGpkKxoyJR22z-Ao_Dj5idz97vd6u7fqk,4419
+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=Zp1pZvrWcbV4p_PERS5e9zNKPSeHQFijYzJiby3y0Pk,25206
+mms_client/utils/web.py,sha256=fcdCtdDrHBPyhIlTcyiuAk3D3TlW8HmUw-wGfpG4KTA,9653
+mms_client-1.0.5.dist-info/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+mms_client-1.0.5.dist-info/METADATA,sha256=ipQzCCXjjlPxB3CgR_xRVWBp-t22GnEq_lmyC0mlXuU,13782
+mms_client-1.0.5.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+mms_client-1.0.5.dist-info/RECORD,,

mms_client-1.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.6.1
+Root-Is-Purelib: true
+Tag: py3-none-any