webmediator 0.9.2__tar.gz

webmediator-0.9.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonid Salavatov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

webmediator-0.9.2/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: webmediator
+Version: 0.9.2
+Summary: Python sync/async client for the WebMediator API
+Home-page: https://github.com/mustaddon/webmediator.git
+Author: Leonid Salavatov
+Author-email: mustaddon@gmail.com
+Keywords: WebMediator,CQRS,Mediator
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# webmediator
+Python sync/async client for the WebMediator API.
+
+
+*Sync*
+```python
+import webmediator
+
+client = webmediator.Client('https://localhost:7263/mediator')
+
+response = client.send('Ping', {'Message':'EXAMPLE' }):
+print(response)
+```
+
+*Async*
+```python
+import webmediator
+import asyncio
+
+async def main():
+    mediator = webmediator.AsyncClient('http://localhost:5263/mediator')
+
+    response = await client.send('Ping', {'Message':'EXAMPLE' }):
+    print(response)
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(main())
+```
+
+*Console output:*
+```
+type: Pong, data: {'Message': 'EXAMPLE PONG'}
+```

webmediator-0.9.2/README.md

@@ -0,0 +1,33 @@
+# webmediator
+Python sync/async client for the WebMediator API.
+
+
+*Sync*
+```python
+import webmediator
+
+client = webmediator.Client('https://localhost:7263/mediator')
+
+response = client.send('Ping', {'Message':'EXAMPLE' }):
+print(response)
+```
+
+*Async*
+```python
+import webmediator
+import asyncio
+
+async def main():
+    mediator = webmediator.AsyncClient('http://localhost:5263/mediator')
+
+    response = await client.send('Ping', {'Message':'EXAMPLE' }):
+    print(response)
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(main())
+```
+
+*Console output:*
+```
+type: Pong, data: {'Message': 'EXAMPLE PONG'}
+```

webmediator-0.9.2/setup.cfg

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

webmediator-0.9.2/setup.py

@@ -0,0 +1,42 @@
+# pip install httpx
+# pip install --upgrade setuptools wheel
+# python setup.py sdist bdist_wheel
+# pip install --upgrade twine
+## python -m twine upload dist/*
+
+
+import setuptools
+
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="webmediator",
+    version="0.9.2",
+    author="Leonid Salavatov",
+    author_email="mustaddon@gmail.com",
+    description="Python sync/async client for the WebMediator API",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/mustaddon/webmediator.git",
+    keywords=["WebMediator", "CQRS", "Mediator"],
+    #packages=['webmediator'],
+    # package_dir={'': 'src', 'webmediator': 'src/webmediator'},
+    package_dir={'': 'src'},
+    packages=setuptools.find_packages(where='src'),
+    classifiers=[
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent","Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
+    ],
+    install_requires=[ 'httpx' ],
+    python_requires='>=3.8',
+)

webmediator-0.9.2/src/webmediator/__init__.py

@@ -0,0 +1,20 @@
+from ._client import *
+from ._client_async import *
+from ._client_base import *
+from ._stream import *
+from ._stream_async import *
+
+__all__ = [
+    "Client",
+    "HttpStreamIO",
+
+    "AsyncClient",
+    "AsyncHttpStreamIO",
+
+    "Response"
+]
+
+__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "webmediator")  # noqa

webmediator-0.9.2/src/webmediator/_client.py

