pyAS4 0.1.19__py3-none-any.whl

pyAS4/AS4Client.py

@@ -0,0 +1,327 @@
+import base64
+import logging
+import uuid
+from io import BytesIO
+from typing import Generator
+
+from pymtom_xop import MtomAttachment, MtomTransport
+from zeep import Client, Settings, Transport
+from zeep.exceptions import Fault
+from zeep.plugins import HistoryPlugin
+
+from pyAS4.header import Header, get_dict_header
+
+_logger = logging.getLogger(__name__)
+
+
+def _open_io(content: bytes | str | None, encoding_b64: bool = False) -> BytesIO:
+    """Повертає `BytesIO` для payload; за потреби кодує вміст у base64."""
+    _logger.debug(f"open_io - > {type(content)}")
+
+    if content is None:
+        raise ValueError("Content cannot be None")
+
+    if isinstance(content, str):
+        return BytesIO(content.encode("utf-8"))
+
+    if encoding_b64:
+        return BytesIO(base64.b64encode(content))
+
+    return BytesIO(content)
+
+
+def _norm_cid(cid: str | bytes) -> str:
+    """Нормалізує Content-ID для використання в SOAP payloadId."""
+    # CID у payloadId має бути без кутових дужок і без префікса `cid:`.
+    cid = cid.decode() if isinstance(cid, bytes) else cid
+
+    if not cid:
+        return ""
+    cid = cid.strip().strip("<>").strip()
+    if cid.lower().startswith("cid:"):
+        cid = cid[4:]
+    return cid
+
+
+def attachment(
+        files: list[dict[str, str | bytes]], attachments: list[MtomAttachment] | None = None
+) -> list[MtomAttachment]:
+    """
+    Додає вкладення до списку `attachments` на основі переданих файлів.
+    Кожен файл у списку `files` повинен бути словником з ключами
+    `content`, `content_type` та необов'язковим `cid`.
+    :param files:
+    :param attachments:
+    :return:
+    """
+    if attachments is None:
+        attachments = []
+    for file in files:
+        attachments.append(
+            MtomAttachment(
+                file=_open_io(file.get("content")),
+                content_type=file.get("content_type"),
+                cid=f"<{_norm_cid(file.get('cid', str(uuid.uuid4())))}>",
+            )
+        )
+    return attachments
+
+
+def get_payload(user_message: dict, body) -> list[dict[str, str]]:
+    """
+    Перетворює частини повідомлення та payload на список словників для зручності обробки.
+    :param user_message:
+    :param body:
+    :return:
+    """
+
+    payloads = body.payload
+    if isinstance(payloads, list):
+        _logger.info(f"Received {len(payloads)} payloads in part")
+    else:
+        payloads = [payloads]
+        _logger.info("Received a single payload in part, wrapping in lists")
+
+    meta_parts = []
+    for part in user_message.get("PayloadInfo", []):
+        m = {"href": part.get("href", "").strip('"')}
+
+        for proporty in part.get("PartProperties", {}).get("Property", []):
+            m.update({proporty.get("name"): proporty.get("_value_1")})
+
+        for payload in payloads:
+            if payload.payloadId == part.get("href", "").strip('"'):
+                m.update({"content": payload.value.decode()})
+        if not m.get("content"):
+            _logger.error(f"Part {part.get('href', '')} has no content, skipping")
+            continue
+        meta_parts.append(m)
+    return meta_parts
+
+
+class AS4Client:
+    """
+    Summary of what the class does.
+
+    The AS4Client class is responsible for creating and managing an AS4 client
+    instance. It initializes the necessary elements such as WSDL, transport,
+    plugins, and header to set up the client properly. This class serves to
+    facilitate communication in the context of AS4-based message exchange by
+    leveraging the provided configuration data.
+
+    :ivar wsdl: The URL or path to the WSDL describing the service. This is a
+        critical component for initializing the client.
+    :type wsdl: str
+    :ivar transport: The transport object that handles the communication layer for
+        the AS4 client.
+    :type transport: Transport
+    :ivar plugins: A list of plugins, such as HistoryPlugin, used for message
+        handling, logging, or other custom processing needs.
+    :type plugins: list[HistoryPlugin]
+    :ivar header: The AS4-specific header required for processing and transmitting
+        requests through the client.
+    :type header: Header
+    """
+
+    def __init__(
+            self,
+            wsdl: str,
+            transport: Transport,
+            plugins: list[HistoryPlugin],
+            header: Header,
+    ):
+        self.wsdl = wsdl
+        self.transport: Transport = transport
+        self.plugins = plugins
+        self.header = header
+
+        self.settings = Settings(strict=False, xml_huge_tree=True)
+        self.client: Client | None = None
+
+
+class MtomTransportProtocol(Transport):
+    def add_files(self, files: list[MtomAttachment]) -> None: ...
+
+
+class AS4Send(AS4Client):
+    def __init__(
+            self,
+            wsdl: str,
+            transport: MtomTransportProtocol,
+            plugins: list[HistoryPlugin],
+            header: Header,
+    ):
+        """
+        Initializes the client with a specific WSDL, transport, plugin list, and header.
+        The transport must be an instance of MtomTransport. This class is a specialized
+        client designed for handling SOAP requests with MTOM support by extending the
+        base client functionality.
+
+        :param wsdl: WSDL file location as a string for constructing the SOAP client.
+        :param transport: Transport layer used for communication, which must be an
+            instance of MtomTransport.
+        :param plugins: List of `HistoryPlugin` used to capture and manipulate outgoing
+            or incoming messages within the client.
+        :param header: SOAP request header to include in all outgoing requests.
+        :raises TypeError: If the provided `transport` is not an instance of
+            `MtomTransport`.
+        """
+        if not isinstance(transport, MtomTransport):
+            raise TypeError("Transport must be an instance of MtomTransport")
+
+        super().__init__(wsdl, transport, plugins, header)
+        self.transport = transport
+
+    def send_message(self, payload: list[dict]):
+        """
+        Sends a message by preparing and attaching payload data to the transport, then
+        initializing a SOAP client for further communication.
+
+        This method prepares the provided payload, converts it into attachments, and
+        adds these attachments to the transport mechanism. The SOAP client is then
+        initialized utilizing the configured WSDL, transport, settings, and plugins.
+
+        :param payload: A list of dictionaries, where each dictionary contains the
+            necessary data to be sent as part of the operation.
+        :type payload: list[dict]
+        """
+        attach = attachment(payload)
+        self.transport.add_files(files=attach)  # type: ignore
+
+        self.client = Client(
+            wsdl=self.wsdl,
+            transport=self.transport,
+            settings=self.settings,
+            plugins=self.plugins,
+        )
+        PayloadType = self.client.get_type("ns0:LargePayloadType")
+        bodyload_obj = None
+        payload_objs = []
+
+        for idx, file in enumerate(attach):
+            payload_id = f"cid:{_norm_cid(file.get_cid())}"
+            obj = PayloadType(
+                value=file.get_cid(),
+                payloadId=payload_id,
+                contentType=file.content_type,
+            )
+            self.header.payload_append(
+                [{"href": payload_id, "mimetype": file.content_type}]
+            )
+            payload_objs.append(obj)
+        try:
+            response = self.client.service.submitMessage(
+                _soapheaders=[self.header.element],
+                body=payload_objs,
+                bodyload=bodyload_obj,
+            )
+        except Fault:
+            _logger.exception("SOAP Fault occurred while sending message")
+            raise
+        except Exception:
+            _logger.exception("Error sending message")
+            raise
+        _logger.info(f"Message sent successfully: {response}")
+        return response
+
+
+class AS4Receive(AS4Client):
+    def __init__(
+            self,
+            wsdl: str,
+            transport: Transport,
+            plugins: list[HistoryPlugin],
+            header: Header,
+    ):
+        """
+        Initializes a new instance of the class.
+
+        This constructor establishes the core components required for the proper
+        functioning of the object by accepting necessary parameters including WSDL
+        configuration, transport layer, plugins, and header data. These components
+        are essential for initializing the client object which enables interaction
+        with specified SOAP endpoints.
+
+        :param wsdl: WSDL URL or file path to be used for client configuration.
+            Represents the Web Services Description Language definition for the SOAP
+            service.
+        :type wsdl: str
+        :param transport: A transport instance that handles HTTP requests and responses
+            for the SOAP client.
+        :type transport: Transport
+        :param plugins: A list of plugins to be used by the SOAP client for functionalities
+            such as logging or request/response alterations.
+        :type plugins: list[HistoryPlugin]
+        :param header: The header object used to define additional metadata or
+            authentication details for SOAP requests.
+        :type header: Header
+        """
+        super().__init__(wsdl, transport, plugins, header)
+
+        self.client = Client(
+            wsdl=self.wsdl,
+            transport=self.transport,
+            settings=self.settings,
+            plugins=self.plugins,
+        )
+
+    def _get_pending(self) -> list:
+        try:
+            if self.client is None:
+                raise RuntimeError("Client not initialized")
+            response = self.client.service.listPendingMessages(
+                finalRecipient=self.header.c4_party_id
+            )
+            _logger.info(f"Received message: {len(response)}")
+            return response
+        except Fault:
+            _logger.exception("SOAP Fault occurred")
+            raise
+        except Exception:
+            _logger.exception("Error receiving message")
+            raise
+
+    def receive_message(self) -> Generator[dict, None, None]:
+        """
+        Retrieve and process messages.
+
+        Iterates over pending items and attempts to retrieve their corresponding messages via a SOAP service.
+        Each retrieved message is processed, extracting its header and payload. Log messages are generated for success,
+        warnings, and errors during the process.
+
+        :raises Fault: If a SOAP fault occurs while attempting to retrieve a message.
+        :raises Exception: If an unexpected error occurs during message retrieval.
+        :return: A generator yielding dictionaries containing retrieved message details including message ID,
+                header, and payload.
+        :rtype: Generator[dict, None, None]
+        """
+
+        for item in self._get_pending():
+            message_id = getattr(item, "messageId", None) or str(item)
+            if not message_id:
+                _logger.warning("Message ID not found in pending item")
+                continue
+
+            try:
+                if self.client is None:
+                    raise RuntimeError("Client not initialized")
+                retrieved = self.client.service.retrieveMessage(messageID=message_id)
+            except Fault:
+                _logger.exception(
+                    f"SOAP Fault occurred while retrieving message {message_id}"
+                )
+                continue
+            except Exception:
+                _logger.exception(f"Error retrieving message {message_id}")
+                continue
+
+            message = {"messageId": message_id}
+            header_data = get_dict_header(
+                retrieved.header.ebMSHeaderInfo.UserMessage
+            )
+            message["header"] = header_data
+            message["payload"] = get_payload(header_data, retrieved.body)
+
+            _logger.debug(f"Retrieved message: {message}")
+            yield message
+        _logger.info("No more messages to retrieve")

