python3-commons 0.18.7__tar.gz → 0.18.8__tar.gz

{python3_commons-0.18.7/src/python3_commons.egg-info → python3_commons-0.18.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python3-commons
-Version: 0.18.7
+Version: 0.18.8
 Summary: Re-usable Python3 code
 Author-email: Oleg Korsak <kamikaze.is.waiting.you@gmail.com>
 License-Expression: GPL-3.0

{python3_commons-0.18.7 → python3_commons-0.18.8}/src/python3_commons/soap_client.py

@@ -1,11 +1,6 @@
-"""
-Async SOAP client built on aiohttp + zeep.
-"""
-
 from __future__ import annotations
 
 import asyncio
-import concurrent.futures
 import logging
 import ssl
 from collections.abc import AsyncIterator, Sequence
@@ -13,10 +8,9 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Self
 
-import certifi
-
 try:
     import aiohttp
+    import certifi
     from aiohttp import ClientSession, ClientTimeout, TCPConnector
     from requests import Response
     from requests.cookies import RequestsCookieJar
@@ -38,55 +32,48 @@ logger = logging.getLogger(__name__)
 
 def _make_ssl_context(*, verify: bool) -> ssl.SSLContext | bool:
     if not verify:
-        return False  # aiohttp accepts False to disable verification
+        return False
 
     return ssl.create_default_context(cafile=certifi.where())
 
 
 @dataclass(frozen=True, slots=True)
 class TransportConfig:
-    """Immutable transport settings passed to AsyncTransport."""
-
     timeout: int = 300
-    """Total timeout in seconds for WSDL fetches."""
-
     operation_timeout: int = 60
-    """Total timeout in seconds for SOAP operation calls."""
-
     verify_ssl: bool = True
     proxy: str | None = None
 
 
-class AsyncTransport(Transport):
-    """
-    Async transport for zeep using aiohttp.
-
-    Usage::
+# -------------------------
+# Transport
+# -------------------------
 
-        async with soap_client("https://example.com/service?wsdl") as client:
-            result = await client.service.SomeOperation(...)
-    """
 
+class AsyncTransport(Transport):
     def __init__(
-            self,
-            *,
-            session: ClientSession,
-            config: TransportConfig,
-            _owns_session: bool = False,
+        self,
+        *,
+        session: ClientSession,
+        config: TransportConfig,
+        loop: asyncio.AbstractEventLoop,
+        owns_session: bool = False,
     ) -> None:
         super().__init__()
         self._session = session
         self._config = config
-        self._owns_session = _owns_session
+        self._loop = loop
+        self._owns_session = owns_session
 
     @classmethod
     def from_config(
-            cls,
-            config: TransportConfig | None = None,
-            *,
-            session: ClientSession | None = None,
-    ) -> Self:
+        cls,
+        config: TransportConfig | None = None,
+        *,
+        session: ClientSession | None = None,
+    ) -> AsyncTransport:
         config = config or TransportConfig()
+        loop = asyncio.get_running_loop()
         owns_session = session is None
 
         if owns_session:
@@ -96,7 +83,12 @@ class AsyncTransport(Transport):
                 headers={'User-Agent': f'Zeep/{get_version()} (www.python-zeep.org)'},
             )
 
-        return cls(session=session, config=config, _owns_session=owns_session)
+        return cls(
+            session=session,
+            config=config,
+            loop=loop,
+            owns_session=owns_session,
+        )
 
     async def aclose(self) -> None:
         if self._owns_session:
@@ -110,7 +102,6 @@ class AsyncTransport(Transport):
 
     @staticmethod
     def _build_response(response: aiohttp.ClientResponse, body: bytes) -> Response:
-        """Convert an aiohttp response into a requests.Response for zeep."""
         r = Response()
         r.status_code = response.status
         r._content = body  # noqa: SLF001
@@ -127,116 +118,112 @@ class AsyncTransport(Transport):
 
         return r
 
+    async def _fetch(self, url: str) -> bytes:
+        async with self._session.get(
+            url,
+            proxy=self._config.proxy,
+            timeout=ClientTimeout(total=self._config.timeout),
+        ) as resp:
+            body = await resp.read()
+
+            if resp.status >= 400:
+                raise TransportError(
+                    status_code=resp.status,
+                    message=body.decode(errors='ignore'),
+                )
+
+            return body
+
     def load(self, url: str) -> bytes:
         """
-        Sync entry-point zeep calls during WSDL document init.
+        Called synchronously by zeep during WSDL parsing.
 
-        Creates a short-lived session confined to its own event loop so there
-        is no cross-loop session sharing with the operational session.
+        We safely hop into the main loop.
         """
         if not url:
             return b''
 
-        async def _fetch() -> bytes:
-            async with (
-                ClientSession(
-                    connector=TCPConnector(ssl=_make_ssl_context(verify=self._config.verify_ssl)),
-                    timeout=ClientTimeout(total=self._config.timeout),
-                    headers={'User-Agent': f'Zeep/{get_version()} (www.python-zeep.org)'},
-                ) as session,
-                session.get(url, proxy=self._config.proxy) as resp,
-            ):
-                content = await resp.read()
-
-                if resp.status >= 400:
-                    raise TransportError(
-                        status_code=resp.status,
-                        message=content.decode(errors='ignore'),
-                    )
-
-                return content
-
-        # load() is always called from within a running event loop (during
-        # AsyncClient.__init__ inside the soap_client context manager), so
-        # run_until_complete on the running loop would raise. Always delegate
-        # to a thread with its own fresh event loop.
-        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-            return pool.submit(asyncio.run, _fetch()).result()
-
-    async def post(
-            self,
-            address: str,
-            message: bytes,
-            headers: dict[str, str],
-            *,
-            timeout: int | None = None,
-    ) -> Response:
-        logger.debug('SOAP POST → %s\n%s', address, message)
+        future = asyncio.run_coroutine_threadsafe(
+            self._fetch(url),
+            self._loop,
+        )
 
-        async with self._session.post(
-                address,
-                data=message,
-                headers=headers,
-                proxy=self._config.proxy,
-                timeout=ClientTimeout(total=timeout) if timeout is not None else None,
-        ) as resp:
-            body = await resp.read()
-            logger.debug('SOAP ← %s (HTTP %d)\n%s', address, resp.status, body)
-            return self._build_response(resp, body)
+        return future.result()
 
     def post_xml(
-            self,
-            address: str,
-            envelope: Any,
-            headers: dict[str, str],
+        self,
+        address: str,
+        envelope: Any,
+        headers: dict[str, str],
     ) -> Response:
-        """
-        Sync entry-point zeep calls from a thread executor during send_async.
-        Bridges back into the running event loop via run_coroutine_threadsafe.
-        """
-        loop = asyncio.get_event_loop()
         future = asyncio.run_coroutine_threadsafe(
             self.post(address, etree_to_string(envelope), headers),
-            loop,
+            self._loop,
         )
+
         return future.result()
 
+    async def post(
+        self,
+        address: str,
+        message: bytes,
+        headers: dict[str, str],
+        *,
+        timeout: int | None = None,
+    ) -> Response:
+        logger.debug('SOAP POST → %s', address)
+
+        async with self._session.post(
+            address,
+            data=message,
+            headers=headers,
+            proxy=self._config.proxy,
+            timeout=ClientTimeout(total=timeout) if timeout is not None else None,
+        ) as resp:
+            body = await resp.read()
+            logger.debug('SOAP ← %s (%d)', address, resp.status)
+            return self._build_response(resp, body)
+
     async def get(
-            self,
-            address: str,
-            params: dict[str, str],
-            headers: dict[str, str],
+        self,
+        address: str,
+        params: dict[str, str],
+        headers: dict[str, str],
     ) -> Response:
         async with self._session.get(
-                address,
-                params=params,
-                headers=headers,
-                proxy=self._config.proxy,
+            address,
+            params=params,
+            headers=headers,
+            proxy=self._config.proxy,
         ) as resp:
             body = await resp.read()
             return self._build_response(resp, body)
 
 
 def build_soap_client(
-        wsdl_url: str,
-        transport: AsyncTransport,
-        plugins: Sequence[Plugin] | None = None,
+    wsdl_url: str,
+    transport: AsyncTransport,
+    plugins: Sequence[Plugin] | None = None,
 ) -> AsyncClient:
     if not wsdl_url:
         msg = 'wsdl_url must be a non-empty string.'
 
         raise ValueError(msg)
 
-    return AsyncClient(wsdl_url, transport=transport, plugins=list(plugins or []))
+    return AsyncClient(
+        wsdl_url,
+        transport=transport,
+        plugins=list(plugins or []),
+    )
 
 
 @asynccontextmanager
 async def soap_client(
-        wsdl_url: str,
-        *,
-        config: TransportConfig | None = None,
-        session: ClientSession | None = None,
-        plugins: Sequence[Plugin] | None = None,
+    wsdl_url: str,
+    *,
+    config: TransportConfig | None = None,
+    session: ClientSession | None = None,
+    plugins: Sequence[Plugin] | None = None,
 ) -> AsyncIterator[AsyncClient]:
     """
     Async context manager yielding a ready-to-use zeep AsyncClient.

{python3_commons-0.18.7 → python3_commons-0.18.8/src/python3_commons.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python3-commons
-Version: 0.18.7
+Version: 0.18.8
 Summary: Re-usable Python3 code
 Author-email: Oleg Korsak <kamikaze.is.waiting.you@gmail.com>
 License-Expression: GPL-3.0