@@ -0,0 +1,125 @@
+import typing
+import ssl
+
+import httpx
+from httpx._types import AuthTypes, HeaderTypes, CookieTypes, CertTypes, ProxyTypes,TimeoutTypes
+from httpx._transports import BaseTransport
+from httpx._config import Limits, DEFAULT_LIMITS, DEFAULT_TIMEOUT_CONFIG, DEFAULT_MAX_REDIRECTS
+from httpx._client import EventHook
+
+from ._client_base import BaseClient, Response
+from ._stream import HttpStreamIO
+
+
+class Client(BaseClient):
+    def __init__(self, endpoint_url: str,
+        auth: AuthTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        verify: ssl.SSLContext | str | bool = False,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: ProxyTypes | None = None,
+        mounts: None | (typing.Mapping[str, BaseTransport | None]) = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        transport: BaseTransport | None = None,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+        response_stream_as_bytes = False
+    ):
+        super().__init__(endpoint_url)
+
+        self._response_stream_as_bytes = response_stream_as_bytes
+        self._client = httpx.Client(
+            base_url=self._endpoint_url,
+            auth=auth,
+            headers=headers,
+            cookies=cookies,
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            proxy=proxy,
+            mounts=mounts,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            limits=limits,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            transport=transport,
+            default_encoding=default_encoding)
+
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.close()
+
+    def close(self):
+        self._client.close()
+
+    def _get_result_stream(self, res: httpx.Response):
+        if not self._response_stream_as_bytes:
+            return HttpStreamIO(res)
+        
+        content=res.read()
+        res.close()
+        return content
+        
+    def _get_result(self, res: httpx.Response):
+        res.raise_for_status()
+
+        data_type = self._get_data_type(res)
+        
+        if res.status_code== 204:
+            res.close()
+            return Response(data_type)
+        
+        if not self._is_json_ctype(res):
+            streamProp = self._get_data_stream_property(res)
+
+            if streamProp:
+                data = self._get_data(res)
+                data[streamProp] = self._get_result_stream(res)
+
+                return Response(data_type,
+                    data = data,
+                    stream_ref = data[streamProp])
+            
+            data=self._get_result_stream(res)
+            return Response(data_type,
+                data = data,
+                stream_ref = data)
+        
+        res.read()
+        result = Response(data_type, res.json())
+        res.close()
+        return result
+    
+    def send(self, type: str, data=None):
+        if data == None:
+            return self._get_result(self._post(type))
+        
+        if self._is_stream(data):
+            return self._get_result(self._post(type, content=self._stream_content(data)))
+        
+        io_prop = self._get_stream_prop(data)
+
+        if io_prop:
+            copy = data.copy()
+            del copy[io_prop]
+            return self._get_result(self._post(
+                url=f"{type}?data={self._encode_json(copy)}", 
+                content=self._stream_content(data[io_prop])))
+
+        return self._get_result(self._post(type, json=data))
+    
+    def _post(self, url, json = None, content = None):
+        req = self._client.build_request('POST', url, json=json, content=content)
+        return self._client.send(req, stream=True)

webmediator-0.9.2/src/webmediator/_client_async.py

@@ -0,0 +1,145 @@
+import asyncio
+import typing
+import ssl
+
+import httpx
+from httpx._types import AuthTypes, HeaderTypes, CookieTypes, CertTypes, ProxyTypes,TimeoutTypes
+from httpx._transports import AsyncBaseTransport
+from httpx._config import Limits, DEFAULT_LIMITS, DEFAULT_TIMEOUT_CONFIG, DEFAULT_MAX_REDIRECTS
+from httpx._client import EventHook
+
+from ._client_base import BaseClient, Response
+from ._stream_async import AsyncHttpStreamIO
+
+
+class AsyncClient(BaseClient):
+    def __init__(self, endpoint_url: str,
+        auth: AuthTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        verify: ssl.SSLContext | str | bool = False,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: ProxyTypes | None = None,
+        mounts: None | (typing.Mapping[str, AsyncBaseTransport | None]) = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        transport: AsyncBaseTransport | None = None,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+        response_stream_as_bytes = False
+    ):
+        super().__init__(endpoint_url)
+        
+        self._response_stream_as_bytes = response_stream_as_bytes
+        self._client = httpx.AsyncClient(
+            base_url=self._endpoint_url,
+            auth=auth,
+            headers=headers,
+            cookies=cookies,
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            proxy=proxy,
+            mounts=mounts,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            limits=limits,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            transport=transport,
+            default_encoding=default_encoding)
+
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.close()
+
+    def close(self):
+        self._client.close()
+
+    async def aclose(self):
+        await self._client.aclose()
+
+    async def _get_result_stream(self, res: httpx.Response):
+        if not self._response_stream_as_bytes:
+            return AsyncHttpStreamIO(res)
+        
+        content = await res.aread()
+        await res.aclose()
+        return content
+        
+    async def _get_result(self, res: httpx.Response):
+        res.raise_for_status()
+
+        data_type = self._get_data_type(res)
+        
+        if res.status_code== 204:
+            await res.aclose()
+            return Response(data_type)
+    
+        if not self._is_json_ctype(res):
+            streamProp = self._get_data_stream_property(res)
+            if streamProp:
+                data = self._get_data(res)
+                data[streamProp] = await self._get_result_stream(res)
+                return Response(data_type,
+                    data = data,
+                    stream_ref = data[streamProp])
+            
+            data = await self._get_result_stream(res)
+            return Response(data_type,
+                data = data,
+                stream_ref = data)
+        
+        await res.aread()
+        result = Response(data_type, res.json())
+        await res.aclose()
+        return result
+    
+    async def _stream_content_async(self, data):
+        it = iter(self._stream_content(data))
+        done = object()
+
+        while True:
+            try:
+                value = await asyncio.to_thread(next, it, done)
+            except StopIteration:
+                break
+            
+            if value is done:
+                break
+            
+            yield value
+
+
+    async def send(self, type: str, data=None):
+        if data == None:
+            return await self._get_result(await self._post(type))
+        
+        if self._is_stream(data):
+            return await self._get_result(
+                await self._post(type, content=self._stream_content_async(data)))
+        
+        io_prop = self._get_stream_prop(data)
+
+        if io_prop:
+            copy = data.copy()
+            del copy[io_prop]
+            return await self._get_result(
+                await self._post(f"{type}?data={self._encode_json(copy)}", 
+                    content=self._stream_content_async(data[io_prop])))
+
+        return await self._get_result(
+            await self._post(type, json=data))
+    
+    async def _post(self, url, json = None, content = None):
+        req = self._client.build_request('POST', url, json=json, content=content)
+        return await self._client.send(req, stream=True)

