Quick follow up to the 0.3 release that made working multi-port service definitions

harder then necessary. After consideration (and a good night sleep),
it seemed obvious that a few changes would make this much easier: 1) filter out
the non-soap bindings - they were causing the real trouble; 2) since most servers
are happy with any of the soap bindings (soap 1.1 and 1.2), ambigious references to methods
when invoking then without the port qualification will work just fine in almost every
case. So, why not just allow suds to select the port. Let's not make the user do it
when it's not necessary. In most cases, uses on 0.2.9 and earlier will not have to
update there code when moving to 0.3.1 as they might have in 0.3.

version 0.3 (9-30-08):

Extends the support for multi-port services introduced in 0.2.9. This addition,

provides for multiple services to define the same method and suds will
handle it properly. See section 'SERVICES WITH MULTIPLE PORTS:'

Add support for multi-document document/literal soap binding style.

See section 'MULTI-DOCUMENT Docuemnt/Literal:'

Add support for (xs:group, xs:attributeGroup) tags.

Add Client.last_sent() and Client.last_received().

version 0.2.9 (9-09-08):

Support for multiple ports within a service.

Attribute references <xs:attribute ref=""/>

Make XML special character encoder in sax package - pluggable

version 0.2.8 (8-28-08):

Update document/literal binding to always send the document root referenced by the <part/>.

After yet another review of the space and user input, seems like the referenced
element is ALWAYS the document root.

Add support for 'binding' schemaLocations to namespace-uri.
This is for imports that don's specify a schemaLocation and still expect the schema
to be downloaded. Eg: Axis references 'http://schemas.xmlsoap.org/soap/encoding/'
without a schemaLocation. So, by doing this:

longer copy imported schemas, rather the import proxies find requests; Add ServiceDefinition class which
provides better service inspection; also provides namespace mapping and show types; schema property api simplified;
support for xs:any and xs:anyType added; Some schema lookup problems fixed; Binding classes refactored slightly;
A lot of debug logging added (might have to comment some out for performance - some of the args are expensive).

Add sudsobject.Property; a property is a special Object that contains a (value) attributeand is returned by the

Builder (factory) for schema-types without children such as: <element/> and <simpleType/>; Builder, Marshallers
and Resolvers updated to handle Properties; Resolver, Schema also updated to handle attribute lookups (this was missing)

Add derived() to SchemaObject. This is needed to ensure that all derived types (wsdl classes)

are qualified by xsi:type without specifying the xsi:type for all custom types as did in earlier
releases of suds. Update the literal marshaller to only add the xsi:type when the type needs
to be specified.

Change ns promotion in sax to prevent ns promoted to parent when parent has the prefix.

Changed binding returned_type() to return the (unresolved) Element

In order to support the new features and fix reported bugs,

I'm in the process of refactoring and hopefully evolving the components
in Suds that provide the input/output translations:

Builder ( translates: XSD objects => python objects )

Marshaller ( translates: python objects => XML/SOAP )

Unmarshaller ( translates: soap/xml => python objects )

This evolution will provide better symmetry between these components as follows:

The Builder and Unmarshaller will produce python
(subclass of sudsobject.Object) objects with:

__metadata__.__type__ = XSD type (SchemaObject)

subclass name ( __class__.__name__ ) = schema-type name.

and

The Marshaller(s), while consuming python objects produced by the Builder or
Unmarshaller, will leverage this standard information to
produce the appropriate output ( XML/SOAP ).

The 0.2.1 code behaves mostly like this but ... not quite.
Also, the implementations have some redundancy.

While doing this, it made sense to factor out the common schema-type "lookup"
functionality used by the Builder, Marshallers and Unmarshaller classes into a
hierarchy of "Resolver" classes. This reduces the complexity and redundancy
of the Builder, Marshallers and Unmarshaller classes and allows for better
modularity. Once this refactoring was complete, the difference between the
literal/encoded Marshallers became very small. Given that the amount of code
in the bindings.literal and bindings.encoded packages was small (and getting smaller)
and in the interest of keeping the Suds code base compact, I moved all of the
marshalling classes to the bindings.marshaller module.
All of the bindings.XX sub-packages will be removed.

The net effect:

All of the Suds major components:

client (old: service proxy)

wsdl
* schema (xsd package)
* resolvers

