django-xmlrpc-0.1.8/0000775000175000017500000000000013170473243015735 5ustar fantomasfantomas00000000000000django-xmlrpc-0.1.8/setup.cfg0000664000175000017500000000010313170473243017550 0ustar fantomasfantomas00000000000000[bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 django-xmlrpc-0.1.8/MANIFEST.in0000664000175000017500000000015513170472224017472 0ustar fantomasfantomas00000000000000include README.rst recursive-include django_xmlrpc/locale * recursive-include django_xmlrpc/templates *.html django-xmlrpc-0.1.8/README.rst0000664000175000017500000000326213170473152017426 0ustar fantomasfantomas00000000000000============== Django XML-RPC ============== **Django_xmlrpc** offers a means by which a Django developer can expose their views (or indeed any other function) using XML-RPC. This is a fork of the original version made by Svetlyak40wt compatible with Django >= 1.8 and Python >= 2.5. If you want to use **django_xmlrpc** for an older version of Django or Python, please use an old release. .. contents:: Installation ============ You could retrieve the last sources from http://github.com/Fantomas42/django-xmlrpc and run the installation script :: $ python setup.py install or use pip :: $ pip install -e git://github.com/Fantomas42/django-xmlrpc.git#egg=django-xmlrpc Usage ===== Register **django_xmlrpc** in your INSTALLED_APPS section of your project' settings. There are two ways to register methods that you want to handle: In your project's settings. :: XMLRPC_METHODS = (('path.to.your.method', 'Method name'), ('path.to.your.othermethod', 'Other Method name'),) In a file called ``xmlrpc.py`` in your application directory. :: XMLRPC_METHODS = (('path.to.your.method', 'Method name'), ('path.to.your.othermethod', 'Other Method name'),) A registered method should look like this: :: from django_xmlrpc.decorators import xmlrpc_func @xmlrpc_func(returns='string', args=['string']) def test_xmlrpc(text): """Simply returns the args passed to it as a string""" return "Here's a response! %s" % str(text) Finally we need to register the url of the XML-RPC server. Insert something like this in your project's urls.py: :: from django_xmlrpc.views import handle_xmlrpc url(r'^xmlrpc/$', handle_xmlrpc, name='xmlrpc'), django-xmlrpc-0.1.8/django_xmlrpc/0000775000175000017500000000000013170473243020564 5ustar fantomasfantomas00000000000000django-xmlrpc-0.1.8/django_xmlrpc/registry.py0000664000175000017500000001217213170472224023007 0ustar fantomasfantomas00000000000000"""registry module for the django_xmlrpc package Authors:: Julien Fache Credit must go to Brendan W. McAdams , who posted the original SimpleXMLRPCDispatcher to the Django wiki: http://code.djangoproject.com/wiki/XML-RPC New BSD License =============== Copyright (c) 2007, Graham Binns http://launchpad.net/~codedragon 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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. """ from collections import Callable from logging import getLogger from django.apps import apps from django.conf import settings from django.core.exceptions import ImproperlyConfigured from django_xmlrpc.dispatcher import xmlrpc_dispatcher logger = getLogger('xmlrpc.registry') def register_xmlrpc_methods(): """ Register all xmlrpc methods in the server. """ if hasattr(settings, 'XMLRPC_METHODS'): register_xmlrpc_methods_legacy() else: register_xmlrpc_methods_autodiscover() register_xmlrpc_methods_helpers() def register_xmlrpc_method(path, name): """ Register a method into the server. """ # If 'path' is actually a function, just add it without fuss if isinstance(path, Callable): logger.info("Registering '%s:%s' => '%s'" % ( path.__module__, path.__name__, name)) xmlrpc_dispatcher.register_function(path, name) return # Otherwise we try and find something that we can call logger.debug('%s not callable, resolving path...' % path) i = path.rfind('.') module, attr = path[:i], path[i + 1:] try: mod = __import__(module, globals(), locals(), [attr]) except ImportError: raise ImproperlyConfigured( "Error registering XML-RPC method: " "module %s can't be imported" % module) try: func = getattr(mod, attr) except AttributeError: raise ImproperlyConfigured( 'Error registering XML-RPC method: ' 'module %s doesn\'t define a method "%s"' % (module, attr)) if not isinstance(func, Callable): raise ImproperlyConfigured( 'Error registering XML-RPC method: ' '"%s" is not callable in module %s' % (attr, module)) logger.info("Registering '%s:%s' => '%s'" % (module, attr, name)) xmlrpc_dispatcher.register_function(func, name) def register_xmlrpc_methods_legacy(): """ Load up any methods that have been registered with the server via settings. """ logger.info('Register XML-RPC methods from settings.XMLRPC_METHODS') for path, name in settings.XMLRPC_METHODS: register_xmlrpc_method(path, name) def register_xmlrpc_methods_autodiscover(): """ Looks in app directories for a module called 'xmlrpc' This should contain a distribution XMLRPC_METHODS declaration. """ logger.info('Register XML-RPC methods by inspecting INSTALLED_APPS') for application in apps.get_app_configs(): application_name = application.name logger.debug('Checking %s...' % application_name) try: module = __import__('%s.xmlrpc' % application_name, globals(), locals(), ['']) logger.debug('Found %s.xmlrpc' % application_name) except ImportError: logger.debug('Not found %s.xmlrpc' % application_name) continue if hasattr(module, 'XMLRPC_METHODS'): logger.info('Found XMLRPC_METHODS in %s.xmlrpc' % application_name) for path, name in module.XMLRPC_METHODS: register_xmlrpc_method(path, name) def register_xmlrpc_methods_helpers(): """Register the introspection and multicall methods with the XML-RPC namespace. """ xmlrpc_dispatcher.register_introspection_functions() xmlrpc_dispatcher.register_multicall_functions() django-xmlrpc-0.1.8/django_xmlrpc/decorators.py0000664000175000017500000001420713170472224023305 0ustar fantomasfantomas00000000000000"""Offers decorators to make the use of django_xmlrpc a great deal simpler Authors:: Graham Binns, Reza Mohammadi Credit must go to Brendan W. McAdams , who posted the original SimpleXMLRPCDispatcher to the Django wiki: http://code.djangoproject.com/wiki/XML-RPC New BSD License =============== Copyright (c) 2007, Graham Binns http://launchpad.net/~codedragon 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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. """ try: from xmlrpc.client import Fault except ImportError: # Python 2 from xmlrpclib import Fault from django.contrib.auth import authenticate from django.utils.translation import gettext as _ # Some constants for your pleasure # XXX: Any standardization? AUTHENTICATION_FAILED_CODE = 81 PERMISSION_DENIED_CODE = 82 class AuthenticationFailedException(Fault): """An XML-RPC fault to be raised when a permission_required authentication check fails Author """ def __init__(self): Fault.__init__(self, AUTHENTICATION_FAILED_CODE, _('Username and/or password is incorrect')) class PermissionDeniedException(Fault): """An XML-RPC fault to be raised when a permission_required permission check fails """ def __init__(self): Fault.__init__(self, PERMISSION_DENIED_CODE, _('Permission denied')) def xmlrpc_method(returns='string', args=None, name=None): """Adds a signature to an XML-RPC function. returns The return type of the function. This can either be a string description (e.g. 'string') or a type (e.g. str, bool) etc. args A list of the types of the arguments that the function accepts. These can be strings or types or a mixture of the two e.g. [str, bool, 'string'] """ # Args should be a list if args is None: args = [] def _xmlrpc_func(func): """Inner function for XML-RPC method decoration. Adds a signature to the method passed to it. func The function to add the signature to """ # Add a signature to the function func._xmlrpc_signature = { 'returns': returns, 'args': args } return func return _xmlrpc_func xmlrpc_func = xmlrpc_method # Don't use this decorator when your service is going to be # available in an unencrpted/untrusted network. # Configure HTTPS transport for your web server. def permission_required(perm=None): """Decorator for authentication. Uses Django's built in authentication framework to provide authenticated-only and permission-related access to XML-RPC methods perm The permission (as a string) that the user must hold to be able to call the function that is decorated with permission_required. """ def _dec(func): """An inner decorator. Adds the lookup code for the permission passed in the outer method to the function passed to it. func The function to add the permission check to """ def __authenticated_call(username, password, *args): """Inner inner decorator. Adds username and password parameters to a given XML-RPC function for authentication and permission checking purposes and modifies the method signature appropriately username The username used for authentication password The password used for authentication """ try: user = authenticate(username=username, password=password) if not user: raise AuthenticationFailedException if perm and not user.has_perm(perm): raise PermissionDeniedException except AuthenticationFailedException: raise except PermissionDeniedException: raise except: raise AuthenticationFailedException return func(user, *args) # Update the function's XML-RPC signature, if the method has one if hasattr(func, '_xmlrpc_signature'): sig = func._xmlrpc_signature # We just stick two string args on the front of sign['args'] to # represent username and password sig['args'] = (['string'] * 2) + sig['args'] __authenticated_call._xmlrpc_signature = sig # Update the function's docstring if func.__doc__: __authenticated_call.__doc__ = func.__doc__ + \ "\nNote: Authentication is required.""" if perm: __authenticated_call.__doc__ += (' this function requires ' '"%s" permission.' % perm) return __authenticated_call return _dec django-xmlrpc-0.1.8/django_xmlrpc/templates/0000775000175000017500000000000013170473243022562 5ustar fantomasfantomas00000000000000django-xmlrpc-0.1.8/django_xmlrpc/templates/xmlrpc_get.html0000664000175000017500000000127313170472224025615 0ustar fantomasfantomas00000000000000{% extends "admin/base_site.html" %} {% load i18n %} {% block title %}{% trans "XML-RPC Service" %}{% endblock %} {% block content %}

{% trans "XML-RPC Service" %}

{% trans "You need to invoke this service using an XML-RPC Client." %}

{% trans "The following methods are available :" %}

{% for m in methods %}

{{ m.0 }}

{% trans "Types of argument" %}{{ m.1.args|length|pluralize }} : {{ m.1.args }}
{% trans "Type of return" %} : {{ m.1.returns }} 
{{ m.2 }}
{% endfor %} {% endblock %} django-xmlrpc-0.1.8/django_xmlrpc/locale/0000775000175000017500000000000013170473243022023 5ustar fantomasfantomas00000000000000django-xmlrpc-0.1.8/django_xmlrpc/locale/fr/0000775000175000017500000000000013170473243022432 5ustar fantomasfantomas00000000000000django-xmlrpc-0.1.8/django_xmlrpc/locale/fr/LC_MESSAGES/0000775000175000017500000000000013170473243024217 5ustar fantomasfantomas00000000000000django-xmlrpc-0.1.8/django_xmlrpc/locale/fr/LC_MESSAGES/django.mo0000664000175000017500000000200613170472224026012 0ustar fantomasfantomas00000000000000Þ•\ œÈÉ%Û%"H8X—‘)*=hw.ˆ·>ÇPermission deniedThe following methods are available :Type of returnTypes of argumentUsername and/or password is incorrectXML-RPC ServiceYou need to invoke this service using an XML-RPC Client.Project-Id-Version: django-xmlrpc Report-Msgid-Bugs-To: POT-Creation-Date: 2010-07-31 15:33+0200 PO-Revision-Date: 2010-07-31 15:50+0100 Last-Translator: Fantomas Language-Team: Fantomas42 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Poedit-Language: French X-Poedit-Country: FRANCE X-Poedit-SourceCharset: utf-8 Permission refuséeLes méthodes suivantes sont disponibles :Type de retourTypes d'argumentNom d'utilisateur et/ou mot de passe incorrectService XML-RPCVous devez invoquer ce service en utilisant un client XML-RPC.django-xmlrpc-0.1.8/django_xmlrpc/locale/fr/LC_MESSAGES/django.po0000664000175000017500000000264613170472224026027 0ustar fantomasfantomas00000000000000# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # msgid "" msgstr "" "Project-Id-Version: django-xmlrpc\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2010-07-31 15:33+0200\n" "PO-Revision-Date: 2010-07-31 15:50+0100\n" "Last-Translator: Fantomas \n" "Language-Team: Fantomas42 \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Poedit-Language: French\n" "X-Poedit-Country: FRANCE\n" "X-Poedit-SourceCharset: utf-8\n" #: decorators.py:60 msgid "Username and/or password is incorrect" msgstr "Nom d'utilisateur et/ou mot de passe incorrect" #: decorators.py:68 msgid "Permission denied" msgstr "Permission refusée" #: templates/xmlrpc_get.html:4 #: templates/xmlrpc_get.html.py:7 msgid "XML-RPC Service" msgstr "Service XML-RPC" #: templates/xmlrpc_get.html:9 msgid "You need to invoke this service using an XML-RPC Client." msgstr "Vous devez invoquer ce service en utilisant un client XML-RPC." #: templates/xmlrpc_get.html:11 msgid "The following methods are available :" msgstr "Les méthodes suivantes sont disponibles :" #: templates/xmlrpc_get.html:17 msgid "Types of argument" msgstr "Types d'argument" #: templates/xmlrpc_get.html:19 msgid "Type of return" msgstr "Type de retour" django-xmlrpc-0.1.8/django_xmlrpc/apps.py0000664000175000017500000000407613170472224022106 0ustar fantomasfantomas00000000000000"""apps module for the django_xmlrpc package Authors:: Julien Fache Credit must go to Brendan W. McAdams , who posted the original SimpleXMLRPCDispatcher to the Django wiki: http://code.djangoproject.com/wiki/XML-RPC New BSD License =============== Copyright (c) 2007, Graham Binns http://launchpad.net/~codedragon 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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. """ from django.apps import AppConfig class XMLRPCConfig(AppConfig): name = 'django_xmlrpc' label = 'xmlrpc' verbose_name = 'XMRPC' def ready(self): from django_xmlrpc.registry import register_xmlrpc_methods register_xmlrpc_methods() django-xmlrpc-0.1.8/django_xmlrpc/views.py0000664000175000017500000000655413170473152022304 0ustar fantomasfantomas00000000000000"""Uses SimpleXMLRPCServer's SimpleXMLRPCDispatcher to serve XML-RPC requests Authors:: Graham Binns Reza Mohammadi Julien Fache Credit must go to Brendan W. McAdams , who posted the original SimpleXMLRPCDispatcher to the Django wiki: http://code.djangoproject.com/wiki/XML-RPC New BSD License =============== Copyright (c) 2007, Graham Binns http://launchpad.net/~codedragon 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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. """ from logging import getLogger from django.http import HttpResponse from django.http import HttpResponseServerError from django.shortcuts import render from django.views.decorators.csrf import csrf_exempt from django_xmlrpc.dispatcher import xmlrpc_dispatcher logger = getLogger('xmlrpc.views') @csrf_exempt def handle_xmlrpc(request): """Handles XML-RPC requests. All XML-RPC calls should be forwarded here request The HttpRequest object that carries the XML-RPC call. If this is a GET request, nothing will happen (we only accept POST requests) """ if request.method == 'POST': logger.info(request.body) try: response = HttpResponse(content_type='text/xml') response.write( xmlrpc_dispatcher._marshaled_dispatch(request.body)) logger.debug(response) return response except: return HttpResponseServerError() else: methods = xmlrpc_dispatcher.system_listMethods() method_list = [] for method in methods: sig_ = xmlrpc_dispatcher.system_methodSignature(method) sig = { 'returns': sig_[0], 'args': ', '.join(sig_[1:]), } # This just reads your docblock, so fill it in! method_help = xmlrpc_dispatcher.system_methodHelp(method) method_list.append((method, sig, method_help)) return render(request, 'xmlrpc_get.html', {'methods': method_list}) django-xmlrpc-0.1.8/django_xmlrpc/__init__.py0000664000175000017500000000370013170473172022676 0ustar fantomasfantomas00000000000000"""__init__ module for the django_xmlrpc package Authors:: Graham Binns Julien Fache Credit must go to Brendan W. McAdams , who posted the original SimpleXMLRPCDispatcher to the Django wiki: http://code.djangoproject.com/wiki/XML-RPC New BSD License =============== Copyright (c) 2007, Graham Binns http://launchpad.net/~codedragon 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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. """ VERSION = (0, 1, 8) __version__ = '.'.join(map(str, VERSION)) default_app_config = 'django_xmlrpc.apps.XMLRPCConfig' django-xmlrpc-0.1.8/django_xmlrpc/dispatcher.py0000664000175000017500000000577613170472224023301 0ustar fantomasfantomas00000000000000"""Offers a simple XML-RPC dispatcher for django_xmlrpc Author:: Graham Binns Credit must go to Brendan W. McAdams , who posted the original SimpleXMLRPCDispatcher to the Django wiki: http://code.djangoproject.com/wiki/XML-RPC New BSD License =============== Copyright (c) 2007, Graham Binns http://launchpad.net/~codedragon 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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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. """ from inspect import getargspec try: from xmlrpc.server import SimpleXMLRPCDispatcher except ImportError: # Python 2 from SimpleXMLRPCServer import SimpleXMLRPCDispatcher class DjangoXMLRPCDispatcher(SimpleXMLRPCDispatcher): """A simple XML-RPC dispatcher for Django. Subclassess SimpleXMLRPCServer.SimpleXMLRPCDispatcher for the purpose of overriding certain built-in methods (it's nicer than monkey-patching them, that's for sure). """ def system_methodSignature(self, method): """Returns the signature details for a specified method method The name of the XML-RPC method to get the details for """ # See if we can find the method in our funcs dict # TODO: Handle this better: We really should return something more # formal than an AttributeError func = self.funcs[method] try: sig = func._xmlrpc_signature except: sig = { 'returns': 'string', 'args': ['string' for arg in getargspec(func)[0]], } return [sig['returns']] + sig['args'] xmlrpc_dispatcher = DjangoXMLRPCDispatcher(allow_none=False, encoding=None) django-xmlrpc-0.1.8/django_xmlrpc.egg-info/0000775000175000017500000000000013170473243022256 5ustar fantomasfantomas00000000000000django-xmlrpc-0.1.8/django_xmlrpc.egg-info/top_level.txt0000664000175000017500000000001613170473243025005 0ustar fantomasfantomas00000000000000django_xmlrpc django-xmlrpc-0.1.8/django_xmlrpc.egg-info/not-zip-safe0000664000175000017500000000000113170473243024504 0ustar fantomasfantomas00000000000000 django-xmlrpc-0.1.8/django_xmlrpc.egg-info/PKG-INFO0000664000175000017500000000556313170473243023364 0ustar fantomasfantomas00000000000000Metadata-Version: 1.1 Name: django-xmlrpc Version: 0.1.8 Summary: XML-RPC Server App for the Django framework. Home-page: https://github.com/Fantomas42/django-xmlrpc Author: Fantomas42 Author-email: fantomas42@gmail.com License: New BSD License Description-Content-Type: UNKNOWN Description: ============== Django XML-RPC ============== **Django_xmlrpc** offers a means by which a Django developer can expose their views (or indeed any other function) using XML-RPC. This is a fork of the original version made by Svetlyak40wt compatible with Django >= 1.8 and Python >= 2.5. If you want to use **django_xmlrpc** for an older version of Django or Python, please use an old release. .. contents:: Installation ============ You could retrieve the last sources from http://github.com/Fantomas42/django-xmlrpc and run the installation script :: $ python setup.py install or use pip :: $ pip install -e git://github.com/Fantomas42/django-xmlrpc.git#egg=django-xmlrpc Usage ===== Register **django_xmlrpc** in your INSTALLED_APPS section of your project' settings. There are two ways to register methods that you want to handle: In your project's settings. :: XMLRPC_METHODS = (('path.to.your.method', 'Method name'), ('path.to.your.othermethod', 'Other Method name'),) In a file called ``xmlrpc.py`` in your application directory. :: XMLRPC_METHODS = (('path.to.your.method', 'Method name'), ('path.to.your.othermethod', 'Other Method name'),) A registered method should look like this: :: from django_xmlrpc.decorators import xmlrpc_func @xmlrpc_func(returns='string', args=['string']) def test_xmlrpc(text): """Simply returns the args passed to it as a string""" return "Here's a response! %s" % str(text) Finally we need to register the url of the XML-RPC server. Insert something like this in your project's urls.py: :: from django_xmlrpc.views import handle_xmlrpc url(r'^xmlrpc/$', handle_xmlrpc, name='xmlrpc'), Keywords: django,service,xmlrpc Platform: UNKNOWN Classifier: Framework :: Django Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Intended Audience :: Developers Classifier: Operating System :: OS Independent Classifier: Topic :: Software Development :: Libraries :: Python Modules django-xmlrpc-0.1.8/django_xmlrpc.egg-info/dependency_links.txt0000664000175000017500000000000113170473243026324 0ustar fantomasfantomas00000000000000 django-xmlrpc-0.1.8/django_xmlrpc.egg-info/SOURCES.txt0000664000175000017500000000077613170473243024154 0ustar fantomasfantomas00000000000000MANIFEST.in README.rst setup.cfg setup.py django_xmlrpc/__init__.py django_xmlrpc/apps.py django_xmlrpc/decorators.py django_xmlrpc/dispatcher.py django_xmlrpc/registry.py django_xmlrpc/views.py django_xmlrpc.egg-info/PKG-INFO django_xmlrpc.egg-info/SOURCES.txt django_xmlrpc.egg-info/dependency_links.txt django_xmlrpc.egg-info/not-zip-safe django_xmlrpc.egg-info/top_level.txt django_xmlrpc/locale/fr/LC_MESSAGES/django.mo django_xmlrpc/locale/fr/LC_MESSAGES/django.po django_xmlrpc/templates/xmlrpc_get.htmldjango-xmlrpc-0.1.8/setup.py0000664000175000017500000000211113170472224017440 0ustar fantomasfantomas00000000000000import os from setuptools import find_packages from setuptools import setup import django_xmlrpc setup(name='django-xmlrpc', version=django_xmlrpc.__version__, description='XML-RPC Server App for the Django framework.', long_description=open(os.path.join('README.rst')).read(), keywords='django, service, xmlrpc', author='Graham Binns', author_email='graham.binns@gmail.com', maintainer='Fantomas42', maintainer_email='fantomas42@gmail.com', url='https://github.com/Fantomas42/django-xmlrpc', packages=find_packages(), classifiers=[ 'Framework :: Django', 'Development Status :: 5 - Production/Stable', 'Environment :: Web Environment', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Intended Audience :: Developers', 'Operating System :: OS Independent', 'Topic :: Software Development :: Libraries :: Python Modules'], license='New BSD License', include_package_data=True, zip_safe=False ) django-xmlrpc-0.1.8/PKG-INFO0000664000175000017500000000556313170473243017043 0ustar fantomasfantomas00000000000000Metadata-Version: 1.1 Name: django-xmlrpc Version: 0.1.8 Summary: XML-RPC Server App for the Django framework. Home-page: https://github.com/Fantomas42/django-xmlrpc Author: Fantomas42 Author-email: fantomas42@gmail.com License: New BSD License Description-Content-Type: UNKNOWN Description: ============== Django XML-RPC ============== **Django_xmlrpc** offers a means by which a Django developer can expose their views (or indeed any other function) using XML-RPC. This is a fork of the original version made by Svetlyak40wt compatible with Django >= 1.8 and Python >= 2.5. If you want to use **django_xmlrpc** for an older version of Django or Python, please use an old release. .. contents:: Installation ============ You could retrieve the last sources from http://github.com/Fantomas42/django-xmlrpc and run the installation script :: $ python setup.py install or use pip :: $ pip install -e git://github.com/Fantomas42/django-xmlrpc.git#egg=django-xmlrpc Usage ===== Register **django_xmlrpc** in your INSTALLED_APPS section of your project' settings. There are two ways to register methods that you want to handle: In your project's settings. :: XMLRPC_METHODS = (('path.to.your.method', 'Method name'), ('path.to.your.othermethod', 'Other Method name'),) In a file called ``xmlrpc.py`` in your application directory. :: XMLRPC_METHODS = (('path.to.your.method', 'Method name'), ('path.to.your.othermethod', 'Other Method name'),) A registered method should look like this: :: from django_xmlrpc.decorators import xmlrpc_func @xmlrpc_func(returns='string', args=['string']) def test_xmlrpc(text): """Simply returns the args passed to it as a string""" return "Here's a response! %s" % str(text) Finally we need to register the url of the XML-RPC server. Insert something like this in your project's urls.py: :: from django_xmlrpc.views import handle_xmlrpc url(r'^xmlrpc/$', handle_xmlrpc, name='xmlrpc'), Keywords: django,service,xmlrpc Platform: UNKNOWN Classifier: Framework :: Django Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Intended Audience :: Developers Classifier: Operating System :: OS Independent Classifier: Topic :: Software Development :: Libraries :: Python Modules