pyAS4/header.py

@@ -0,0 +1,265 @@
+import logging
+import uuid
+
+from lxml import etree
+
+_logger = logging.getLogger(__name__)
+
+_NS = {
+    "query": "urn:oasis:names:tc:ebxml-regrep:xsd:query:4.0",
+    "rs": "urn:oasis:names:tc:ebxml-regrep:xsd:rs:4.0",
+    "rim": "urn:oasis:names:tc:ebxml-regrep:xsd:rim:4.0",
+    "xsi": "http://www.w3.org/2001/XMLSchema-instance",
+    "sdg": "http://data.europa.eu/sdg#", # NOSONAR
+    "s12": "http://www.w3.org/2003/05/soap-envelope",
+    "eu": "http://eu.domibus.wsplugin/", # NOSONAR
+    "eb3": "http://docs.oasis-open.org/ebxml-msg/ebms/v3.0/ns/core/200704/",
+}
+
+
+def _nsmap(ns: str, tag: str) -> str:
+    return f"{{{_NS[ns]}}}{tag}"
+
+
+class Header:
+    """
+    Represents an ebXML-compatible messaging header, allowing for configuration of
+    various party identifiers, service/action details, and payload-related data.
+
+    This class is designed to facilitate the construction and management of an
+    ebXML AS4-compliant messaging XML, including functionality to dynamically
+    append payload information. The primary purpose of this class is to support
+    eDelivery-compliant systems by structuring the metadata and delivering
+    message-based document exchange.
+
+    :ivar c1_party_id: Identifier for Party 1 involved in the message exchange.
+    :ivar c1_party_id_type: The type of the identifier used for Party 1.
+    :ivar c2_party_id: Identifier for Party 2 involved in the message exchange.
+    :ivar c2_party_id_type: The type of the identifier used for Party 2.
+    :ivar c3_party_id: Identifier for Party 3 involved in the message exchange.
+    :ivar c3_party_id_type: The type of the identifier used for Party 3.
+    :ivar c4_party_id: Identifier for Party 4 involved in the message exchange.
+    :ivar c4_party_id_type: The type of the identifier used for Party 4.
+    :ivar conversationid: Unique identifier for the conversation thread.
+    :ivar service: Service URL to describe the functionality invoked.
+    :ivar service_type: Specific type of the service provided.
+    :ivar action: Action URL defining the invoked operation.
+    :ivar role: Role URL describing the role of the communicating party.
+    """
+
+    def __init__(self,
+                 c1_party_id: str,
+                 c1_party_id_type: str,
+                 c2_party_id: str,
+                 c2_party_id_type: str,
+                 c3_party_id: str,
+                 c3_party_id_type: str,
+                 c4_party_id: str,
+                 c4_party_id_type: str,
+                 conversationid: str = str(uuid.uuid4()),
+                 service: str = "http://docs.oasis-open.org/ebxml-msg/as4/200902/service",  #NOSONAR
+                 service_type: str = "urn:oasis:names:tc:ebcore:ebrs:ebms:binding:1.0",
+                 action: str = "http://docs.oasis-open.org/ebxml-msg/as4/200902/action",  #NOSONAR
+                 role: str = "http://sdg.europa.eu/edelivery/gateway" #NOSONAR
+                 ):
+        """
+        Initializes an instance of the class with required and optional attributes to configure
+        a messaging context as per the specified standards. It validates non-None constraints
+        for mandatory parameters.
+
+        :param c1_party_id: Identifier for Party 1 involved in the message exchange.
+        :param c1_party_id_type: The type of the identifier used for Party 1.
+        :param c2_party_id: Identifier for Party 2 involved in the message exchange.
+        :param c2_party_id_type: The type of the identifier used for Party 2.
+        :param c3_party_id: Identifier for Party 3 involved in the message exchange.
+        :param c3_party_id_type: The type of the identifier used for Party 3.
+        :param c4_party_id: Identifier for Party 4 involved in the message exchange.
+        :param c4_party_id_type: The type of the identifier used for Party 4.
+        :param conversationid: (Optional) Unique identifier for the conversation thread.
+            Defaults to a random UUID.
+        :param service: (Optional) Service URL to describe the functionality invoked.
+            Defaults to "http://docs.oasis-open.org/ebxml-msg/as4/200902/service".
+        :param service_type: (Optional) Specific type of the service provided.
+            Defaults to "urn:oasis:names:tc:ebcore:ebrs:ebms:binding:1.0".
+        :param action: (Optional) Action URL defining the invoked operation.
+            Defaults to "http://docs.oasis-open.org/ebxml-msg/as4/200902/action".
+        :param role: (Optional) Role URL describing the role of the communicating party.
+            Defaults to "http://sdg.europa.eu/edelivery/gateway".
+        :raises ValueError: If any of the mandatory `c1_party_id`, `c2_party_id`,
+            `c3_party_id`, or `c4_party_id` parameters are None.
+        """
+        if None in (c1_party_id, c2_party_id, c3_party_id, c4_party_id):
+            raise ValueError("Parameters must not be None")
+
+        self._xml = etree.Element(_nsmap('eb3', 'Messaging'), nsmap=_NS)
+
+        self.c1_party_id = c1_party_id
+        self.c1_party_id_type = c1_party_id_type
+        self.c2_party_id = c2_party_id
+        self.c2_party_id_type = c2_party_id_type
+        self.c3_party_id = c3_party_id
+        self.c3_party_id_type = c3_party_id_type
+        self.c4_party_id = c4_party_id
+        self.c4_party_id_type = c4_party_id_type
+        self.service = service
+        self.service_type = service_type
+        self.action = action
+        self.conversationid = conversationid
+        self.role = role
+        self.pay_load_info = self.__toxml()
+
+    def __toxml(self) -> etree._Element:
+        """
+        Generates and returns an XML element representing a `PayloadInfo` node with nested
+        structure for UserMessage, PartyInfo, CollaborationInfo, and MessageProperties
+        based on the provided instance attributes.
+
+        This method uses the lxml.etree library to structure an XML tree,
+        populating the sub-elements with instance-specific data.
+
+        :return: An XML element 'PayloadInfo' with the nested structure.
+        :rtype: etree._Element
+        """
+
+        user_message = etree.SubElement(self._xml, _nsmap('eb3', 'UserMessage'))
+
+        party_info = etree.SubElement(user_message, _nsmap('eb3', 'PartyInfo'))
+        froms = etree.SubElement(party_info, _nsmap('eb3', 'From'))
+        etree.SubElement(froms, _nsmap('eb3', 'PartyId'),
+                         attrib={'type': self.c2_party_id_type},
+                         ).text=self.c2_party_id
+        etree.SubElement(froms, _nsmap('eb3', 'Role'),
+                         ).text=self.role
+
+        to = etree.SubElement(party_info, _nsmap('eb3', 'To'))
+        etree.SubElement(to, _nsmap('eb3', 'PartyId'),
+                         attrib={'type': self.c3_party_id_type},
+                         ).text=self.c3_party_id
+        etree.SubElement(to, _nsmap('eb3', 'Role'),
+                         ).text=self.role
+
+        collaboration_info = etree.SubElement(user_message, _nsmap('eb3', 'CollaborationInfo'))
+        etree.SubElement(collaboration_info, _nsmap('eb3', 'Service'),
+                         type="urn:oasis:names:tc:ebcore:ebrs:ebms:binding:1.0",
+                         ).text=self.service
+        etree.SubElement(collaboration_info, _nsmap('eb3', 'Action'),
+                         ).text=self.action
+        etree.SubElement(collaboration_info, _nsmap('eb3', 'ConversationId'),
+                         ).text=self.conversationid
+
+        message_proportis = etree.SubElement(user_message, _nsmap('eb3', 'MessageProperties'))
+        etree.SubElement(message_proportis, _nsmap('eb3', 'Property'),
+                         attrib={
+                             'name': 'originalSender',
+                             'type': self.c1_party_id_type},
+                         ).text=self.c1_party_id
+        etree.SubElement(message_proportis, _nsmap('eb3', 'Property'),
+                         attrib={
+                             'name': 'finalRecipient',
+                             'type': self.c4_party_id_type},
+                         ).text=self.c4_party_id
+
+        pay_load_info = etree.SubElement(user_message, _nsmap('eb3', 'PayloadInfo'))
+
+        return pay_load_info
+
+    def payload_append(self, payloads: list[dict[str, str]]):
+        """
+        Appends payload information to the internal XML structure.
+
+        This method processes a list of payload dictionaries and appends their
+        information into an internal XML structure represented by `self.pay_load_info`.
+        Each dictionary in the input list contains details about a single payload, such
+        as its `href`, `mimetype`, and optionally its `CompressionType`.
+
+        :param payloads: List of dictionaries, where each dictionary represents a
+            payload with at least the keys `href` (str) and `mimetype` (str). The key
+            `CompressionType` (str) is optional.
+        :return: None
+        """
+        for payload in payloads:
+            pl = etree.SubElement(self.pay_load_info, _nsmap('eb3', 'PartInfo'),
+                                  attrib={'href': payload['href']})
+            pp = etree.SubElement(pl, _nsmap('eb3', 'PartProperties'),)
+            etree.SubElement(pp, _nsmap('eb3', 'Property'),
+                             attrib={'name': "MimeType"},
+                             ).text=payload['mimetype']
+            if payload.get('CompressionType', None):
+                etree.SubElement(pp, _nsmap('eb3', 'Property'),
+                                 attrib={'name': "CompressionType"},
+                                 ).text=payload['CompressionType']
+
+    @property
+    def element(self) -> etree._Element:
+        """
+        Returns the underlying XML element associated with this object.
+
+        This property provides access to the root XML element, enabling direct
+        manipulation or query of the XML structure represented by it.
+
+        :return: The root XML element of the object.
+        :rtype: etree._Element
+        """
+        return self._xml
+
+    @property
+    def xml(self) -> bytes:
+        """
+        Provides a property to retrieve the XML representation of an element.
+
+        This property generates and returns the XML content of the associated
+        element in a byte string format with pretty-print formatting applied.
+
+        :return: A byte string containing the XML representation of the element
+            with pretty-print formatting.
+        :rtype: Bytes
+        """
+        return etree.tostring(self.element, pretty_print=True)
+
+
+def get_dict_header(source_message) -> dict:
+    """
+    Перетворює заголовок повідомлення на словник для зручності обробки.
+    :param source_message:
+    :return:
+    """
+    headers = {
+        "messageId": source_message.MessageInfo.MessageId,
+        "timestamp": source_message.MessageInfo.Timestamp,
+        "Party": {
+            "From": {
+                "name": source_message.PartyInfo.From.PartyId._value_1,
+                "type": source_message.PartyInfo.From.PartyId.type,
+                "role": source_message.PartyInfo.From.Role,
+            },
+            "To": {
+                "name": source_message.PartyInfo.To.PartyId._value_1,
+                "type": source_message.PartyInfo.To.PartyId.type,
+                "role": source_message.PartyInfo.To.Role,
+            },
+        },
+        "CollaborationInfo": {
+            "service": source_message.CollaborationInfo.Service._value_1,
+            "serviceType": source_message.CollaborationInfo.Service.type,
+            "action": source_message.CollaborationInfo.Action,
+            "conversationId": source_message.CollaborationInfo.ConversationId,
+        },
+    }
+    parts = source_message.PayloadInfo.PartInfo
+    if isinstance(parts, list):
+        _logger.info(f"Received {len(parts)} parts in message")
+    else:
+        parts = [parts]
+        _logger.info("Received a single part in a message, wrapping in lists")
+
+    meta_parts = []
+    for part in parts:
+        m = {"href": part.href.strip('"')}
+
+        for proporty in part.PartProperties.Property:
+            m.update({proporty.name: proporty._value_1})
+
+        meta_parts.append(m)
+
+    headers["PayloadInfo"] = meta_parts
+    return headers