webmediator-0.9.2/src/webmediator/_client_base.py

@@ -0,0 +1,101 @@
+import io
+import json
+from urllib.parse import quote
+import base64
+import httpx
+    
+from ._stream import CHUNK_SIZE, HttpStreamIO
+from ._stream_async import AsyncHttpStreamIO
+
+class BaseClient:
+    def __init__(self, endpoint_url: str):
+        self._endpoint_url = endpoint_url if endpoint_url[-1] == '/' else endpoint_url+'/'
+
+    def _encode_json(self, obj):
+        return quote(json.dumps(obj), safe='')
+    
+    def _is_stream(self, obj):
+        return isinstance(obj, io.IOBase) or isinstance(obj, bytes)
+
+    def _get_stream_prop(self, obj):
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                if value != None and self._is_stream(value):
+                    return key
+        return None
+
+    def _stream_content(self, data):
+        if isinstance(data, bytes):
+            yield data
+            return
+        
+        if isinstance(data, io.TextIOBase):
+            while chunk := data.read(CHUNK_SIZE):
+                yield chunk.encode(data.encoding)
+            return    
+            
+        while chunk := data.read(CHUNK_SIZE):
+            yield chunk
+
+    def _is_json_ctype(self, res: httpx.Response) -> bool:
+        ctype = res.headers.get('content-type')
+        return ctype != None and ctype.find('application/json') >= 0
+
+    def _get_data(self, res: httpx.Response):
+        return json.loads(base64.b64decode(res.headers.get('data')))
+
+    def _get_data_type(self, res: httpx.Response) -> str | None:
+        return res.headers.get('data-type')
+    
+    def _get_data_stream_property(self, res: httpx.Response) -> str | None:
+        return res.headers.get('data-stream-property')
+    
+    def get_link(self, type: str, data=None):
+        if data == None:
+            return self._endpoint_url+type
+
+        if self._is_stream(data) or self._get_stream_prop(data):
+            raise TypeError("The data contains stream property (IOBase or bytes) and cannot be presented as a link.")
+
+        return f"{self._endpoint_url}{type}?data={self._encode_json(data)}"
+    
+ 
+
+class Response:
+    def __init__(self,
+        type: str, 
+        data = None, 
+        stream_ref : HttpStreamIO | AsyncHttpStreamIO | None = None
+    ):
+        self.type = type
+        self.data = data
+        self.__stream_ref = stream_ref if isinstance(stream_ref, (HttpStreamIO, AsyncHttpStreamIO)) else None
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.close()
+
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exception_type, exception_value, exception_traceback):
+        await self.aclose()
+
+    def __str__(self):
+        return f"type: {self.type}, data: {self.data}"
+    
+    def close(self):
+        if self.__stream_ref != None:
+            self.__stream_ref.close()
+            
+    async def aclose(self):
+        if self.__stream_ref == None:
+            return
+        
+        if isinstance(self.__stream_ref, AsyncHttpStreamIO):
+            await self.__stream_ref.aclose()
+        else:
+            self.__stream_ref.close()
+        

webmediator-0.9.2/src/webmediator/_stream.py

@@ -0,0 +1,51 @@
+import io
+import httpx
+
+CHUNK_SIZE = 4096
+
+class HttpStreamIO(io.RawIOBase):
+    def __init__(self, response: httpx.Response):
+        self._response = response
+        self._generator = response.iter_raw(CHUNK_SIZE)
+        self._buffer = b""
+
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.close()
+
+    def readable(self):
+        return True
+
+    def close(self):
+        if not self.closed:
+            self._response.close()
+            super().close()
+
+    def read(self, size=-1):
+        if size == 0:
+            return b""
+        
+        # Keep fetching from the generator until we have enough data or it's exhausted
+        while size < 0 or len(self._buffer) < size:
+            try:
+                chunk = next(self._generator)
+                if not isinstance(chunk, bytes):
+                    raise TypeError("Generator must yield bytes objects")
+                self._buffer += chunk
+            except StopIteration:
+                self.close()
+                break # Generator exhausted
+            except:
+                self.close()
+                raise
+
+        if size < 0:
+            result = self._buffer
+            self._buffer = b""
+        else:
+            result = self._buffer[:size]
+            self._buffer = self._buffer[size:]
+            
+        return result