output (marshalling)

builder

input (unmarshalling)

Now have better:

modularity

symmetry with regard to Object metadata.

code re-use (< 1% code duplication --- i hope)

looser coupling

... and better provide for the following features/bug-fixes:

(fix) Proper level of XML element qualification based on

<schema elementFormDefault=""/> attribute. This will ensure that when
elementFormDefault="qualified", Suds will include the proper namespace on
root elements for both literal and encoded bindings. In order for this to
work properly, the literal marshaller (like the encoded marshaller) needed
to be schema-type aware. Had i added the same schema-type lookup as the
encoded marshaller instead of the refactoring described above, the two
classes would have been almost a complete duplicate of each other :-(

The builder and unmarshaller used the schema.Schema.find()
to resolve schema-types. They constructed a path as "person.name.first"
to resolve types in proper context. Since the Schema.find() was stateless,
it resolved the intermediate path elements on every call. The new resolver
classes are statefull and resolve child types much more efficiently.

Prevent name collisions in sudsobject.Object like the items() method. I've moved all
methods (including class methods) to a Factory class that is included in the Object class
as a class attr ( __factory__ ). Now that all attributes have python built-in naming,
we should not have any more name collisions. This of course assumes that no wsdl/schema
entity names will have a name with the python built-in naming convention
but I have to draw the line somewhere :-)

version 0.2.1 (5-8-08):

Update the schema.py SchemaProperty loading sequence so that the schema is loaded in 3 steps:

The wsdl was also changed to only load the schema once and store it. The schema collection was
changed to load schemas in 2 steps:

create all raw schema objects.

load schemas.

This ensure that local <import/>'d schemas can be found when referenced out of order.
The sax.py Element interface changed: attribute() replaced by get() and set().
Also, __getitem__ and __setitem__ can be used to access attribute values.
Epydocs updated for sax.py. And ... last <element ref=/> now supported properly.

fix logging by: NOT setting to info in suds.__init__.logger(); set handler on root logger

only; moved logger (log) from classes to modules and use __name__ for logger name.
NOTE: This means that to enable soap message logging:

>
> logger('suds.serviceproxy').setLevel(logging.DEBUG)
>

-- instead of --

>
> logger('serviceproxy').setLevel(logging.DEBUG)
>

Add support for (xsd) schema <attribute/> nodes which primarily affects objects returned by the Builder

Update serviceproxy.py:set_proxies() to log DEBUG instead of INFO.

Enhance schema __str__ to show both the raw xml and the model (mostly for debugging).

version-0.2 (04-28-08):

Contains the first cut at the rpc/encoded soap style.

Replaced Property class with suds.sudsobject.Object. The Property class was developed a long time

ago with a slightly different purpose. The suds Object is a simpler (more straight forward) approach that
requires less code and works better in the debugger.

The Binding (and the encoding) is selected on a per-method basis which is more consistent with the wsdl.

In <= 0.1.7, the binding was selected when the ServiceProxy was constructed and used for all service
methods. The binding was stored as self.binding. Since the WSDL provides for a separate binding style and
encoding for each operation, Suds needed to be change to work the same way.

The (nil_supported) and (faults) flag(s) passed into the service proxy using **kwargs. In addition to these

flags, a (http_proxy) flag has been added and is passed to the urllib2.Request object. The following args
are supported:

nil_supported = The bindings will set the xsi:nil="true" on nodes that have a value=None when this

flag is True (default:True). Otherwise, an empty node <x/> is sent.

proxy = An http proxy to be specified on requests (default:{}).

The proxy is defined as {protocol:proxy,}

Http proxy supported (see above).

ServiceProxy refactored to delegate to a SoapClient. Since the service proxy exposes web services via getattr(),

any attribute (including methods) provided by the ServiceProxy class hides WS operations defined by the
wsdl. So, by moving everything to the SoapClient, wsdl operations are no longer hidden without
having to use hoky names for attributes and methods in the service proxy. Instead, the service proxy has
__client__ and __factory__ attributes (which really should be at low risk for name collision). For now the
get_instance() and get_enum() methods have not been moved to preserve backward compatibility. Although,
the prefered API change would to replace:

<x xsi:nil=true/> and <x/> is unmarshalled as '' and <x xsi:nil/> is unmarshalled as None.

service.binding.nil_supported = False -- means that property values = None are marshalled (out) as
<x/> and <x/> and <x xsi:nil=true/> is unmarshalled as None.
The xsi:nil is really ignored.

THE DEFAULT IS (TRUE)

Sax handler updated to handle multiple character() callbacks when the sax parser "chunks" the text.
When the node.text is None, the node.text is set to the characters. Else, the characters are appended.
Thanks - andrea.spinelli@imteam.it

Replaced special (text) attribute with __text__ to allow for natural elements named "text"

XML output encoded as UTF-8 which matches the HTTP header and supports unicode.

SchemaCollection changed to provide the builtin() and custom() methods. To support this, findPrefixes() was added to the
Element in sax.py. This is a better approach anyway since the wsdl and schemas may have many prefixes
to http://www.w3.org/2001/XMLSchema. Tested with both doc/lit and rpc/lit bindings

Refactored bindings packages from document & rpc to literal & encoded

Contains the completion of full namespace support as follows:

Namespace prefixes are no longer stripped from attribute values that
reference types defined in the wsdl.

Schema's imported using <import/> should properly handle namespace and prefix
mapping and re-mapping as needed.

All types are resolved, using fully qualified (w/ namespaces) lookups.

Schema.get_type() supports paths with and without ns prefixes. When no prefix
is specified the type is matched using the schema's target namespace.

Property maintains attribute names (keys) in the order added. This also means
that get_item() and get_names() return ordered values.

( Although, I suspect ordering really needs to be done in the marshaller using the

order specified in the wsdl/schema )

Major refactoring of the schema.py. The primary goals is perparation for type lookups that are
fully qualified by namespace. Once completed, the prefixes on attribute values will not longer
be stripped (purged).
Change Summary:

SchemaProperty overlay classes created at __init__ instead of on-demand.

schema imports performed by new Import class instead of by Schema.

Schema loads top level properties using a factory.

All SchemaProperty /children/ lists are sorted by __cmp__ in SchemaProperty derived classes.
This ensures that types with the same name are resolved in the following order (Import, Complex, Simple, Element).

All /children/ SchemaProperty lists are constructed at __init__ instead of on-demand.

The SchemaGroup created and WSDL class updated. This works better then having the wsdl aggregate the <schema/>
nodes which severs linkage to the wsdl parent element that have namespace prefix mapping.

<import/> element handles properly in that both namespace remapping and prefix re-mapping of the imported schema's
targetNamespace and associated prefix mapping - is performed.

Eg: SCHMEA-A has prefix (tns) mapped as xmlns:tns=http://nsA and has targetNamespace=http://nsA.
SCHEMA-B is importing schema A and has prefix (abc) mapped as xmlns:abc=http://nsABC.
SCHEMA-B imports A as <import namespace=http://nsB xxx schemaLocation=http://nsA/schema-a.xsd&gt;.
So, since SCHEMA-B will be referencing elements of SCHEMA-A with prefix (abc) such as abc:something, SCHEMA-A's
targetNamespace must be updated as http://nsABC and all element with type=tns:something must be updated to be
type=abc:something so then can be resolved.

Fixes unmarshalling problem where nodes are added to property as (text, value). This as introduced when the
bindings were refactored.

Fixed various Property print problems.

Notes:

Thanks to Jesper Noehr of Coniuro for the majority of the rpc/literal binding and
for lots of collaboration on #suds.

Add proper handling of method params that are lists of property
objects.

version-0.1.3 (12-19-07):

Fixes problem where nodes marked as a collection (maxOccurs > 1) not

creating property objects with value=[] when mapped-in with < 2
values by the DocumentReader. Caused by missing the
bindings.Document.ReplyHint.stripns() (which uses the DocumentReader.stripns())
conversion to DocumentReader.stripn() now returning a tuple (ns,tag) as
of 0.1.2.

version-0.1.2 (12-18-07):

This release contains an update to property adds:

metadata support

overrides: __getitem__, __setitem__, __contans__

changes property(reader|writer) to use the property.metadata

to handle namespaces for XML documents.

fixes setup.py requires.

version-0.1.1 (12-17-07):

This release marks the first release in fedora hosted.

Unlimited private and public hosted repositories. Free for small teams!