pyas4-0.1.19.dist-info/METADATA

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: pyAS4
+Version: 0.1.19
+Summary: Python бібліотека для роботи з AS4 (OASIS ebXML AS4) протоколом обміну повідомленнями
+Author: Andriy Shapovalov
+Requires-Python: >=3.12
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: lxml>=6.1.1
+Requires-Dist: zeep>=4.3.3
+Requires-Dist: pymtom-xop-fork>=0.0.3
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11.0; extra == "dev"
+Requires-Dist: pyrefly>=0.60.0; extra == "dev"
+Requires-Dist: pytest>=8.2.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.7; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Dynamic: license-file
+
+pyAS4
+=====
+
+Бібліотека Python для роботи з AS4 (OASIS ebXML AS4) протоколом обміну повідомленнями.
+
+**pyAS4** - це дружелюбна обгортка навколо ZEEP та MTOM/XOP транспорту, яка спрощує створення та управління
+AS4-сумісними повідомленнями для систем електронної доставки та B2B комунікацій.
+
+Опис
+----
+
+pyAS4 надає удосконалений клієнт для роботи з AS4 веб-сервісами, включаючи:
+
+- **AS4Send** - клієнт для відправлення AS4-повідомлень
+- **AS4Receive** - клієнт для отримання AS4-повідомлень
+- **Header** - конструктор заголовків AS4 для керування метаданими повідомлень
+- Підтримка MTOM/XOP для передачі великих файлів
+- Управління party identifiers та service/action деталями
+- Обробка вхідних та вихідних повідомлень
+
+Вимоги
+------
+
+- Python >= 3.12
+- lxml >= 6.1.1
+- zeep >= 4.3.3
+
+Встановлення
+------------
+
+За допомогою uv::
+
+    uv sync --extra dev
+
+Або з вихідного коду::
+
+    git clone <repository-url>
+    cd pyAS4
+    uv sync --extra dev
+
+Використання
+------------
+
+Основний приклад
+^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    from zeep.plugins import HistoryPlugin
+    from pymtom_xop import MtomTransport
+
+    from pyAS4.AS4Client import AS4Send
+    from pyAS4.header import Header
+
+    # Створіть транспорт та заголовок
+    transport = MtomTransport()
+    header = Header(
+        c1_party_id="party1-id",
+        c1_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C1",
+        c2_party_id="party2-id",
+        c2_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C2",
+        c3_party_id="party3-id",
+        c3_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C3",
+        c4_party_id="party4-id",
+        c4_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C4",
+        service_type="urn:oasis:names:tc:ebcore:ebrs:ebms:binding:1.0",
+        conversationid="my-conversation-id",
+    )
+
+    # Ініціалізуйте клієнт відправлення
+    client = AS4Send(
+        wsdl="http://example.com/as4-service?wsdl",
+        transport=transport,
+        plugins=[HistoryPlugin()],
+        header=header,
+    )
+
+Відправлення повідомлень
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    # Відправте повідомлення з вказаними корисними навантаженнями
+    payloads = [
+        {
+            "content": b"<xml>payload content</xml>",
+            "content_type": "application/xml",
+        }
+    ]
+
+    client.send_message(payloads)
+
+Отримання очікуючих повідомлень
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    from pyAS4.AS4Client import AS4Receive
+
+    receiver = AS4Receive(
+        wsdl="http://example.com/as4-service?wsdl",
+        transport=transport,
+        plugins=[HistoryPlugin()],
+        header=header,
+    )
+
+    # Отримайте очікуючі повідомлення
+    for message in receiver.receive_message():
+        print(message)
+
+Робота з заголовками AS4
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: python
+
+    from pyAS4.header import Header
+
+    # Створіть заголовок AS4
+    header = Header(
+        c1_party_id="sender-id",
+        c1_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C1",
+        c2_party_id="recipient-id",
+        c2_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C2",
+        c3_party_id="intermediary-id",
+        c3_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C3",
+        c4_party_id="carrier-id",
+        c4_party_id_type="urn:fdc:peppol.eu:2017:identifiers:C4",
+        conversationid="unique-conversation-id",
+        service="http://docs.oasis-open.org/ebxml-msg/as4/200902/service",
+        service_type="urn:oasis:names:tc:ebcore:ebrs:ebms:binding:1.0",
+        action="http://docs.oasis-open.org/ebxml-msg/as4/200902/action"
+    )
+
+Структура проєкту
+-----------------
+
+::
+
+    pyAS4/
+    ├── pyAS4/
+    │   ├── __init__.py           # Точка входу бібліотеки
+    │   ├── AS4Client.py          # AS4Client, AS4Send та AS4Receive
+    │   ├── header.py            # Header клас для керування AS4 заголовками
+    │   └── py.typed             # Маркер для типізованої бібліотеки
+    ├── README.rst               # Цей файл
+    ├── pyproject.toml           # Конфігурація проєкту (PEP 517/518)
+    └── uv.lock                  # Зафіксовані залежності для uv
+
+Архітектура
+-----------
+
+**AS4Send / AS4Receive**
+    Базові клієнти для відправлення й отримання AS4-повідомлень через WSDL,
+    транспорт і AS4-заголовок.
+
+**Header**
+    Клас для конструювання та керування ebXML AS4 заголовками повідомлень.
+    Генерує коректний XML на основі стандартів OASIS ebXML.
+
+**MtomTransport**
+    Транспорт з підтримкою MTOM/XOP для обробки великих бінарних вкладень.
+
+Стандарти та протоколи
+----------------------
+
+Проєкт реалізує наступні стандарти:
+
+- **OASIS ebXML AS4 v3.0** - Асинхронна обробка SOAP повідомлень
+- **PEPPOL** - Pan-European Public Procurement Online (ідентифікатори сторін)
+- **MTOM/XOP** - SOAP з вкладеннями (передача великих файлів)
+
+Автор
+-----
+
+Andrey Shapovalov (mt.andrey@gmail.com)
+
+Ліцензія
+--------
+
+EUPL v1.2
+
+Поточна версія
+--------------
+
+9
+
+Внески
+------
+
+Поточна версія розробляється в приватному репозиторії.
+
+Контакти
+--------
+
+Для питань та пропозицій звертайтесь до:
+- Email: mt.andrey@gmail.com
+
+----
+
+Примітка: Бібліотека розроблена для роботи з системами електронної доставки,
+що відповідають стандартам OASIS ebXML AS4, та особливо для проєктів,
+що використовують PEPPOL мережу.