webmediator-0.9.2/src/webmediator/_stream_async.py

@@ -0,0 +1,67 @@
+import io
+import httpx
+from ._utils_async import run_coroutine_sync 
+from ._stream import CHUNK_SIZE
+
+
+class AsyncHttpStreamIO(io.RawIOBase):
+    def __init__(self, response: httpx.Response):
+        self._response = response
+        self._generator = response.aiter_raw(CHUNK_SIZE)
+        self._buffer = b""
+
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+        self.close()
+        
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exception_type, exception_value, exception_traceback):
+        await self.aclose()
+
+    def readable(self):
+        return True
+    
+    def close(self):
+        if not self.closed:
+            run_coroutine_sync(self.aclose())
+            super().close()
+    
+    async def aclose(self):
+        if not self.closed:
+            await self._response.aclose()
+            super().close()
+    
+    def read(self, size=-1):
+        return run_coroutine_sync(self.aread(size))
+    
+    async def aread(self, size=-1):
+        if size == 0:
+            return b""
+        
+        # Keep fetching from the generator until we have enough data or it's exhausted
+        while size < 0 or len(self._buffer) < size:
+            try:
+                chunk = await anext(self._generator)
+                if not isinstance(chunk, bytes):
+                    raise TypeError("Generator must yield bytes objects")
+                self._buffer += chunk
+            except StopAsyncIteration:
+                await self.aclose()
+                break # Generator exhausted
+            except:
+                await self.aclose()
+                raise
+
+        if size < 0:
+            result = self._buffer
+            self._buffer = b""
+        else:
+            result = self._buffer[:size]
+            self._buffer = self._buffer[size:]
+            
+        return result
+    

webmediator-0.9.2/src/webmediator/_utils_async.py

@@ -0,0 +1,30 @@
+import asyncio
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Coroutine, TypeVar
+
+T = TypeVar("T")
+
+def run_coroutine_sync(coroutine: Coroutine[Any, Any, T], timeout: float = 30) -> T:
+    def run_in_new_loop():
+        new_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(new_loop)
+        try:
+            return new_loop.run_until_complete(coroutine)
+        finally:
+            new_loop.close()
+
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coroutine)
+
+    if threading.current_thread() is threading.main_thread():
+        if not loop.is_running():
+            return loop.run_until_complete(coroutine)
+        else:
+            with ThreadPoolExecutor() as pool:
+                future = pool.submit(run_in_new_loop)
+                return future.result(timeout=timeout)
+    else:
+        return asyncio.run_coroutine_threadsafe(coroutine, loop).result()

webmediator-0.9.2/src/webmediator.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: webmediator
+Version: 0.9.2
+Summary: Python sync/async client for the WebMediator API
+Home-page: https://github.com/mustaddon/webmediator.git
+Author: Leonid Salavatov
+Author-email: mustaddon@gmail.com
+Keywords: WebMediator,CQRS,Mediator
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# webmediator
+Python sync/async client for the WebMediator API.
+
+
+*Sync*
+```python
+import webmediator
+
+client = webmediator.Client('https://localhost:7263/mediator')
+
+response = client.send('Ping', {'Message':'EXAMPLE' }):
+print(response)
+```
+
+*Async*
+```python
+import webmediator
+import asyncio
+
+async def main():
+    mediator = webmediator.AsyncClient('http://localhost:5263/mediator')
+
+    response = await client.send('Ping', {'Message':'EXAMPLE' }):
+    print(response)
+
+if __name__ == "__main__":
+    asyncio.get_event_loop().run_until_complete(main())
+```
+
+*Console output:*
+```
+type: Pong, data: {'Message': 'EXAMPLE PONG'}
+```

webmediator-0.9.2/src/webmediator.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+src/webmediator/__init__.py
+src/webmediator/_client.py
+src/webmediator/_client_async.py
+src/webmediator/_client_base.py
+src/webmediator/_stream.py
+src/webmediator/_stream_async.py
+src/webmediator/_utils_async.py
+src/webmediator.egg-info/PKG-INFO
+src/webmediator.egg-info/SOURCES.txt
+src/webmediator.egg-info/dependency_links.txt
+src/webmediator.egg-info/requires.txt
+src/webmediator.egg-info/top_level.txt

webmediator-0.9.2/src/webmediator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

webmediator-0.9.2/src/webmediator.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx

webmediator-0.9.2/src/webmediator.egg-info/top_level.txt

@@ -0,0 +1 @@
+webmediator