aioxmlrpc-0.3/0000755000175000001440000000000012730531133014513 5ustar guillaumeusers00000000000000aioxmlrpc-0.3/aioxmlrpc.egg-info/0000755000175000001440000000000012730531133020203 5ustar guillaumeusers00000000000000aioxmlrpc-0.3/aioxmlrpc.egg-info/not-zip-safe0000644000175000001440000000000112430617313022433 0ustar guillaumeusers00000000000000 aioxmlrpc-0.3/aioxmlrpc.egg-info/SOURCES.txt0000644000175000001440000000053412730531133022071 0ustar guillaumeusers00000000000000CHANGES.rst LICENSE MANIFEST.in README.rst setup.py aioxmlrpc/__init__.py aioxmlrpc/client.py aioxmlrpc.egg-info/PKG-INFO aioxmlrpc.egg-info/SOURCES.txt aioxmlrpc.egg-info/dependency_links.txt aioxmlrpc.egg-info/not-zip-safe aioxmlrpc.egg-info/requires.txt aioxmlrpc.egg-info/top_level.txt aioxmlrpc/tests/__init__.py aioxmlrpc/tests/test_client.pyaioxmlrpc-0.3/aioxmlrpc.egg-info/top_level.txt0000644000175000001440000000001212730531133022726 0ustar guillaumeusers00000000000000aioxmlrpc aioxmlrpc-0.3/aioxmlrpc.egg-info/dependency_links.txt0000644000175000001440000000000112730531133024251 0ustar guillaumeusers00000000000000 aioxmlrpc-0.3/aioxmlrpc.egg-info/PKG-INFO0000644000175000001440000000527612730531133021312 0ustar guillaumeusers00000000000000Metadata-Version: 1.1 Name: aioxmlrpc Version: 0.3 Summary: XML-RPC client for asyncio Home-page: https://github.com/mardiros/aioxmlrpc Author: Guillaume Gauvrit Author-email: guillaume@gauvr.it License: UNKNOWN Description: ========= aioxmlrpc ========= .. image:: https://travis-ci.org/mardiros/aioxmlrpc.png?branch=master :target: https://travis-ci.org/mardiros/aioxmlrpc Getting Started =============== Asyncio version of the standard lib ``xmlrpc`` Currently only ``aioxmlrpc.client``, which works like ``xmlrpc.client`` but with coroutine is implemented. Fill free to fork me if you want to implement the server part. ``aioxmlrpc`` is based on ``aiohttp`` for the transport, and just patch the necessary from the python standard library to get it working. Installation ------------ :: pip install aioxmlrpc Example of usage ---------------- This example show how to print the current version of the Gandi XML-RPC api. :: import asyncio from aioxmlrpc.client import ServerProxy @asyncio.coroutine def print_gandi_api_version(): api = ServerProxy('https://rpc.gandi.net/xmlrpc/') result = yield from api.version.info() print(result) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(print_gandi_api_version()) loop.stop() Changelog ========= 0.3 released on 2016-06-16 -------------------------- * Fix socket closing issue 0.2 released on 2016-05-26 -------------------------- * Update compatibility for aiohttp >= 0.20 .. important:: This break the compatibility of python 3.3 0.1 released on 2014-05-17 -------------------------- * Initial version implementing ``aioxmlrpc.client`` Keywords: asyncio xml-rpc rpc Platform: UNKNOWN Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License aioxmlrpc-0.3/aioxmlrpc.egg-info/requires.txt0000644000175000001440000000002012730531133022573 0ustar guillaumeusers00000000000000aiohttp >= 0.20 aioxmlrpc-0.3/README.rst0000644000175000001440000000215312430617253016210 0ustar guillaumeusers00000000000000========= aioxmlrpc ========= .. image:: https://travis-ci.org/mardiros/aioxmlrpc.png?branch=master :target: https://travis-ci.org/mardiros/aioxmlrpc Getting Started =============== Asyncio version of the standard lib ``xmlrpc`` Currently only ``aioxmlrpc.client``, which works like ``xmlrpc.client`` but with coroutine is implemented. Fill free to fork me if you want to implement the server part. ``aioxmlrpc`` is based on ``aiohttp`` for the transport, and just patch the necessary from the python standard library to get it working. Installation ------------ :: pip install aioxmlrpc Example of usage ---------------- This example show how to print the current version of the Gandi XML-RPC api. :: import asyncio from aioxmlrpc.client import ServerProxy @asyncio.coroutine def print_gandi_api_version(): api = ServerProxy('https://rpc.gandi.net/xmlrpc/') result = yield from api.version.info() print(result) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(print_gandi_api_version()) loop.stop() aioxmlrpc-0.3/CHANGES.rst0000644000175000001440000000057412730531065016327 0ustar guillaumeusers00000000000000Changelog ========= 0.3 released on 2016-06-16 -------------------------- * Fix socket closing issue 0.2 released on 2016-05-26 -------------------------- * Update compatibility for aiohttp >= 0.20 .. important:: This break the compatibility of python 3.3 0.1 released on 2014-05-17 -------------------------- * Initial version implementing ``aioxmlrpc.client`` aioxmlrpc-0.3/LICENSE0000644000175000001440000000276512730531030015526 0ustar guillaumeusers00000000000000Copyright (c) 2014-2016, Guillaume Gauvrit and Contibutors All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. aioxmlrpc-0.3/MANIFEST.in0000644000175000001440000000007012430617253016253 0ustar guillaumeusers00000000000000include LICENSE include *.rst recursive-exclude . *.pyc aioxmlrpc-0.3/setup.cfg0000644000175000001440000000007312730531133016334 0ustar guillaumeusers00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 aioxmlrpc-0.3/setup.py0000644000175000001440000000302712730531030016223 0ustar guillaumeusers00000000000000import os import re import sys from setuptools import setup, find_packages py_version = sys.version_info[:2] if py_version < (3, 3): raise RuntimeError('Unsupported Python version. Python 3.3+ required') here = os.path.abspath(os.path.dirname(__file__)) NAME = 'aioxmlrpc' with open(os.path.join(here, 'README.rst')) as readme: README = readme.read() with open(os.path.join(here, 'CHANGES.rst')) as changes: CHANGES = changes.read() with open(os.path.join(here, NAME, '__init__.py')) as version: VERSION = re.compile(r".*__version__ = '(.*?)'", re.S).match(version.read()).group(1) requires = ['aiohttp >= 0.20'] if py_version < (3, 4): requires.append('asyncio') setup(name=NAME, version=VERSION, description='XML-RPC client for asyncio', long_description=README + '\n\n' + CHANGES, classifiers=[ 'Programming Language :: Python', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: BSD License' ], author='Guillaume Gauvrit', author_email='guillaume@gauvr.it', url='https://github.com/mardiros/aioxmlrpc', keywords='asyncio xml-rpc rpc', packages=find_packages(), include_package_data=True, zip_safe=False, test_suite='{}.tests'.format(NAME), install_requires=requires ) aioxmlrpc-0.3/aioxmlrpc/0000755000175000001440000000000012730531133016511 5ustar guillaumeusers00000000000000aioxmlrpc-0.3/aioxmlrpc/client.py0000644000175000001440000001035412730531030020340 0ustar guillaumeusers00000000000000""" XML-RPC Client with asyncio. This module adapt the ``xmlrpc.client`` module of the standard library to work with asyncio. """ import asyncio import logging from xmlrpc import client as xmlrpc import aiohttp __ALL__ = ['ServerProxy', 'Fault', 'ProtocolError'] # you don't have to import xmlrpc.client from your code Fault = xmlrpc.Fault ProtocolError = xmlrpc.ProtocolError log = logging.getLogger(__name__) class _Method: # some magic to bind an XML-RPC method to an RPC server. # supports "nested" methods (e.g. examples.getStateName) def __init__(self, send, name): self.__send = send self.__name = name def __getattr__(self, name): return _Method(self.__send, "%s.%s" % (self.__name, name)) @asyncio.coroutine def __call__(self, *args): ret = yield from self.__send(self.__name, args) return ret class AioTransport(xmlrpc.Transport): """ ``xmlrpc.Transport`` subclass for asyncio support """ user_agent = 'python/aioxmlrpc' def __init__(self, use_https, *, use_datetime=False, use_builtin_types=False, loop): super().__init__(use_datetime, use_builtin_types) self.use_https = use_https self._loop = loop self._connector = aiohttp.TCPConnector(loop=self._loop) @asyncio.coroutine def request(self, host, handler, request_body, verbose): """ Send the XML-RPC request, return the response. This method is a coroutine. """ headers = {'User-Agent': self.user_agent, #Proxy-Connection': 'Keep-Alive', #'Content-Range': 'bytes oxy1.0/-1', 'Accept': 'text/xml', 'Content-Type': 'text/xml' } url = self._build_url(host, handler) response = None try: response = yield from aiohttp.request( 'POST', url, headers=headers, data=request_body, connector=self._connector, loop=self._loop) body = yield from response.text() if response.status != 200: raise ProtocolError(url, response.status, body, response.headers) except ProtocolError: raise except Exception as exc: log.error('Unexpected error', exc_info=True) raise ProtocolError(url, response.status, str(exc), response.headers) return self.parse_response(body) def parse_response(self, body): """ Parse the xmlrpc response. """ p, u = self.getparser() p.feed(body) p.close() return u.close() def _build_url(self, host, handler): """ Build a url for our request based on the host, handler and use_http property """ scheme = 'https' if self.use_https else 'http' return '%s://%s%s' % (scheme, host, handler) def close(self): self._connector.close() class ServerProxy(xmlrpc.ServerProxy): """ ``xmlrpc.ServerProxy`` subclass for asyncio support """ def __init__(self, uri, transport=None, encoding=None, verbose=False, allow_none=False, use_datetime=False,use_builtin_types=False, loop=None): self._loop = loop or asyncio.get_event_loop() if not transport: transport = AioTransport(uri.startswith('https://'), loop=self._loop) super().__init__(uri, transport, encoding, verbose, allow_none, use_datetime, use_builtin_types) @asyncio.coroutine def __request(self, methodname, params): # call a method on the remote server request = xmlrpc.dumps(params, methodname, encoding=self.__encoding, allow_none=self.__allow_none).encode(self.__encoding) response = yield from self.__transport.request( self.__host, self.__handler, request, verbose=self.__verbose ) if len(response) == 1: response = response[0] return response def close(self): self.__transport.close() def __getattr__(self, name): return _Method(self.__request, name) aioxmlrpc-0.3/aioxmlrpc/__init__.py0000644000175000001440000000007612730531100020617 0ustar guillaumeusers00000000000000""" XML-RPC Protocol for ``asyncio`` """ __version__ = '0.3' aioxmlrpc-0.3/aioxmlrpc/tests/0000755000175000001440000000000012730531133017653 5ustar guillaumeusers00000000000000aioxmlrpc-0.3/aioxmlrpc/tests/__init__.py0000644000175000001440000000005312430617253021767 0ustar guillaumeusers00000000000000""" Test suite for the aioxmlrpc module """aioxmlrpc-0.3/aioxmlrpc/tests/test_client.py0000644000175000001440000000743712730531030022551 0ustar guillaumeusers00000000000000from unittest import TestCase from unittest import mock import asyncio RESPONSES = { 'http://localhost/test_xmlrpc_ok': {'status': 200, 'body': """ 1 """ }, 'http://localhost/test_xmlrpc_fault': {'status': 200, 'body': """ faultCode 4 faultString You are not lucky """ }, 'http://localhost/test_http_500': {'status': 500, 'body': """ I am really broken """ } } @asyncio.coroutine def dummy_response(method, url, **kwargs): class Response: def __init__(self): response = RESPONSES[url] self.status = response['status'] self.body = response['body'] self.headers = {} @asyncio.coroutine def text(self): return self.body return Response() @asyncio.coroutine def dummy_request(*args, **kwargs): return dummy_response(*args, **kwargs) class ServerProxyTestCase(TestCase): def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(None) self.aiohttp_request = mock.patch('aiohttp.request', new=dummy_request) self.aiohttp_request.start() def tearDown(self): self.aiohttp_request.stop() def test_xmlrpc_ok(self): from aioxmlrpc.client import ServerProxy client = ServerProxy('http://localhost/test_xmlrpc_ok', loop=self.loop) response = self.loop.run_until_complete( client.name.space.proxfyiedcall() ) self.assertEqual(response, 1) self.assertIs(self.loop, client._loop) def test_xmlrpc_fault(self): from aioxmlrpc.client import ServerProxy, Fault client = ServerProxy('http://localhost/test_xmlrpc_fault', loop=self.loop) self.assertRaises(Fault, self.loop.run_until_complete, client.name.space.proxfyiedcall() ) def test_http_500(self): from aioxmlrpc.client import ServerProxy, ProtocolError client = ServerProxy('http://localhost/test_http_500', loop=self.loop) self.assertRaises(ProtocolError, self.loop.run_until_complete, client.name.space.proxfyiedcall() ) def test_xmlrpc_ok_global_loop(self): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) from aioxmlrpc.client import ServerProxy client = ServerProxy('http://localhost/test_xmlrpc_ok') response = self.loop.run_until_complete( client.name.space.proxfyiedcall() ) self.assertIs(loop, client._loop) self.assertEqual(response, 1) def test_close_transport(self): from aioxmlrpc.client import ServerProxy, AioTransport transp = AioTransport(use_https=False, loop=self.loop) transp._connector.close = mock.Mock() client = ServerProxy('http://localhost/test_xmlrpc_ok', loop=self.loop, transport=transp) response = self.loop.run_until_complete( client.name.space.proxfyiedcall() ) client.close() self.assertEqual(response, 1) self.assertIs(self.loop, client._loop) self.assertTrue(transp._connector.close.called) aioxmlrpc-0.3/PKG-INFO0000644000175000001440000000527612730531133015622 0ustar guillaumeusers00000000000000Metadata-Version: 1.1 Name: aioxmlrpc Version: 0.3 Summary: XML-RPC client for asyncio Home-page: https://github.com/mardiros/aioxmlrpc Author: Guillaume Gauvrit Author-email: guillaume@gauvr.it License: UNKNOWN Description: ========= aioxmlrpc ========= .. image:: https://travis-ci.org/mardiros/aioxmlrpc.png?branch=master :target: https://travis-ci.org/mardiros/aioxmlrpc Getting Started =============== Asyncio version of the standard lib ``xmlrpc`` Currently only ``aioxmlrpc.client``, which works like ``xmlrpc.client`` but with coroutine is implemented. Fill free to fork me if you want to implement the server part. ``aioxmlrpc`` is based on ``aiohttp`` for the transport, and just patch the necessary from the python standard library to get it working. Installation ------------ :: pip install aioxmlrpc Example of usage ---------------- This example show how to print the current version of the Gandi XML-RPC api. :: import asyncio from aioxmlrpc.client import ServerProxy @asyncio.coroutine def print_gandi_api_version(): api = ServerProxy('https://rpc.gandi.net/xmlrpc/') result = yield from api.version.info() print(result) if __name__ == '__main__': loop = asyncio.get_event_loop() loop.run_until_complete(print_gandi_api_version()) loop.stop() Changelog ========= 0.3 released on 2016-06-16 -------------------------- * Fix socket closing issue 0.2 released on 2016-05-26 -------------------------- * Update compatibility for aiohttp >= 0.20 .. important:: This break the compatibility of python 3.3 0.1 released on 2014-05-17 -------------------------- * Initial version implementing ``aioxmlrpc.client`` Keywords: asyncio xml-rpc rpc Platform: UNKNOWN Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License