pyas4-0.1.19.dist-info/RECORD

@@ -0,0 +1,8 @@
+pyAS4/AS4Client.py,sha256=34c6mBTkkUHvsw3wcVdr0PUTskx2hAyV7Tb3EwbzsYU,12332
+pyAS4/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyAS4/header.py,sha256=suxG0ZXovuE6UriysscwdxhvkChf3CHH2dXPqjhV4Ic,12226
+pyas4-0.1.19.dist-info/licenses/LICENSE,sha256=ki5-O-jt9WSvTvj8NrFtB82sv4uCY9lwvPb-DuBZKIc,13957
+pyas4-0.1.19.dist-info/METADATA,sha256=swLOXAed-hpqA4Z8quaroDWasHodQD-Ufxnbn1tHKUk,7552
+pyas4-0.1.19.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyas4-0.1.19.dist-info/top_level.txt,sha256=vCujoNeUocyhJQzT1AUJNPbQKEf_oplo9UnmK5o_eFw,6
+pyas4-0.1.19.dist-info/RECORD,,

pyas4-0.1.19.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyas4-0.1.19.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+EUROPEAN UNION PUBLIC LICENCE v. 1.2 
+EUPL © the European Union 2007, 2016 
+
+This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined below) which is provided under the 
+terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such 
+use is covered by a right of the copyright holder of the Work). 
+The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following 
+notice immediately following the copyright notice for the Work: 
+                          Licensed under the EUPL 
+or has expressed by any other means his willingness to license under the EUPL. 
+
+1.Definitions 
+In this Licence, the following terms have the following meaning: 
+— ‘The Licence’:this Licence. 
+— ‘The Original Work’:the work or software distributed or communicated by the Licensor under this Licence, available 
+as Source Code and also as Executable Code as the case may be. 
+— ‘Derivative Works’:the works or software that could be created by the Licensee, based upon the Original Work or 
+modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work 
+required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in 
+the country mentioned in Article 15. 
+— ‘The Work’:the Original Work or its Derivative Works. 
+— ‘The Source Code’:the human-readable form of the Work which is the most convenient for people to study and 
+modify. 
+— ‘The Executable Code’:any code which has generally been compiled and which is meant to be interpreted by 
+a computer as a program. 
+— ‘The Licensor’:the natural or legal person that distributes or communicates the Work under the Licence. 
+— ‘Contributor(s)’:any natural or legal person who modifies the Work under the Licence, or otherwise contributes to 
+the creation of a Derivative Work. 
+— ‘The Licensee’ or ‘You’:any natural or legal person who makes any usage of the Work under the terms of the 
+Licence. 
+— ‘Distribution’ or ‘Communication’:any act of selling, giving, lending, renting, distributing, communicating, 
+transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential 
+functionalities at the disposal of any other natural or legal person. 
+
+2.Scope of the rights granted by the Licence 
+The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for 
+the duration of copyright vested in the Original Work: 
+— use the Work in any circumstance and for all usage, 
+— reproduce the Work, 
+— modify the Work, and make Derivative Works based upon the Work, 
+— communicate to the public, including the right to make available or display the Work or copies thereof to the public 
+and perform publicly, as the case may be, the Work, 
+— distribute the Work or copies thereof, 
+— lend and rent the Work or copies thereof, 
+— sublicense rights in the Work or copies thereof. 
+Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the 
+applicable law permits so. 
+In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed 
+by law in order to make effective the licence of the economic rights here above listed. 
+The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the 
+extent necessary to make use of the rights granted on the Work under this Licence. 
+
+3.Communication of the Source Code 
+The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as 
+Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with 
+each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to 
+the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to 
+distribute or communicate the Work. 
+
+4.Limitations on copyright 
+Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the 
+exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations 
+thereto. 
+
+5.Obligations of the Licensee 
+The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those 
+obligations are the following: 
+
+Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to 
+the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the 
+Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work 
+to carry prominent notices stating that the Work has been modified and the date of modification. 
+
+Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this 
+Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless 
+the Original Work is expressly distributed only under this version of the Licence — for example by communicating 
+‘EUPL v. 1.2 only’. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the 
+Work or Derivative Work that alter or restrict the terms of the Licence. 
+
+Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both 
+the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done 
+under the terms of this Compatible Licence. For the sake of this clause, ‘Compatible Licence’ refers to the licences listed 
+in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with 
+his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail. 
+
+Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide 
+a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available 
+for as long as the Licensee continues to distribute or communicate the Work. 
+Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names 
+of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and 
+reproducing the content of the copyright notice. 
+
+6.Chain of Authorship 
+The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or 
+licensed to him/her and that he/she has the power and authority to grant the Licence. 
+Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or 
+licensed to him/her and that he/she has the power and authority to grant the Licence. 
+Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions 
+to the Work, under the terms of this Licence. 
+
+7.Disclaimer of Warranty 
+The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work 
+and may therefore contain defects or ‘bugs’ inherent to this type of development. 
+For the above reason, the Work is provided under the Licence on an ‘as is’ basis and without warranties of any kind 
+concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or 
+errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this 
+Licence. 
+This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work. 
+
+8.Disclaimer of Liability 
+Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be 
+liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the 
+Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss 
+of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, 
+the Licensor will be liable under statutory product liability laws as far such laws apply to the Work. 
+
+9.Additional agreements 
+While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services 
+consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole 
+responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, 
+defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by 
+the fact You have accepted any warranty or additional liability. 
+
+10.Acceptance of the Licence 
+The provisions of this Licence can be accepted by clicking on an icon ‘I agree’ placed under the bottom of a window 
+displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of 
+applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms 
+and conditions. 
+Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You 
+by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution 
+or Communication by You of the Work or copies thereof. 
+
+11.Information to the public 
+In case of any Distribution or Communication of the Work by means of electronic communication by You (for example, 
+by offering to download the Work from a remote location) the distribution channel or media (for example, a website) 
+must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence 
+and the way it may be accessible, concluded, stored and reproduced by the Licensee. 
+
+12.Termination of the Licence 
+The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms 
+of the Licence. 
+Such a termination will not terminate the licences of any person who has received the Work from the Licensee under 
+the Licence, provided such persons remain in full compliance with the Licence. 
+
+13.Miscellaneous 
+Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the 
+Work. 
+If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or 
+enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid 
+and enforceable. 
+The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of 
+the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. 
+New versions of the Licence will be published with a unique version number. 
+All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take 
+advantage of the linguistic version of their choice. 
+
+14.Jurisdiction 
+Without prejudice to specific agreement between parties, 
+— any litigation resulting from the interpretation of this License, arising between the European Union institutions, 
+bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice 
+of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union, 
+— any litigation arising between other parties and resulting from the interpretation of this License, will be subject to 
+the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business. 
+
+15.Applicable Law 
+Without prejudice to specific agreement between parties, 
+— this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat, 
+resides or has his registered office, 
+— this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside 
+a European Union Member State. 
+
+
+                                                         Appendix 
+
+‘Compatible Licences’ according to Article 5 EUPL are: 
+— GNU General Public License (GPL) v. 2, v. 3 
+— GNU Affero General Public License (AGPL) v. 3 
+— Open Software License (OSL) v. 2.1, v. 3.0 
+— Eclipse Public License (EPL) v. 1.0 
+— CeCILL v. 2.0, v. 2.1 
+— Mozilla Public Licence (MPL) v. 2 
+— GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3 
+— Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software 
+— European Union Public Licence (EUPL) v. 1.1, v. 1.2 
+— Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+).
+
+The European Commission may update this Appendix to later versions of the above licences without producing 
+a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the 
+covered Source Code from exclusive appropriation. 
+All other changes or additions to this Appendix require the production of a new EUPL version. 

pyas4-0.1.19.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyAS4