mms-client 1.8.0__tar.gz → 1.9.0__tar.gz

{mms_client-1.8.0 → mms_client-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mms-client
-Version: 1.8.0
+Version: 1.9.0
 Summary: API client for accessing the MMS
 Home-page: https://github.com/ElectroRoute-Japan/mms-client
 Author: Ryan Wood
@@ -192,10 +192,10 @@ client = MmsClient(domain="mydomain.com", participant="F100", user="FAKEUSER", c
 ```
 
 ## Auditing XML Requests & Responses
-A common requirement for this sort of library is recording or saving the raw XML requests and responses for audit/logging purposes. This library supports this workflow through the `mms_client.utils.auditing.AuditPlugin` object. This object intercepts the XML request at the Zeep client level right before it is sent to the MMS and, similarly, intercepts the XML response immediately after it is received from the MMS. Before passing these objects on, without modifying them, it records the XML data as a byte string and passes it to two methods: `audit_request` and `audit_response`. These can be overridden by any object that inherits from this class, allowing the user to direct this data to whatever store they prefer to use for auditing or logging.
+A common requirement for this sort of library is recording or saving the raw XML requests and responses for audit/logging purposes. This library supports this workflow through the `mms_client.utils.plugin.Plugin` object. This object intercepts the XML request at the Zeep client level right before it is sent to the MMS and, similarly, intercepts the XML response immediately after it is received from the MMS. Before passing these objects on, without modifying them, it records the XML data as a byte string and passes it to two methods: `audit_request` and `audit_response`. These can be overridden by any object that inherits from this class, allowing the user to direct this data to whatever store they prefer to use for auditing or logging.
 
 ```python
-class TestAuditPlugin(AuditPlugin):
+class TestAuditPlugin(Plugin):
 
     def __init__(self):
         self.request = None

{mms_client-1.8.0 → mms_client-1.9.0}/README.md

@@ -158,10 +158,10 @@ client = MmsClient(domain="mydomain.com", participant="F100", user="FAKEUSER", c
 ```
 
 ## Auditing XML Requests & Responses
-A common requirement for this sort of library is recording or saving the raw XML requests and responses for audit/logging purposes. This library supports this workflow through the `mms_client.utils.auditing.AuditPlugin` object. This object intercepts the XML request at the Zeep client level right before it is sent to the MMS and, similarly, intercepts the XML response immediately after it is received from the MMS. Before passing these objects on, without modifying them, it records the XML data as a byte string and passes it to two methods: `audit_request` and `audit_response`. These can be overridden by any object that inherits from this class, allowing the user to direct this data to whatever store they prefer to use for auditing or logging.
+A common requirement for this sort of library is recording or saving the raw XML requests and responses for audit/logging purposes. This library supports this workflow through the `mms_client.utils.plugin.Plugin` object. This object intercepts the XML request at the Zeep client level right before it is sent to the MMS and, similarly, intercepts the XML response immediately after it is received from the MMS. Before passing these objects on, without modifying them, it records the XML data as a byte string and passes it to two methods: `audit_request` and `audit_response`. These can be overridden by any object that inherits from this class, allowing the user to direct this data to whatever store they prefer to use for auditing or logging.
 
 ```python
-class TestAuditPlugin(AuditPlugin):
+class TestAuditPlugin(Plugin):
 
     def __init__(self):
         self.request = None

{mms_client-1.8.0 → mms_client-1.9.0}/pyproject.toml

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

{mms_client-1.8.0 → mms_client-1.9.0}/src/mms_client/services/base.py

@@ -365,7 +365,10 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             f"{config.name}: Starting request. Envelope: {type(envelope).__name__}, Data: {type(payload).__name__}",
         )
         request = self._to_mms_request(
-            wrapper, config.request_type, config.service.serializer.serialize(envelope, payload, config.for_report)
+            wrapper,
+            config.name,
+            config.request_type,
+            config.service.serializer.serialize(envelope, payload, config.for_report),
         )
 
         # Next, submit the request to the MMS server and get and verify the response.
@@ -422,7 +425,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             if is_list
             else config.service.serializer.serialize(envelope, payload, config.for_report)  # type: ignore[type-var]
         )
-        request = self._to_mms_request(wrapper, config.request_type, serialized)
+        request = self._to_mms_request(wrapper, config.name, config.request_type, serialized)
 
         # Next, submit the request to the MMS server and get and verify the response.
         resp = wrapper.submit(request)
@@ -452,6 +455,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
     def _to_mms_request(
         self,
         client: ZWrapper,
+        operation: str,
         req_type: RequestType,
         data: bytes,
         return_req: bool = False,
@@ -461,6 +465,7 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
 
         Arguments:
         client (ZWrapper):              The Zeep client to use for submitting the request.
+        operation (str):                The name of the MMS function being called.
         req_type (RequestType):         The type of request to submit to the MMS server.
         data (bytes):                   The data to submit to the MMS server.
         return_req (bool):              Whether to return the request data in the response. This is False by default.
@@ -470,11 +475,13 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
         """
         # First, convert the attachments to the correct the MMS format
         attachment_data = (
-            [self._to_mms_attachment(client, name, data) for name, data in attachments.items()] if attachments else []
+            [self._to_mms_attachment(client, operation, name, data) for name, data in attachments.items()]
+            if attachments
+            else []
         )
 
         # Next, convert the payload to a base-64 string
-        tag, signature = self._register_and_sign(client, "payload", data)
+        tag, signature = self._register_and_sign(client, operation, "payload", data)
 
         # Embed the data and the attachments in the MMS request and return it
         logger.debug(
@@ -491,24 +498,38 @@ class BaseClient:  # pylint: disable=too-many-instance-attributes
             attachmentData=attachment_data,
         )
 
-    def _to_mms_attachment(self, client: ZWrapper, name: str, data: bytes) -> Attachment:  # pragma: no cover
+    def _to_mms_attachment(
+        self, client: ZWrapper, operation: str, name: str, data: bytes
+    ) -> Attachment:  # pragma: no cover
         """Convert the given data to an MMS attachment.
 
         Arguments:
         client (ZWrapper):  The Zeep client to use for submitting the request.
+        operation (str):    The name of the operation.
         name (str):         The name of the attachment.
         data (bytes):       The data to be attached.
 
         Returns:    The MMS attachment.
         """
         # Convert the data to a base-64 string
-        tag, signature = self._register_and_sign(client, name, data)
+        tag, signature = self._register_and_sign(client, operation, name, data)
 
         # Create the MMS attachment and return it
         return Attachment(signature=signature, name=name, binaryData=tag)
 
-    def _register_and_sign(self, client: ZWrapper, name: str, data: bytes) -> Tuple[str, str]:
-        tag = client.register_attachment(name, data)
+    def _register_and_sign(self, client: ZWrapper, operation: str, name: str, data: bytes) -> Tuple[str, str]:
+        """Register an attachment and sign the data.
+
+        Arguments:
+        client (ZWrapper):  The Zeep client to use for submitting the request.
+        operation (str):    The name of the operation.
+        name (str):         The name of the attachment.
+        data (bytes):       The data to be attached.
+
+        Returns:    The content ID of the attachment, which should be used in place of the attachment data.
+        """
+        # First, register the attachment
+        tag = client.register_attachment(operation, name, data)
 
         # Next, sign the data
         signature = self._signer.sign(data)

{mms_client-1.8.0 → mms_client-1.9.0}/src/mms_client/types/transport.py

@@ -17,7 +17,7 @@ class RequestType(Enum):
 
     INFO = "mp.info"
     MARKET = "mp.market"
-    REGISTRATION = "mpr"
+    REGISTRATION = "mp.registration"
     REPORT = "mp.report"
     OMI = "mp.omi"
 

{mms_client-1.8.0 → mms_client-1.9.0}/src/mms_client/utils/multipart_transport.py

@@ -9,16 +9,21 @@ from email.mime.multipart import MIMEMultipart
 from logging import getLogger
 from random import SystemRandom
 from typing import Dict
+from typing import List
 from typing import Optional
+from typing import Tuple
 
 from lxml import etree
 from lxml.etree import _Element as Element
 from pendulum import now
+from requests import Response
 from requests import Session
 from zeep.cache import VersionedCacheBase
 from zeep.transports import Transport
 from zeep.wsdl.utils import etree_to_string
 
+from mms_client.utils.plugin import Plugin
+
 # Set the default logger for the MMS client
 logger = getLogger(__name__)
 
@@ -136,6 +141,7 @@ class MultipartTransport(Transport):
         timeout: int = 300,
         operation_timeout: Optional[int] = None,
         session: Optional[Session] = None,
+        plugins: Optional[List[Plugin]] = None,
     ):
         """Create a new MTOMS transport.
 
@@ -145,12 +151,17 @@ class MultipartTransport(Transport):
         timeout (int):                          The timeout for the transport.
         operation_timeout (int, optional):      The operation timeout for the transport.
         session (Session, optional):            The session to be used for the transport.
+        plugins (List[Plugin], optional):       The plugins to be used for the transport.
         """
         # Save the domain for later use
         self._domain = domain
 
-        # Setup a dictionary to store the attachments after they're registered
+        # Setup a dictionary to store the attachments and operations after they're registered
         self._attachments: Dict[str, Attachment] = {}
+        self._operations: Dict[str, str] = {}
+
+        # Save our list of plugins
+        self._plugins = plugins or []
 
         # Call the parent constructor
         super().__init__(
@@ -160,23 +171,25 @@ class MultipartTransport(Transport):
             session=session,
         )
 
-    def register_attachment(self, name: str, data: bytes) -> str:
+    def register_attachment(self, operation: str, name: str, data: bytes) -> str:
         """Register an attachment.
 
         Registered attachments will be sent with the request as MTOMS attachments. The content ID of the attachment
         will be returned so that it can be used in the request.
 
         Arguments:
-        name (str):     The name of the attachment.
-        data (bytes):   The data to be attached.
+        operation (str):    The name of the operation.
+        name (str):         The name of the attachment.
+        data (bytes):       The data to be attached.
 
         Returns:    The content ID of the attachment, which should be used in place of the attachment data.
         """
         attachment = Attachment(name, data, self._domain)
         self._attachments[attachment.cid] = attachment
+        self._operations[attachment.cid] = operation
         return attachment.tag
 
-    def post_xml(self, address: str, envelope: Element, headers: dict):
+    def post_xml(self, address: str, envelope: Element, headers: dict) -> Response:
         """Post the XML envelope and attachments.
 
         Arguments:
@@ -186,19 +199,30 @@ class MultipartTransport(Transport):
 
         Returns:    The response from the server.
         """
-        # Search for values that start with our FILETAG
+        # First, search for values that start with our FILETAG
         filetags = envelope.xpath(f"//*[starts-with(text(), '{FILETAG}')]")
 
-        # if there are any attached files, we will set the attachments. Otherwise, just the envelope
+        # Next, if there are any attached files, we will set the attachments. Otherwise, just the envelope
         if filetags:
-            message = self.create_mtom_request(filetags, envelope, headers).encode("UTF-8")
+            message, operation = self.create_mtom_request(filetags, envelope, headers)
         else:
-            message = etree_to_string(envelope)
+            message, operation = etree_to_string(envelope), address
+
+        # Iterate over all the plugins and call their egress methods
+        for plugin in self._plugins:
+            message, headers = plugin.egress(message, headers, operation)
+
+        # Now, post the request and get the response
+        resp = self.post(address, message, headers)
+
+        # Iterate over all the plugins and call their ingress methods
+        for plugin in self._plugins:
+            resp._content, resp.headers = plugin.ingress(resp.content, resp.headers, operation)
 
-        # Post the request and return the response
-        return self.post(address, message, headers)
+        # Finally, return the response
+        return resp
 
-    def create_mtom_request(self, filetags, envelope: Element, headers: dict) -> str:
+    def create_mtom_request(self, filetags, envelope: Element, headers: dict) -> Tuple[bytes, str]:
         """Set MTOM attachments and return the right envelope.
 
         Arguments:
@@ -221,6 +245,7 @@ class MultipartTransport(Transport):
 
         # Attach each file to the multipart request
         for cid in files:
+            operation = self._operations.pop(cid)
             mtom_part.attach(self.create_attachment(cid))
 
         # Finally, create the final multipart request string
@@ -235,7 +260,7 @@ class MultipartTransport(Transport):
         # Decode the XML and return the request
         message = mtom_part.as_string().split("\n\n", 1)[1]
         message = message.replace("\n", "\r\n", 5)
-        return message
+        return message.encode("UTF-8"), operation
 
     def create_attachment(self, cid):
         """Create an attachment for the multipart request.
@@ -246,7 +271,7 @@ class MultipartTransport(Transport):
         Returns:    The attachment.
         """
         # First, get the attachment from the cache
-        attach = self._attachments[cid]
+        attach = self._attachments.pop(cid)
 
         # Next, create the attachment
         part = MIMEBase("application", "octet-stream")

mms_client-1.8.0/src/mms_client/utils/auditing.py → mms_client-1.9.0/src/mms_client/utils/plugin.py

@@ -3,44 +3,44 @@
 from abc import ABC
 from abc import abstractmethod
 from logging import getLogger
-
-from lxml.etree import _Element as Element
-from lxml.etree import tostring
-from zeep import Plugin
-from zeep.wsdl.definitions import Operation
+from typing import Tuple
 
 # Set the default logger for the MMS client
 logger = getLogger(__name__)
 
 
-class AuditPlugin(ABC, Plugin):
+class Plugin(ABC):
     """Base class for audit plugins."""
 
-    def egress(self, envelope: Element, http_headers: dict, operation: Operation, binding_options):
+    def egress(self, message: bytes, http_headers: dict, operation: str) -> Tuple[bytes, dict]:
         """Handle the MMS request before it is sent.
 
-        Arguments are the same as in the egress method of the Plugin class.
+        Arguments:
+        message (bytes):        The message to send.
+        http_headers (dict):    The HTTP headers to send.
+        operation (str):        The operation being called.
 
         Returns:
         lxml.etree.Element: The XML message to send.
         dict:               The HTTP headers to send.
         """
-        data = tostring(envelope, encoding="UTF-8", xml_declaration=True)
-        self.audit_request(operation.name, data)
-        return envelope, http_headers
+        self.audit_request(operation, message)
+        return message, http_headers
 
-    def ingress(self, envelope: Element, http_headers: dict, operation: Operation):
+    def ingress(self, message: bytes, http_headers: dict, operation: str) -> Tuple[bytes, dict]:
         """Handle the MMS response before it is processed.
 
-        Arguments are the same as in the ingress method of the Plugin class.
+        Arguments:
+        message (bytes):        The message to process.
+        http_headers (dict):    The HTTP headers to process.
+        operation (str):        The operation being called.
 
         Returns:
         lxml.etree.Element: The XML message to process.
         dict:               The HTTP headers to process.
         """
-        data = tostring(envelope, encoding="UTF-8", xml_declaration=True)
-        self.audit_response(operation.name, data)
-        return envelope, http_headers
+        self.audit_response(operation, message)
+        return message, http_headers
 
     @abstractmethod
     def audit_request(self, operation: str, mms_request: bytes) -> None:

{mms_client-1.8.0 → mms_client-1.9.0}/src/mms_client/utils/web.py

@@ -11,7 +11,6 @@ from backoff import on_exception
 from requests import Session
 from requests_pkcs12 import Pkcs12Adapter
 from zeep import Client
-from zeep import Plugin
 from zeep.cache import SqliteCache
 from zeep.exceptions import TransportError
 from zeep.xsd.valueobjects import CompoundValue
@@ -19,6 +18,7 @@ from zeep.xsd.valueobjects import CompoundValue
 from mms_client.types.transport import MmsRequest
 from mms_client.types.transport import MmsResponse
 from mms_client.utils.multipart_transport import MultipartTransport
+from mms_client.utils.plugin import Plugin
 
 # Set the default logger for the MMS client
 logger = getLogger(__name__)
@@ -193,24 +193,26 @@ class ZWrapper:
 
         # Finally, we create the Zeep client with the given WSDL file location, session, and cache settings and then,
         # from that client, we create the SOAP service with the given service binding and selected endpoint.
-        self._transport = MultipartTransport(domain, cache=SqliteCache() if cache else None, session=sess)
+        self._transport = MultipartTransport(
+            domain, cache=SqliteCache() if cache else None, session=sess, plugins=plugins
+        )
         self._client = Client(
             wsdl=str(location.resolve()),
             transport=self._transport,
-            plugins=plugins,
         )
         self._create_service()
 
-    def register_attachment(self, name: str, attachment: bytes) -> str:
+    def register_attachment(self, operation: str, name: str, attachment: bytes) -> str:
         """Register a multipart attachment.
 
         Arguments:
+        operation (str):    The name of the operation.
         name (str):         The name of the attachment.
         attachment (bytes): The data to be attached.
 
         Returns:    The content ID of the attachment, which should be used in place of the attachment data.
         """
-        return self._transport.register_attachment(name, attachment)
+        return self._transport.register_attachment(operation, name, attachment)
 
     @on_exception(expo, TransportError, max_tries=3, giveup=fatal_code, logger=logger)  # type: ignore[arg-type]
     def submit(self, req: MmsRequest) -> MmsResponse: