Table Of Contents

Previous topic

Spyne FAQ

This Page

History and Future


Spyne respects the “Semantic Versioning” rules outlined in

This means you can do better than just adding 'spyne' to your list of dependencies. Assuming the current version of spyne is 2.4.8, you can use the following as dependency string:

  • spyne if you feel adventurous or are willing to work on spyne itself.
  • spyne<2.99 if you only want backwards-compatible bug fixes and new features.
  • spyne<2.5 if you only want backwards-compatible bug fixes.
  • spyne=2.4.8 if you rather like that version.

We have a policy of pushing to pypi as soon as possible, so be sure to at least use the second option to prevent things from breaking unexpectedly.

Spyne project uses -alpha -beta and -rc labels to denote unfinished code. We don’t prefer using separate integers for experimental labels. So for example, instead of having 2.0.0-alpha47, we’ll have 2.2.5-alpha.

  • -alpha means unstable code. You may not recognize the project next time you look at it.
  • -beta means stable(ish) api, unstable behavior, there are bugs everywhere! Don’t be upset if some quirks that you rely on disappear.
  • -rc means it’s been working in production sans issues for some time on beta-testers’ sites, but we’d still like it to have tested by a few more people.

These labels apply to the project as a whole. Thus, we won’t tag the whole project as beta because some new feature is not yet well-tested, but we will clearly denote experimental code in its documentation.

Roadmap and Criticism

This is an attempt to make a free-for-all area to display opinions about possible feature directions of Spyne. Doing it in a text file in the source repository may not be the best approach for the job, but it should be enough to at least spark a discussion around this topic.

The following would definitely be nice to have, but are just modules that should not cause a change in unrelated areas of Spyne.

  • Support for polymorphism in XML Schema.
  • Support for the JsonRpc protocol.
  • Support for the JsonSchema interface document standard.
  • Support for the Thrift binary protocol.
  • Support for the Thrift IDL – The Thrift Interface Definition Language.
  • Support for the MessagePack IDL.
  • Support for the XmlRpc standard.
  • Support for EXI – The Efficient Xml Interchange as a serializer.
  • SMTP as client/server transport.
  • SPDY as client/server transport.
  • Support security extensions to Soap (maybe using PyXMLSec ?)
  • Support addressing (routing) extensions to Soap
  • Add WSDL Parsing support to Soap client.
  • Implement Soap 1.2 standard.
  • Implement Wsdl 2.0 standard.
  • Reflect transport and protocol pairs other than Soap/Http in the Wsdl.
  • etc.

Comparison with other rpc frameworks

RPC is a very popular subject. There’s a plethora of active and inactive projects that satisfy a wide range of requirements. Here are the main sources of information:


The Ladon project has almost the same goals and same approach to the rpc-related issues as Spyne.

Discussion thread:

  • Supports JsonWSP protocol, which is JsonRpc with interface description. Spyne supports JsonDocument which serializes complex object hierarchies as nested dict objects.

  • Supports both Python 2 and Python 3. Spyne is Python 2 only.

  • Auto-generates human-readable API documentation. (example: In Spyne, you need to do with the ugliness of a raw wsdl document.

  • Uses standard python tools for xml parsing which is good for pure-python deployments. Spyne uses lxml, due to its excellent xml namespace support and speed. So Spyne is faster but more difficult to deploy.

  • Does not support ZeroMQ as transport.

  • Does not support MessagePack.

  • Does not support HttpRpc.

  • Does not do declarative input validation. Traditional (imperative) input validation is possible via a code injection mechanism similar to Spyne’s events.

  • Does not have a Soap client. Spyne does, but it’s not that useful as it does not parse Wsdl documents.

    In fact, Ladon is pure server-side software - the whole idea of supporting a standard protocol like SOAP is that clients are already out there.

  • Spyne uses own classes for denoting types, whereas ladon uses Python callables. This lets ladon api to be simpler, but gives the Spyne api the power to have declarative restrictions on input types.

  • Does not test against deliverables for testing soap compatibility.

  • Does not support parsing and/or modifying protocol or transport headers.


“”” Web Service Made Easy (WSME) is a very easy way to implement webservices in your python web application. It is originally a rewrite of TGWebServices with focus on extensibility, framework-independance and better type handling. “”“

  • Supports TurboGears
  • Supports REST+Json, REST+Xml, (a subset of) SOAP and ExtDirect.
  • Supports type validation.
  • No client support.
  • Does not test against deliverables for testing soap compatibility.
  • Only supports http as transport.
  • Uses genshi for Xml support.


This is preliminary. Please correct these points if you spot any error.

  • Uses own protocol
  • Does not do validation.
  • Python-specific.
  • Fast.
  • Not designed for public servers. ??


This is preliminary. Please correct these points if you spot any error.

  • Uses own protocol
  • Does not do validation.
  • Python-specific.
  • Fast.
  • Not designed for public servers. ??


  • Soap 1.1 / Wsdl 1.1 Client only.
  • Excellent wsdl parser, very easy to use.
  • Recommended way to interface with Spyne’s Soap services.
  • Uses own pure-python xml implementation, so it’s roughly 10 times slower than Spyne’s Soap client.
  • Pure-python library, so relatively easier to deploy.


  • Unmaintained, although still works with recent Python versions
  • Contains SOAPpy, which is not the same as SOAPy (notice the extra P)
  • Supports attachments
  • Requires code generation (wsdl2py) for complex data structures
  • Almost complete lack of user-friendliness
  • Lack of WSDL generator


  • Really simple (only two files, both less than 500 lines of code)
  • Client only
  • Requires PyXML, thus unusable with recent Python versions


  • Client only.
  • Unmaintained.


  • Python Remote Objects
  • ???



  • Fix restriction bases of simple types not being imported.
  • Fix for customized subclasses forgetting about their empty base classes.
  • Fix Attributes.nullable not surviving customization.


  • Fix for Python 2.6 quirk where any decimal.Decimal() is always less than any float(). Where did that come from?!
  • Fix missing ‘/’ in WsgiMounter.
  • Fix confusion in spyne.model.primitive.Decimal‘s parameter order.
  • Add forgotten HttpBase parameters to WsgiApplication.


  • Fix WsgiApplication choking on empty string return value.
  • Fix TwistedWebResource choking on generators as return values.
  • Fix Csv serializer.


  • Fix Array serialization for Html Microformats
  • Fix deserialization of Fault objects for Soap11
  • Fix Uuid not playing well with soft validation.
  • Fix Uuid not playing well with Xml Schema document.


  • Spyne is now stable!
  • Fix document_built events by adding a doc attribute to the ServerBase class. You can now do some_server.doc.wsdl11.event_manager.add_listener to add events to interface documents.
  • Add wsdl_document_built and xml_document_built events to relevant classes.
  • Behavioral change for TableModel’s relationship handling: It’s now an array by default. The TableModel is deprecated, long live __metadata__ on ComplexModel!
  • First-class integration with Pyramid.
  • First geospatial types: Point and Polygon.
  • Initial revision of the http request pattern matching support via werkzeug.routing.
  • XmlObject -> XmlDocument, JsonObject -> JsonDocument, MessagePackObject -> MessagePackDocument, DictObject -> DictDocument.


  • integration! See for yourself:
  • Python 2.4 compatibility claim was dropped, because this particular Python version is nowhere to be found.
  • Many issues with Python 2.5 compatibility are fixed.


  • Misc fixes regarding the spyne.model.binary.File api.

rpclib-2.8.0-rc -> spyne-2.8.0-rc

  • Rpclib is dead. Long live Spyne!

  • Add support for JsonObject protocol. This initial version is expremental.

  • Add support for MessagePackObject and MessagePackRpc protocols. These initial versions are expremental.

  • Make DateTime string format customizable.

  • Implement TwistedWebResource that exposes an Application instance as a twisted.web.resource.Resource child.

  • Remove Deprecated XMLAttribute and XMLAttributeRef. Use XmlAttribute and XmlAttributeRef instead.

  • Xml Schema: Add support for the <any> tag.

  • Add a chapter about Validation to the manual. Thanks Alex!

  • Interface documents are no longer subclasses of InterfaceBase. It’s up to the transport to expose the application using a given interface document standard now. The interface argument to the Application constructor is now ignored.

  • Html: Added a very simple lxml-based templating scheme: HtmlPage.

  • Html: Added row-based tables: They show fields in rows. It’s good for showing one object per table.

  • Html: Added ImageUri support. They render as <img> tags in Html output.

  • Html: Added support for locales. You can now render field names as human- readable strings.

  • Add support for async methods, which execute after the primary user code returns. Currently, the only async execution method is via threads.

  • Xml & friends: Start tags are now in the same namespace as the definitions themselves. Intermediate tags are in the parent’s namespace, just as before.

  • Xml & friends: Make the ‘bare’ mode work.

  • spyne.util.xml: get_object_as_xml can also get class suggestion.

  • spyne.util.xml: get_xml_as_object has argument order swapped: cls, elt -> elt, cls. See ab91a3e2ad4756b71d1a2752e5b0d2af8551e061.

  • There’s a final argument order change in Application ctor:

    in_protocol, out_protocol, interface, name


    name, in_protocol, out_protocol, interface

  • Relevant pull requests with new features and behavioral changes:



  • Fix (for real this time) the race condition in wsgi server’s wsdl handler.


  • HttpRpc now parses POST/PUT/PATCH bodies, can accept file uploads. Uses werkzeug to do that, which is now a soft dependency.
  • ByteArray now child of SimpleModel. It’s now possible to customize it simply by calling it.
  • Fix race condition in wsgi server wsdl request.
  • Full change log:




  • Implemented fanout support for transports and protocols that can handle that.
  • Implemented a helper module that generates a Soap/Wsdl 1.1 application in rpclib.util.simple
  • Some work towards supporting Python3 using 2to3. See issue #113.
  • ctx.descriptor.reset_function implemented. It’s now safe to fiddle with that value in event handlers.
  • Added a cleaned-up version of the Django wrapper:
  • Fix most of the tests that fail due to api changes.
  • Fix Http soap client.
  • Full change log:


  • Made color in logs optional
  • Fixed ByteArray serializer



  • Many issues with ‘soft’ validation was fixed.
  • MethodDescriptor.udp added. Short for “User-Defined Properties”, you can use it to store arbitrary metadata about the decorated method.
  • Fix HttpRpc response serialization.
  • Documentation updates.


  • Fixed import errors in Python<=2.5.
  • A problem with rpclib’s String and unicode objects was fixed.


  • Fixed Fault publishing in Wsdl.
  • Implemented ‘soft’ validation.
  • Documentation improvements. It’s mostly ready!
  • A bug with min/max_occurs logic was fixed. This causes rpclib not to send null values for elements with min_occurs=0 (the default value).
  • Native value for rpclib.model.primitive.String was changed to unicode. To exchange raw data, you should use rpclib.model.binary.ByteArray.
  • Full change log:


  • Added MAX_CONTENT_LENGTH = 2 * 1024 * 1024 and BLOCK_LENGTH = 8 * 1024 constants to rpclib.server.wsgi module.
  • rpclib.model.binary.Attachment is deprecated, and is replaced by ByteArray. The native format of ByteArray is an iterable of strings.
  • Exception handling was formalized. HTTP return codes can be set by exception classes from rpclib.error or custom exceptions.
  • Full change log:


  • Limited support for sqlalchemy.orm.relationship (no string arguments)
  • Added missing event firings.
  • Documented event api and fundamental data structures (rpclib._base)
  • Full change log:



  • Documentation improvements.
  • rpclib.protocol.xml.XmlObject is now working as out_protocol.
  • Many fixes.


  • Documentation improvements.
  • rpclib.client.http.Client -> rpclib.client.http.HttpClient
  • rpclib.client.zeromq.Client -> rpclib.client.zeromq.ZeroMQClient
  • rpclib.server.zeromq.Server -> rpclib.server.zeromq.ZeroMQServer
  • rpclib.model.table.TableSerializer -> rpclib.model.table.TableModel


  • Fixed call to rpclib.application.Application.call_wrapper
  • Fixed HttpRpc server transport instantiation.
  • Documentation improvements.


  • rpclib.application.Application.call_wrapper introduced
  • Documentation improvements.


  • The serialization / deserialization logic was redesigned. Now most of the serialization-related logic is under the responsibility of the ProtocolBase children.
  • Interface generation logic was redesigned. The WSDL logic is separated to XmlSchema and Wsdl11 classes. ‘add_to_schema’ calls were renamed to just ‘add’ and were moved inside rpclib.interface.xml_schema package.
  • Interface and Protocol assignment of an rpclib application is now more explicit. Both are also configurable during instantion. This doesn’t mean there’s much to configure :)
  • WS-I Conformance is back!. See for the latest conformance report.
  • Numeric types now support range restrictions. e.g. Integer(ge=0) will only accept positive integers.
  • Any -> AnyXml, AnyAsDict -> AnyDict. AnyAsDict is not the child of the AnyXml anymore.
  • rpclib.model.exception -> rpclib.model.fault.


  • The method dispatch logic was rewritten: It’s now possible for the protocols to override how method request strings are matched to methods definitions.
  • Unsigned integer primitives were added.
  • ZeroMQ client was fixed.
  • Header confusion in native http soap client was fixed.
  • Grouped transport-specific context information under ctx.transport attribute.
  • Added a self reference mechanism.


  • The inclusion of base xml schemas were made optional.
  • WSDL: Fix out header being the same as in header.
  • Added type checking to outgoing Integer types. it’s not handled as nicely as it should be.
  • Fixed the case where changing the _in_message tag name of the method prevented it from being called.
  • SOAP/WSDL: Added support for multiple {in,out}_header objects.
  • Fix some XMLAttribute bugs.


  • Added inheritance support to rpclib.model.table.TableSerializer.


  • The NullServer now also returns context with the return object to have it survive past user-defined method return.


  • More tests are migrated to the new api.
  • Function identifier strings are no more created directly from the function object itself. Function’s key in the class definition is used as default instead.
  • Base xml schemas are no longer imported.


  • Added rpclib.server.null.NullServer, which is a server class with a client interface that attempts to do no (de)serialization at all. It’s intended to be used in tests.


  • Add late mapping support to sqlalchemy table serializer.


  • Add preliminary support for a sqlalchemy-0.7-compatible serializer.


  • Migrate the HttpRpc serializer to the new internal api.


  • SimpleType -> SimpleModel
  • Small bugfixes.


  • EventManager now uses ordered sets instead of normal sets to store event handlers.
  • Implemented sort_wsdl, a small hack to sort wsdl output in order to ease debugging.


  • Implemented EventManager and replaced hook calls with events.

  • The rpc decorator now produces static methods. The methods still get an implicit first argument that holds the service contexts. It’s an instance of the MethodContext class, and not the ServiceBase (formerly DefinitionBase) class.

  • The new srpc decorator doesn’t force the methods to have an implicit first argument.

  • Fixed fault namespace resolution.

  • Moved xml constants to rpclib.const.xml_ns

  • The following changes to soaplib were ported to rpclib’s SOAP/WSDL parts:
    • duration object is now compatible with Python’s native timedelta.
    • WSDL: Support for multiple <service> tags in the wsdl (one for each class in the application)
    • WSDL: Support for multiple <portType> tags and multiple ports.
    • WSDL: Support for enumerating exceptions a method can throw was added.
    • SOAP: Exceptions got some love to be more standards-compliant.
    • SOAP: Xml attribute support
  • Moved all modules with packagename.base to packagename._base.

  • Renamed classes to have module name as a prefix:
    • rpclib.client._base.Base -> rpclib.client._base.ClientBase
    • rpclib.model._base.Base -> rpclib.model._base.ModelBase
    • rpclib.protocol._base.Base -> rpclib.protocol._base.ProtocolBase
    • rpclib.server._base.Base -> rpclib.server._base.ServerBase
    • rpclib.service.DefinitionBase -> rpclib.service.ServiceBase
    • rpclib.server.wsgi.Application -> rpclib.server.wsgi.WsgiApplication
  • Moved some classes and modules around:
    • rpclib.model.clazz -> rpclib.model.complex
    • rpclib.model.complex.ClassSerializer -> rpclib.model.complex.ComplexModel
    • rpclib.Application -> rpclib.application.Application
    • rpclib.service.rpc, srpc -> rpclib.decorator.rpc, srpc

soaplib-3.x -> rpclib-1.1.1-alpha

  • Soaplib is now also protocol agnostic. As it now supports protocols other than soap (like Rest-minus-the-verbs HttpRpc), it’s renamed to rpclib. This also means soaplib can now support multiple versions of soap and wsdl standards.
  • Mention of xml and soap removed from public api where it’s not directly related to soap or xml. (e.g. a hook rename: on_method_exception_xml -> on_method_exception_doc)
  • Protocol serializers now return iterables instead of complete messages. This is a first step towards eliminating the need to have the whole message in memory during processing.


  • This release transformed soaplib from a soap server that exclusively supported http to a soap serialization/deserialization library that is architecture and transport agnostic.
  • Hard dependency on WSGI removed.
  • Sphinx docs with working examples:
  • Serializers renamed to Models.
  • Standalone xsd generation for ClassSerializer objects has been added. This allows soaplib to be used to define generic XML schemas, without SOAP artifacts.
  • Annotation Tags for primitive Models has been added.
  • The soaplib client has been re-written after having been dropped from recent releases. It follows the suds API but is based on lxml for better performance. WARNING: the soaplib client is not well-tested and future support is tentative and dependent on community response.
  • 0mq support added.
  • Twisted supported via WSGI wrappers.
  • Increased test coverage for soaplib and supported servers


  • Standards-compliant Soap Faults
  • Allow multiple return values and return types


  • pritimitive.Array -> clazz.Array
  • Support for SimpleType restrictions (pattern, length, etc.)


  • Soap header support
  • Tried the WS-I Test first time. Many bug fixes.


  • Support for inheritance.


  • Support for publishing multiple service classes.


  • Soap server logic almost completely rewritten.
  • Soap client removed in favor of suds.
  • Object definition api no longer needs a class types: under class definition.
  • XML Schema validation is supported.
  • Support for publishing multiple namespaces. (multiple <schema> tags in the wsdl)
  • Support for enumerations.
  • Application and Service Definition are separated. Application is instantiated on server start, and Service Definition is instantiated for each new request.
  • @soapmethod -> @rpc


  • Switched to lxml for proper xml namespace support.


  • First public stable release.