pyxroad 1.5.8__tar.gz

pyxroad-1.5.8/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: pyxroad
+Version: 1.5.8
+Summary: X-Road (Trembita) Python client library for SOAP-based service integration
+Author-email: Andrii Shapovalov <mt.andrey@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AndreyShapovalovVN/pyxroad
+Project-URL: Repository, https://github.com/AndreyShapovalovVN/pyxroad.git
+Project-URL: Documentation, https://trembita.gov.ua
+Keywords: x-road,xroad,trembita,soap,python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: lxml>=5.2.1
+Requires-Dist: Requests>=2.32.3
+Requires-Dist: setuptools>=70.0.0
+Requires-Dist: zeep>=4.0.0
+Requires-Dist: redis
+Provides-Extra: redis
+Requires-Dist: redis>=4.5.0; extra == "redis"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+
+# X-Road (Trembita) Python Client
+
+- **Version:** 1.5.6
+- **Web:** https://trembita.gov.ua
+- **Repository:** https://github.com/AndreyShapovalovVN/pyxroad
+- **Keywords:** x-road, xroad, trembita, python, soap
+
+A powerful Python client library for interacting with X-Road (Trembita) security servers.
+This library provides a convenient wrapper around the SOAP-based X-Road protocol, allowing
+developers to easily integrate X-Road services into their Python applications.
+
+## Supported Python Versions
+
+- Python 3.10+
+- Python 3.11+
+- Python 3.12+
+
+## Features
+
+- Easy-to-use SOAP client for X-Road services
+- Support for multiple cache backends (SQLite, Redis, In-Memory)
+- Automatic SOAP header management
+- Transaction ID tracking
+- Configurable logging
+- Type hints for better IDE support
+
+## Installation from GitHub
+
+Using pip:
+
+```bash
+pip install git+https://github.com/AndreyShapovalovVN/pyxroad.git#egg=pyxroad
+```
+
+Or clone and install locally:
+
+```bash
+git clone https://github.com/AndreyShapovalovVN/pyxroad.git
+cd pyxroad
+pip install -e .
+```
+
+## Requirements
+
+- lxml >= 5.2.1
+- Requests >= 2.32.3
+- setuptools >= 68.1.2
+- zeep >= 4.0.0
+- redis (optional, for Redis cache support)
+
+## Code Quality Checks
+
+Run the same checks locally as in CI:
+
+```bash
+ruff check . --extend-exclude 'tests/~*.py'
+mypy . --ignore-missing-imports --pretty --show-error-codes --exclude 'tests/~.*\.py$'
+pytest --maxfail=2 --disable-warnings --ignore-glob='tests/~*.py'
+```
+
+## Quick Start
+
+Basic usage example:
+
+```python
+from XRoad import XClient, Transport, SqliteCache
+import logging
+import sys
+
+# Configure logging
+logging.basicConfig(
+    stream=sys.stdout,
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'
+)
+_logger = logging.getLogger('XRoad')
+
+# Create a client instance
+client = XClient(
+    ssu="http://security-server:8080",
+    client='SEVDEIR-TEST/GOV/00013480/100001',
+    service='SEVDEIR-TEST/GOV/00032684/MIA_prod/CheckPassportStatus/v0.1'
+)
+
+# Make a service request
+try:
+    response = client.request(
+        xroad_id='ABCD123456',  # Optional: set custom request ID
+        PasNumber='AA123456',
+        PasSerial='654321'
+    )
+    _logger.info(f"Response: {response}")
+except Exception as err:
+    _logger.error(f"Error: {err}")
+```
+
+## Advanced Usage
+
+Using custom caching backend:
+
+```python
+from XRoad import XClient, Transport, RedisCache
+
+# With Redis cache
+redis_cache = RedisCache(path='redis://localhost:6379/0', timeout=3600)
+transport = Transport(cache=redis_cache)
+
+client = XClient(
+    ssu="http://security-server:8080",
+    client='SEVDEIR-TEST/GOV/00013480/100001',
+    service='SEVDEIR-TEST/GOV/00032684/MIA_prod/CheckPassportStatus/v0.1',
+    transport=transport
+)
+```
+
+Setting custom headers:
+
+```python
+client.userId = '0123456789'  # Custom user ID
+client.id = 'ABCD123456'      # Custom request ID
+```
+
+## Available Cache Types
+
+- **InMemoryCache**: Default, stores cache in application memory
+- **SqliteCache**: Persistent cache using SQLite database
+- **RedisCache**: Distributed cache using Redis
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Support
+
+For issues, questions, and contributions, please visit:
+https://github.com/AndreyShapovalovVN/pyxroad

pyxroad-1.5.8/README.md

@@ -0,0 +1,136 @@
+# X-Road (Trembita) Python Client
+
+- **Version:** 1.5.6
+- **Web:** https://trembita.gov.ua
+- **Repository:** https://github.com/AndreyShapovalovVN/pyxroad
+- **Keywords:** x-road, xroad, trembita, python, soap
+
+A powerful Python client library for interacting with X-Road (Trembita) security servers.
+This library provides a convenient wrapper around the SOAP-based X-Road protocol, allowing
+developers to easily integrate X-Road services into their Python applications.
+
+## Supported Python Versions
+
+- Python 3.10+
+- Python 3.11+
+- Python 3.12+
+
+## Features
+
+- Easy-to-use SOAP client for X-Road services
+- Support for multiple cache backends (SQLite, Redis, In-Memory)
+- Automatic SOAP header management
+- Transaction ID tracking
+- Configurable logging
+- Type hints for better IDE support
+
+## Installation from GitHub
+
+Using pip:
+
+```bash
+pip install git+https://github.com/AndreyShapovalovVN/pyxroad.git#egg=pyxroad
+```
+
+Or clone and install locally:
+
+```bash
+git clone https://github.com/AndreyShapovalovVN/pyxroad.git
+cd pyxroad
+pip install -e .
+```
+
+## Requirements
+
+- lxml >= 5.2.1
+- Requests >= 2.32.3
+- setuptools >= 68.1.2
+- zeep >= 4.0.0
+- redis (optional, for Redis cache support)
+
+## Code Quality Checks
+
+Run the same checks locally as in CI:
+
+```bash
+ruff check . --extend-exclude 'tests/~*.py'
+mypy . --ignore-missing-imports --pretty --show-error-codes --exclude 'tests/~.*\.py$'
+pytest --maxfail=2 --disable-warnings --ignore-glob='tests/~*.py'
+```
+
+## Quick Start
+
+Basic usage example:
+
+```python
+from XRoad import XClient, Transport, SqliteCache
+import logging
+import sys
+
+# Configure logging
+logging.basicConfig(
+    stream=sys.stdout,
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'
+)
+_logger = logging.getLogger('XRoad')
+
+# Create a client instance
+client = XClient(
+    ssu="http://security-server:8080",
+    client='SEVDEIR-TEST/GOV/00013480/100001',
+    service='SEVDEIR-TEST/GOV/00032684/MIA_prod/CheckPassportStatus/v0.1'
+)
+
+# Make a service request
+try:
+    response = client.request(
+        xroad_id='ABCD123456',  # Optional: set custom request ID
+        PasNumber='AA123456',
+        PasSerial='654321'
+    )
+    _logger.info(f"Response: {response}")
+except Exception as err:
+    _logger.error(f"Error: {err}")
+```
+
+## Advanced Usage
+
+Using custom caching backend:
+
+```python
+from XRoad import XClient, Transport, RedisCache
+
+# With Redis cache
+redis_cache = RedisCache(path='redis://localhost:6379/0', timeout=3600)
+transport = Transport(cache=redis_cache)
+
+client = XClient(
+    ssu="http://security-server:8080",
+    client='SEVDEIR-TEST/GOV/00013480/100001',
+    service='SEVDEIR-TEST/GOV/00032684/MIA_prod/CheckPassportStatus/v0.1',
+    transport=transport
+)
+```
+
+Setting custom headers:
+
+```python
+client.userId = '0123456789'  # Custom user ID
+client.id = 'ABCD123456'      # Custom request ID
+```
+
+## Available Cache Types
+
+- **InMemoryCache**: Default, stores cache in application memory
+- **SqliteCache**: Persistent cache using SQLite database
+- **RedisCache**: Distributed cache using Redis
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Support
+
+For issues, questions, and contributions, please visit:
+https://github.com/AndreyShapovalovVN/pyxroad

pyxroad-1.5.8/XRoad/Members.py

@@ -0,0 +1,104 @@
+import logging
+from dataclasses import dataclass
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Members:
+    """
+    This class is used to parse the memberPath and create a dictionary with the member details.
+    """
+
+    objectType: str
+    memberPath: str
+    xRoadInstance: str | None = None
+    memberClass: str | None = None
+    memberCode: str | None = None
+    subsystemCode: str | None = None
+    serviceCode: str | None = None
+    serviceVersion: str | None = None
+
+    def __post_init__(self):
+        """
+        This method is used to parse the memberPath and assign the values to the class variables.
+        :return:
+        """
+        _logger.debug(f"Members init: {self.memberPath}")
+        if self.memberPath:
+            for iteration, val in enumerate(self.memberPath.split("/")):
+                match iteration:
+                    case 0:
+                        self.xRoadInstance = val
+                    case 1:
+                        self.memberClass = val
+                    case 2:
+                        self.memberCode = val
+                    case 3:
+                        self.subsystemCode = val
+                    case 4:
+                        self.serviceCode = val
+                    case 5:
+                        self.serviceVersion = val
+
+    @property
+    def wsdl_path(self) -> str:
+        """
+        This method returns the wsdl path for the service.
+        :return: String
+        """
+        if "SERVICE" in self.objectType:
+            _path = []
+            for key, value in self.member_dict.items():
+                if not value:
+                    _logger.debug(f"Skipping {key} as value is None")
+                    continue
+                if key in ("objectType", "memberPath"):
+                    _logger.debug(f"Skipping {key}")
+                    continue
+                if value is None:
+                    _logger.debug(f"Skipping {key}")
+                    continue
+                if "serviceVersion" in key:
+                    _logger.debug(f"Adding version={value}")
+                    _path.append(f"version={value}")
+                    continue
+                _logger.debug(f"Adding {key}={value}")
+                _path.append(f"{key}={value}")
+            _logger.info(f"wsdl path: {_path[:-1]}")
+            return "&".join(_path)
+        raise ValueError("wsdl_path is only available for SERVICE objectType")
+
+    def wsdl_url(self, ssu: str) -> str:
+        """
+        This method returns the wsdl url for the service.
+        :param: Ssu - url to securyt server
+        :return: String
+        """
+        _logger.info(f"Generating wsdl url for {ssu}")
+        return f"{ssu}/wsdl?{self.wsdl_path}"
+
+    @property
+    def member_dict(self) -> dict[str, str]:
+        """
+        This method returns the member details in a dictionary format.
+        :return: Dict
+        """
+        _logger.info("Returning member details as dictionary")
+        r = {}
+        if self.xRoadInstance:
+            r["xRoadInstance"] = self.xRoadInstance
+        if self.memberClass:
+            r["memberClass"] = self.memberClass
+        if self.memberCode:
+            r["memberCode"] = self.memberCode
+        if self.subsystemCode:
+            r["subsystemCode"] = self.subsystemCode
+        if self.serviceCode:
+            r["serviceCode"] = self.serviceCode
+        if self.serviceVersion:
+            r["serviceVersion"] = self.serviceVersion
+        if self.objectType:
+            r["objectType"] = self.objectType
+
+        return r

pyxroad-1.5.8/XRoad/__init__.py

@@ -0,0 +1,17 @@
+from .client import XClient
+from .transport import DRACTransport
+from zeep.cache import SqliteCache, InMemoryCache
+from zeep.transports import Transport
+from .cache import RedisCache
+
+__all__ = [
+    "XClient",
+    "Transport",
+    "DRACTransport",
+    "RedisCache",
+    "SqliteCache",
+    "InMemoryCache",
+]
+
+__author__ = "Andrii Shapovalov"
+__email__ = "mt.andrey@gmail.com"

pyxroad-1.5.8/XRoad/cache.py

@@ -0,0 +1,90 @@
+import hashlib
+import logging
+from typing import cast
+
+from redis import Redis
+from zeep.cache import Base
+
+_logger = logging.getLogger(__name__)
+
+
+class RedisCache(Base):
+    """
+    Provides a caching mechanism backed by Redis.
+
+    This class is designed for caching purposes, used Redis as the underlying
+    storage. It supports caching content with a specified time-to-live (TTL) and
+    identifying cached data through unique keys derived from URLs. The cache can
+    accommodate both storing and retrieving cached data, making it suitable for
+    applications requiring temporary storage of frequently accessed resources.
+
+    :ivar redis_client: A Redis client instance is used to interact with Redis.
+    :type redis_client: Redis
+    :ivar ttl: The time-to-live (in seconds) for cached content.
+    :type ttl: Int
+    :ivar prefix: The prefix used to generate cache keys.
+    :type prefix: String
+    """
+
+    _version = "1"
+
+    def __init__(self, path: str | Redis | None = None, timeout: int = 3600):
+        """
+        Initializes a cache object for managing data with Redis as a backend.
+
+        :param path: A Redis connection URL as a string or an instance of the Redis client
+            object. If none is provided, a TypeError is raised.
+        :param timeout: The time-to-live (TTL) for the cached data, specified in seconds.
+            Defaults to 3600 seconds (1 hour).
+
+        :raises TypeError: If `path` is not a string or an instance of Redis.
+        """
+        if isinstance(path, str):
+            self.redis_client = Redis.from_url(path)
+        elif isinstance(path, Redis):
+            self.redis_client = path
+        else:
+            raise TypeError("path must be str or Redis")
+        self.ttl = timeout
+        self.prefix = "zeep:cache:"
+
+    def _key(self, url: str) -> str:
+        digest = hashlib.sha256(url.encode("utf-8")).hexdigest()
+        return f"{self.prefix}{digest}"
+
+    def add(self, url: str, content: bytes):
+        """
+        Adds content to the cache associated with a specific URL.
+
+        This function caches the provided content using the URL as a key. The content is
+        stored in the cache for the configured time-to-live (TTL) period. The key used for
+        caching is generated from the URL, which ensures that the content is identifiable
+        and retrievable.
+
+        :param url: The URL to serve as the key for caching. It must be a string.
+        :param content: The content to cache, provided as a sequence of bytes.
+        :return: None
+        """
+        _logger.debug("Caching contents of %s", url)
+        key = self._key(url)
+        self.redis_client.set(key, content, ex=self.ttl)
+
+    def get(self, url: str) -> bytes | None:
+        """
+        Retrieve content from a cache based on the provided URL. If the content is
+        found in the cache (cache hit), it is returned. Otherwise, it logs a cache
+        miss and returns None.
+
+        :param url: The URL used to retrieve the cached content.
+        :type url: String
+        :return: The cached content as bytes if the key exists in the cache; None
+            otherwise.
+        :rtype: Bytes or None
+        """
+        key = self._key(url)
+        content = cast(bytes | None, self.redis_client.get(key))
+        if content:
+            _logger.debug("Cache HIT for %s", url)
+            return content
+        _logger.debug("Cache MISS for %s", url)
+        return None

pyxroad-1.5.8/XRoad/client.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import logging
+import uuid
+
+from zeep import Client
+from zeep.cache import InMemoryCache
+from zeep.exceptions import Fault
+from zeep.helpers import serialize_object
+from zeep.transports import Transport
+
+from .Members import Members
+
+_logger = logging.getLogger("XRoad")
+
+
+class XClient(Client):
+    """
+    A specialized client class for interacting with X-Road services.
+
+    This class extends the base Client class and provides a mechanism to interact
+    with X-Road systems by implementing SOAP-based service requests. It also manages
+    the construction of appropriate SOAP headers and using default namespaces
+    required by the X-Road environment. The class is capable of handling session
+    setup, ensuring proper initialization of member and service objects, and
+    handling request serialization.
+
+    :ivar response: Holds the response of the latest SOAP request.
+    :type response: Any
+    """
+
+    _version = 4.0
+
+    def __init__(
+            self, ssu: str, client: str, service: str, transport: object | None = None, *args, **kwargs
+    ):
+        """
+        Initializes an instance of the class, configuring service and client details along with
+        SOAP header and transport setup. Validates the presence of required parameters and sets
+        default SOAP headers used for communication.
+
+        :param ssu: The subsystem uniform resource identifier or endpoint to connect.
+        :type ssu: String
+        :param client: The client subsystem identifier in the X-Road ecosystem.
+        :type client: String
+        :param service: The service identifier within the X-Road ecosystem to be accessed.
+        :type service: String
+        :param transport: Optional transport object for handling HTTP requests. Defaults
+            to an instance of `Transport` with in-memory caching if not provided.
+        :type transport: Object | None
+        :param args: Additional positional arguments to be passed to the parent class
+            initializer.
+        :param kwargs: Additional keyword arguments to be passed to the parent class
+            initializer.
+
+        :raises ValueError: If the `service` parameter is not provided.
+        :raises ValueError: If the `client` parameter is not provided.
+        """
+
+        self.response = None
+
+        if not service:
+            raise ValueError("service - required")
+        if not client:
+            raise ValueError("client - required")
+
+        client_member = Members(objectType="SUBSYSTEM", memberPath=client)
+        service_member = Members(objectType="SERVICE", memberPath=service)
+
+        if "transport" not in kwargs:
+            kwargs["transport"] = transport if transport else Transport(InMemoryCache(timeout=60))
+
+        super().__init__(
+            service_member.wsdl_url(ssu),
+            *args,
+            **kwargs,
+        )
+
+        self.transport.session.proxies.update({"http": ssu, })
+
+        self.set_ns_prefix("xro", "https://x-road.eu/xsd/xroad.xsd")
+        self.set_ns_prefix("iden", "https://x-road.eu/xsd/identifiers")
+
+        self.set_default_soapheaders(
+            {
+                "client": client_member.member_dict,
+                "service": service_member.member_dict,
+                "userId": client_member.subsystemCode,
+                "id": uuid.uuid4().hex,
+                "protocolVersion": self._version,
+            }
+        )
+        _logger.debug("Default header (%s)", self._default_soapheaders)
+
+    def request(self, **kwargs):
+        """
+        Handles SOAP service requests with the ability to specify custom arguments and
+        default configurations. The method attempts to process the request with the
+        specified arguments, perform serialization of the response object, and handle
+        any potential SOAP Fault exceptions that may occur.
+
+        :param kwargs: Arbitrary keyword arguments to be passed to the SOAP service
+            request. These may include service-specific parameters or optional settings.
+            If an argument with the key 'xroad_id' is supplied, it will set the 'id'
+            attribute of the instance.
+        :return: Serialized response object from the SOAP service.
+        :rtype: Any
+        :raises Fault: If a SOAP Fault exception occurs during the service call, it is
+            raised after logging the error details.
+        """
+
+        service = self._default_soapheaders["service"].get("serviceCode")
+        if "xroad_id" in kwargs:
+            self.id = kwargs.pop("xroad_id")
+
+        try:
+            response = self.service[service](**kwargs)
+        except Fault as error:
+            _logger.error("service error (%s: %s)", error.code, error.message)
+            raise Fault(error)
+        else:
+            s_object = serialize_object(response)
+            _logger.debug("Response (%s)", s_object)
+            return s_object
+
+    @property
+    def id(self):
+        """
+        Provides access to the `id` property representing a specific identifier contained within the
+        default SOAP header. This property fetches and returns the associated identifier value from
+        a predefined key called "id" in the default SOAP headers.
+
+        The property is read-only and allows retrieval of the value, but no direct modifications
+        to the object’s underlying internal data structures.
+
+        :rtype: Any
+        :return: The value corresponding to the "id" key in the default SOAP headers.
+        """
+        return self._default_soapheaders.get("id")
+
+    @id.setter
+    def id(self, value):
+        """
+        Sets the value of the `id` attribute and updates the corresponding SOAP
+        headers. This setter ensures that the `id` value is synchronized with
+        the default SOAP headers and logs the operation for debugging purposes.
+
+        :param value: The new value to set for the `id` attribute. This value
+            is used to update the `_default_soapheaders`.
+        :type value: Any
+        """
+
+        self._default_soapheaders["id"] = value
+        self.set_default_soapheaders(self._default_soapheaders)
+        _logger.debug("Set (id: %s)", value)
+
+    @property
+    def userId(self) -> str | None:
+        """
+        Provides access to the userId obtained from default SOAP headers.
+
+        This property is a getter that retrieves the value of the "userId" field
+        from the default SOAP headers set in the object. It is meant to provide a
+        convenient way to access this specific information if it exists in the
+        SOAP headers.
+
+        :rtype: String
+        :return: The value of "userId" from the default SOAP headers if it exists,
+            otherwise returns None.
+        """
+        return self._default_soapheaders.get("userId")  # type: ignore[no-any-return]
+
+    @userId.setter
+    def userId(self, value: str):
+        """
+        Sets the userId value into the default SOAP headers and updates the headers accordingly.
+        Logs the userId value upon setting for debugging purposes.
+
+        :param value: The userId value to be set in the default SOAP headers.
+        :type value: String
+        """
+
+        self._default_soapheaders["userId"] = value
+        self.set_default_soapheaders(self._default_soapheaders)
+        _logger.debug("Set (userId: %s)", value)

pyxroad-1.5.8/XRoad/plugins.py

@@ -0,0 +1,55 @@
+import datetime
+import logging
+from email.utils import parsedate_to_datetime
+
+from zeep.plugins import HistoryPlugin
+
+_logger = logging.getLogger(__name__)
+
+
+class UXPHistoryPlugin(HistoryPlugin):
+    """
+    Represents a plugin for handling history-related functionality specific to UXP.
+
+    This class is a specialized extension of the generic HistoryPlugin, designed to
+    handle UXP-specific headers, such as transaction ID and transaction date. The
+    primary purpose of this plugin is to extract and provide easy access to these
+    pieces of information from HTTP headers.
+
+    :ivar last_received: Stores the last received HTTP headers and potentially other
+        related data.
+    :type last_received: dict
+    """
+    @property
+    def transaction_id(self) -> str:
+        """
+        Retrieves the transaction ID from the HTTP headers of the last received
+        request. This ID is used to track a specific transaction across
+        the system.
+
+        :rtype: String
+        :return: The transaction ID as a string. If the "uxp-transaction-id" header
+            is not present, an empty string is returned.
+        """
+        transaction: str = self.last_received["http_headers"].get(  # type: ignore
+            "uxp-transaction-id", ""
+        )
+        return transaction
+
+    @property
+    def transaction_date(self) -> datetime.datetime | None:
+        """
+        Retrieves the transaction date from the "Date" field in the HTTP headers. If the "Date"
+        field is not a valid datetime format, the current datetime will be returned instead.
+
+        :return: The transaction date parsed as a `datetime.datetime` object or the current
+                 datetime if parsing fails.
+        :rtype: datetime.datetime | None
+        """
+        try:
+            date = parsedate_to_datetime(
+                self.last_received["http_headers"].get("Date", "")  # type: ignore
+            )
+        except ValueError:
+            date = datetime.datetime.now()
+        return date

pyxroad-1.5.8/XRoad/transport.py

@@ -0,0 +1,31 @@
+import logging
+
+from lxml import etree
+from zeep.transports import Transport
+
+_logger = logging.getLogger("DRACTransport")
+
+
+class DRACTransport(Transport):
+    """
+    Handles communication with the DRAC (Державни Реестр Актових Записів) service.
+
+    This class is responsible for sending messages to the DRAC service by formatting
+    XML envelopes appropriately. It used the Transport parent class for underlying
+    communication mechanisms.
+    """
+
+    def post_xml(self, address, envelope, headers):
+        message = etree.tostring(
+            envelope, pretty_print=True, xml_declaration=True, encoding="utf-8"
+        ).decode("utf-8")
+
+        _logger.debug(f"Source: \n {message}")
+        drac_message = ""
+        for line in message.splitlines():
+            drac_message += line
+            if "iden:" not in line:
+                drac_message += "\n"
+        _logger.debug(f"Modified: \n {drac_message}")
+
+        return self.post(address, drac_message.encode("utf-8"), headers)

pyxroad-1.5.8/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["setuptools>=70.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyxroad"
+version = "1.5.8"
+description = "X-Road (Trembita) Python client library for SOAP-based service integration"
+authors = [{ name = "Andrii Shapovalov", email = "mt.andrey@gmail.com" }]
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["x-road", "xroad", "trembita", "soap", "python"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Networking",
+]
+dependencies = [
+    "lxml>=5.2.1",
+    "Requests>=2.32.3",
+    "setuptools>=70.0.0",
+    "zeep>=4.0.0",
+    "redis",
+]
+
+[project.optional-dependencies]
+redis = ["redis>=4.5.0"]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+    "mypy>=1.0.0",
+    "black>=23.0.0",
+    "flake8>=6.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AndreyShapovalovVN/pyxroad"
+Repository = "https://github.com/AndreyShapovalovVN/pyxroad.git"
+Documentation = "https://trembita.gov.ua"
+
+[tool.setuptools]
+packages = ["XRoad"]
+
+[tool.setuptools.package-data]
+XRoad = ["py.typed"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+
+[tool.ruff]
+target-version = "py310"
+
+[tool.black]
+line-length = 100
+target-version = ["py310", "py311", "py312"]

pyxroad-1.5.8/pyxroad.egg-info/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: pyxroad
+Version: 1.5.8
+Summary: X-Road (Trembita) Python client library for SOAP-based service integration
+Author-email: Andrii Shapovalov <mt.andrey@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AndreyShapovalovVN/pyxroad
+Project-URL: Repository, https://github.com/AndreyShapovalovVN/pyxroad.git
+Project-URL: Documentation, https://trembita.gov.ua
+Keywords: x-road,xroad,trembita,soap,python
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: lxml>=5.2.1
+Requires-Dist: Requests>=2.32.3
+Requires-Dist: setuptools>=70.0.0
+Requires-Dist: zeep>=4.0.0
+Requires-Dist: redis
+Provides-Extra: redis
+Requires-Dist: redis>=4.5.0; extra == "redis"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+
+# X-Road (Trembita) Python Client
+
+- **Version:** 1.5.6
+- **Web:** https://trembita.gov.ua
+- **Repository:** https://github.com/AndreyShapovalovVN/pyxroad
+- **Keywords:** x-road, xroad, trembita, python, soap
+
+A powerful Python client library for interacting with X-Road (Trembita) security servers.
+This library provides a convenient wrapper around the SOAP-based X-Road protocol, allowing
+developers to easily integrate X-Road services into their Python applications.
+
+## Supported Python Versions
+
+- Python 3.10+
+- Python 3.11+
+- Python 3.12+
+
+## Features
+
+- Easy-to-use SOAP client for X-Road services
+- Support for multiple cache backends (SQLite, Redis, In-Memory)
+- Automatic SOAP header management
+- Transaction ID tracking
+- Configurable logging
+- Type hints for better IDE support
+
+## Installation from GitHub
+
+Using pip:
+
+```bash
+pip install git+https://github.com/AndreyShapovalovVN/pyxroad.git#egg=pyxroad
+```
+
+Or clone and install locally:
+
+```bash
+git clone https://github.com/AndreyShapovalovVN/pyxroad.git
+cd pyxroad
+pip install -e .
+```
+
+## Requirements
+
+- lxml >= 5.2.1
+- Requests >= 2.32.3
+- setuptools >= 68.1.2
+- zeep >= 4.0.0
+- redis (optional, for Redis cache support)
+
+## Code Quality Checks
+
+Run the same checks locally as in CI:
+
+```bash
+ruff check . --extend-exclude 'tests/~*.py'
+mypy . --ignore-missing-imports --pretty --show-error-codes --exclude 'tests/~.*\.py$'
+pytest --maxfail=2 --disable-warnings --ignore-glob='tests/~*.py'
+```
+
+## Quick Start
+
+Basic usage example:
+
+```python
+from XRoad import XClient, Transport, SqliteCache
+import logging
+import sys
+
+# Configure logging
+logging.basicConfig(
+    stream=sys.stdout,
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'
+)
+_logger = logging.getLogger('XRoad')
+
+# Create a client instance
+client = XClient(
+    ssu="http://security-server:8080",
+    client='SEVDEIR-TEST/GOV/00013480/100001',
+    service='SEVDEIR-TEST/GOV/00032684/MIA_prod/CheckPassportStatus/v0.1'
+)
+
+# Make a service request
+try:
+    response = client.request(
+        xroad_id='ABCD123456',  # Optional: set custom request ID
+        PasNumber='AA123456',
+        PasSerial='654321'
+    )
+    _logger.info(f"Response: {response}")
+except Exception as err:
+    _logger.error(f"Error: {err}")
+```
+
+## Advanced Usage
+
+Using custom caching backend:
+
+```python
+from XRoad import XClient, Transport, RedisCache
+
+# With Redis cache
+redis_cache = RedisCache(path='redis://localhost:6379/0', timeout=3600)
+transport = Transport(cache=redis_cache)
+
+client = XClient(
+    ssu="http://security-server:8080",
+    client='SEVDEIR-TEST/GOV/00013480/100001',
+    service='SEVDEIR-TEST/GOV/00032684/MIA_prod/CheckPassportStatus/v0.1',
+    transport=transport
+)
+```
+
+Setting custom headers:
+
+```python
+client.userId = '0123456789'  # Custom user ID
+client.id = 'ABCD123456'      # Custom request ID
+```
+
+## Available Cache Types
+
+- **InMemoryCache**: Default, stores cache in application memory
+- **SqliteCache**: Persistent cache using SQLite database
+- **RedisCache**: Distributed cache using Redis
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Support
+
+For issues, questions, and contributions, please visit:
+https://github.com/AndreyShapovalovVN/pyxroad

pyxroad-1.5.8/pyxroad.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+XRoad/Members.py
+XRoad/__init__.py
+XRoad/cache.py
+XRoad/client.py
+XRoad/plugins.py
+XRoad/transport.py
+pyxroad.egg-info/PKG-INFO
+pyxroad.egg-info/SOURCES.txt
+pyxroad.egg-info/dependency_links.txt
+pyxroad.egg-info/requires.txt
+pyxroad.egg-info/top_level.txt
+tests/test_members.py

pyxroad-1.5.8/pyxroad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyxroad-1.5.8/pyxroad.egg-info/requires.txt

@@ -0,0 +1,15 @@
+lxml>=5.2.1
+Requests>=2.32.3
+setuptools>=70.0.0
+zeep>=4.0.0
+redis
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0
+mypy>=1.0.0
+black>=23.0.0
+flake8>=6.0.0
+
+[redis]
+redis>=4.5.0

pyxroad-1.5.8/pyxroad.egg-info/top_level.txt

@@ -0,0 +1 @@
+XRoad

pyxroad-1.5.8/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyxroad-1.5.8/tests/test_members.py

@@ -0,0 +1,80 @@
+import unittest
+
+from XRoad.Members import Members
+
+
+class TestMembers(unittest.TestCase):
+    def test_initialization_with_full_path(self):
+        member = Members(
+            objectType="SERVICE",
+            memberPath="instance/class/code/subsystem/service/serviceVersion",
+        )
+
+        self.assertEqual(member.xRoadInstance, "instance")
+        self.assertEqual(member.memberClass, "class")
+        self.assertEqual(member.memberCode, "code")
+        self.assertEqual(member.subsystemCode, "subsystem")
+        self.assertEqual(member.serviceCode, "service")
+        self.assertEqual(member.serviceVersion, "serviceVersion")
+
+    def test_initialization_with_partial_path(self):
+        member = Members(objectType="SERVICE", memberPath="instance/class")
+
+        self.assertEqual(member.xRoadInstance, "instance")
+        self.assertEqual(member.memberClass, "class")
+        self.assertIsNone(member.memberCode)
+        self.assertIsNone(member.subsystemCode)
+        self.assertIsNone(member.serviceCode)
+        self.assertIsNone(member.serviceVersion)
+
+    def test_wsdl_path_generation(self):
+        member = Members(
+            objectType="SERVICE",
+            memberPath="instance/class/code/subsystem/service/serviceVersion",
+        )
+        expected_wsdl_path = "xRoadInstance=instance&memberClass=class&memberCode=code&subsystemCode=subsystem&serviceCode=service&version=serviceVersion"
+
+        self.assertEqual(member.wsdl_path, expected_wsdl_path)
+
+    def test_wsdl_url(self):
+        member = Members(
+            objectType="SERVICE",
+            memberPath="instance/class/code/subsystem/service/serviceVersion",
+        )
+        ssu = "https://example.com"
+        expected_wsdl_path = "xRoadInstance=instance&memberClass=class&memberCode=code&subsystemCode=subsystem&serviceCode=service&version=serviceVersion"
+        expected_url = f"{ssu}/wsdl?{expected_wsdl_path}"
+
+        self.assertEqual(member.wsdl_url(ssu), expected_url)
+
+    def test_member_dict(self):
+        member = Members(
+            objectType="SERVICE",
+            memberPath="instance/class/code/subsystem/service/serviceVersion",
+        )
+        expected_dict = {
+            "xRoadInstance": "instance",
+            "memberClass": "class",
+            "memberCode": "code",
+            "subsystemCode": "subsystem",
+            "serviceCode": "service",
+            "serviceVersion": "serviceVersion",
+            "objectType": "SERVICE",
+        }
+
+        self.assertDictEqual(member.member_dict, expected_dict)
+
+    def test_wsdl_path_none_for_non_service(self):
+        member = Members(
+            objectType="OTHER_TYPE",
+            memberPath="instance/class/code/subsystem/service/serviceVersion",
+        )
+        with self.assertRaises(ValueError) as ctx:
+            _ = member.wsdl_path
+        self.assertEqual(
+            str(ctx.exception), "wsdl_path is only available for SERVICE objectType"
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()