Libraries for Subliminal
This commit is contained in:
Ruud
@@ -0,0 +1,56 @@
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the (LGPL) GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Library Lesser General Public License for more details at
|
||||
# ( http://www.gnu.org/licenses/lgpl.html ).
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
# written by: Jeff Ortel ( jortel@redhat.com )
|
||||
|
||||
"""
|
||||
Provides modules containing classes to support
|
||||
unmarshalling (XML).
|
||||
"""
|
||||
|
||||
from suds.sudsobject import Object
|
||||
|
||||
|
||||
|
||||
class Content(Object):
|
||||
"""
|
||||
@ivar node: The content source node.
|
||||
@type node: L{sax.element.Element}
|
||||
@ivar data: The (optional) content data.
|
||||
@type data: L{Object}
|
||||
@ivar text: The (optional) content (xml) text.
|
||||
@type text: basestring
|
||||
"""
|
||||
|
||||
extensions = []
|
||||
|
||||
def __init__(self, node, **kwargs):
|
||||
Object.__init__(self)
|
||||
self.node = node
|
||||
self.data = None
|
||||
self.text = None
|
||||
for k,v in kwargs.items():
|
||||
setattr(self, k, v)
|
||||
|
||||
def __getattr__(self, name):
|
||||
if name not in self.__dict__:
|
||||
if name in self.extensions:
|
||||
v = None
|
||||
setattr(self, name, v)
|
||||
else:
|
||||
raise AttributeError, \
|
||||
'Content has no attribute %s' % name
|
||||
else:
|
||||
v = self.__dict__[name]
|
||||
return v
|
||||
@@ -0,0 +1,88 @@
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the (LGPL) GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Library Lesser General Public License for more details at
|
||||
# ( http://www.gnu.org/licenses/lgpl.html ).
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
# written by: Jeff Ortel ( jortel@redhat.com )
|
||||
|
||||
"""
|
||||
Provides filtered attribute list classes.
|
||||
"""
|
||||
|
||||
from suds import *
|
||||
from suds.umx import *
|
||||
from suds.sax import Namespace
|
||||
|
||||
|
||||
class AttrList:
|
||||
"""
|
||||
A filtered attribute list.
|
||||
Items are included during iteration if they are in either the (xs) or
|
||||
(xml) namespaces.
|
||||
@ivar raw: The I{raw} attribute list.
|
||||
@type raw: list
|
||||
"""
|
||||
def __init__(self, attributes):
|
||||
"""
|
||||
@param attributes: A list of attributes
|
||||
@type attributes: list
|
||||
"""
|
||||
self.raw = attributes
|
||||
|
||||
def real(self):
|
||||
"""
|
||||
Get list of I{real} attributes which exclude xs and xml attributes.
|
||||
@return: A list of I{real} attributes.
|
||||
@rtype: I{generator}
|
||||
"""
|
||||
for a in self.raw:
|
||||
if self.skip(a): continue
|
||||
yield a
|
||||
|
||||
def rlen(self):
|
||||
"""
|
||||
Get the number of I{real} attributes which exclude xs and xml attributes.
|
||||
@return: A count of I{real} attributes.
|
||||
@rtype: L{int}
|
||||
"""
|
||||
n = 0
|
||||
for a in self.real():
|
||||
n += 1
|
||||
return n
|
||||
|
||||
def lang(self):
|
||||
"""
|
||||
Get list of I{filtered} attributes which exclude xs.
|
||||
@return: A list of I{filtered} attributes.
|
||||
@rtype: I{generator}
|
||||
"""
|
||||
for a in self.raw:
|
||||
if a.qname() == 'xml:lang':
|
||||
return a.value
|
||||
return None
|
||||
|
||||
def skip(self, attr):
|
||||
"""
|
||||
Get whether to skip (filter-out) the specified attribute.
|
||||
@param attr: An attribute.
|
||||
@type attr: I{Attribute}
|
||||
@return: True if should be skipped.
|
||||
@rtype: bool
|
||||
"""
|
||||
ns = attr.namespace()
|
||||
skip = (
|
||||
Namespace.xmlns[1],
|
||||
'http://schemas.xmlsoap.org/soap/encoding/',
|
||||
'http://schemas.xmlsoap.org/soap/envelope/',
|
||||
'http://www.w3.org/2003/05/soap-envelope',
|
||||
)
|
||||
return ( Namespace.xs(ns) or ns[1] in skip )
|
||||
@@ -0,0 +1,41 @@
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the (LGPL) GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Library Lesser General Public License for more details at
|
||||
# ( http://www.gnu.org/licenses/lgpl.html ).
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
# written by: Jeff Ortel ( jortel@redhat.com )
|
||||
|
||||
"""
|
||||
Provides basic unmarshaller classes.
|
||||
"""
|
||||
|
||||
from logging import getLogger
|
||||
from suds import *
|
||||
from suds.umx import *
|
||||
from suds.umx.core import Core
|
||||
|
||||
|
||||
class Basic(Core):
|
||||
"""
|
||||
A object builder (unmarshaller).
|
||||
"""
|
||||
|
||||
def process(self, node):
|
||||
"""
|
||||
Process an object graph representation of the xml I{node}.
|
||||
@param node: An XML tree.
|
||||
@type node: L{sax.element.Element}
|
||||
@return: A suds object.
|
||||
@rtype: L{Object}
|
||||
"""
|
||||
content = Content(node)
|
||||
return Core.process(self, content)
|
||||
@@ -0,0 +1,216 @@
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the (LGPL) GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Library Lesser General Public License for more details at
|
||||
# ( http://www.gnu.org/licenses/lgpl.html ).
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
# written by: Jeff Ortel ( jortel@redhat.com )
|
||||
|
||||
"""
|
||||
Provides base classes for XML->object I{unmarshalling}.
|
||||
"""
|
||||
|
||||
from logging import getLogger
|
||||
from suds import *
|
||||
from suds.umx import *
|
||||
from suds.umx.attrlist import AttrList
|
||||
from suds.sax.text import Text
|
||||
from suds.sudsobject import Factory, merge
|
||||
|
||||
|
||||
log = getLogger(__name__)
|
||||
|
||||
reserved = { 'class':'cls', 'def':'dfn', }
|
||||
|
||||
class Core:
|
||||
"""
|
||||
The abstract XML I{node} unmarshaller. This class provides the
|
||||
I{core} unmarshalling functionality.
|
||||
"""
|
||||
|
||||
def process(self, content):
|
||||
"""
|
||||
Process an object graph representation of the xml I{node}.
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: A suds object.
|
||||
@rtype: L{Object}
|
||||
"""
|
||||
self.reset()
|
||||
return self.append(content)
|
||||
|
||||
def append(self, content):
|
||||
"""
|
||||
Process the specified node and convert the XML document into
|
||||
a I{suds} L{object}.
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: A I{append-result} tuple as: (L{Object}, I{value})
|
||||
@rtype: I{append-result}
|
||||
@note: This is not the proper entry point.
|
||||
@see: L{process()}
|
||||
"""
|
||||
self.start(content)
|
||||
self.append_attributes(content)
|
||||
self.append_children(content)
|
||||
self.append_text(content)
|
||||
self.end(content)
|
||||
return self.postprocess(content)
|
||||
|
||||
def postprocess(self, content):
|
||||
"""
|
||||
Perform final processing of the resulting data structure as follows:
|
||||
- Mixed values (children and text) will have a result of the I{content.node}.
|
||||
- Simi-simple values (attributes, no-children and text) will have a result of a
|
||||
property object.
|
||||
- Simple values (no-attributes, no-children with text nodes) will have a string
|
||||
result equal to the value of the content.node.getText().
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: The post-processed result.
|
||||
@rtype: I{any}
|
||||
"""
|
||||
node = content.node
|
||||
if len(node.children) and node.hasText():
|
||||
return node
|
||||
attributes = AttrList(node.attributes)
|
||||
if attributes.rlen() and \
|
||||
not len(node.children) and \
|
||||
node.hasText():
|
||||
p = Factory.property(node.name, node.getText())
|
||||
return merge(content.data, p)
|
||||
if len(content.data):
|
||||
return content.data
|
||||
lang = attributes.lang()
|
||||
if content.node.isnil():
|
||||
return None
|
||||
if not len(node.children) and content.text is None:
|
||||
if self.nillable(content):
|
||||
return None
|
||||
else:
|
||||
return Text('', lang=lang)
|
||||
if isinstance(content.text, basestring):
|
||||
return Text(content.text, lang=lang)
|
||||
else:
|
||||
return content.text
|
||||
|
||||
def append_attributes(self, content):
|
||||
"""
|
||||
Append attribute nodes into L{Content.data}.
|
||||
Attributes in the I{schema} or I{xml} namespaces are skipped.
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
attributes = AttrList(content.node.attributes)
|
||||
for attr in attributes.real():
|
||||
name = attr.name
|
||||
value = attr.value
|
||||
self.append_attribute(name, value, content)
|
||||
|
||||
def append_attribute(self, name, value, content):
|
||||
"""
|
||||
Append an attribute name/value into L{Content.data}.
|
||||
@param name: The attribute name
|
||||
@type name: basestring
|
||||
@param value: The attribute's value
|
||||
@type value: basestring
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
key = name
|
||||
key = '_%s' % reserved.get(key, key)
|
||||
setattr(content.data, key, value)
|
||||
|
||||
def append_children(self, content):
|
||||
"""
|
||||
Append child nodes into L{Content.data}
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
for child in content.node:
|
||||
cont = Content(child)
|
||||
cval = self.append(cont)
|
||||
key = reserved.get(child.name, child.name)
|
||||
if key in content.data:
|
||||
v = getattr(content.data, key)
|
||||
if isinstance(v, list):
|
||||
v.append(cval)
|
||||
else:
|
||||
setattr(content.data, key, [v, cval])
|
||||
continue
|
||||
if self.unbounded(cont):
|
||||
if cval is None:
|
||||
setattr(content.data, key, [])
|
||||
else:
|
||||
setattr(content.data, key, [cval,])
|
||||
else:
|
||||
setattr(content.data, key, cval)
|
||||
|
||||
def append_text(self, content):
|
||||
"""
|
||||
Append text nodes into L{Content.data}
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
if content.node.hasText():
|
||||
content.text = content.node.getText()
|
||||
|
||||
def reset(self):
|
||||
pass
|
||||
|
||||
def start(self, content):
|
||||
"""
|
||||
Processing on I{node} has started. Build and return
|
||||
the proper object.
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: A subclass of Object.
|
||||
@rtype: L{Object}
|
||||
"""
|
||||
content.data = Factory.object(content.node.name)
|
||||
|
||||
def end(self, content):
|
||||
"""
|
||||
Processing on I{node} has ended.
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
pass
|
||||
|
||||
def bounded(self, content):
|
||||
"""
|
||||
Get whether the content is bounded (not a list).
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: True if bounded, else False
|
||||
@rtype: boolean
|
||||
'"""
|
||||
return ( not self.unbounded(content) )
|
||||
|
||||
def unbounded(self, content):
|
||||
"""
|
||||
Get whether the object is unbounded (a list).
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: True if unbounded, else False
|
||||
@rtype: boolean
|
||||
'"""
|
||||
return False
|
||||
|
||||
def nillable(self, content):
|
||||
"""
|
||||
Get whether the object is nillable.
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: True if nillable, else False
|
||||
@rtype: boolean
|
||||
'"""
|
||||
return False
|
||||
@@ -0,0 +1,128 @@
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the (LGPL) GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Library Lesser General Public License for more details at
|
||||
# ( http://www.gnu.org/licenses/lgpl.html ).
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
# written by: Jeff Ortel ( jortel@redhat.com )
|
||||
|
||||
"""
|
||||
Provides soap encoded unmarshaller classes.
|
||||
"""
|
||||
|
||||
from logging import getLogger
|
||||
from suds import *
|
||||
from suds.umx import *
|
||||
from suds.umx.typed import Typed
|
||||
from suds.sax import splitPrefix, Namespace
|
||||
|
||||
log = getLogger(__name__)
|
||||
|
||||
#
|
||||
# Add encoded extensions
|
||||
# aty = The soap (section 5) encoded array type.
|
||||
#
|
||||
Content.extensions.append('aty')
|
||||
|
||||
|
||||
class Encoded(Typed):
|
||||
"""
|
||||
A SOAP section (5) encoding unmarshaller.
|
||||
This marshaller supports rpc/encoded soap styles.
|
||||
"""
|
||||
|
||||
def start(self, content):
|
||||
#
|
||||
# Grab the array type and continue
|
||||
#
|
||||
self.setaty(content)
|
||||
Typed.start(self, content)
|
||||
|
||||
def end(self, content):
|
||||
#
|
||||
# Squash soap encoded arrays into python lists. This is
|
||||
# also where we insure that empty arrays are represented
|
||||
# as empty python lists.
|
||||
#
|
||||
aty = content.aty
|
||||
if aty is not None:
|
||||
self.promote(content)
|
||||
return Typed.end(self, content)
|
||||
|
||||
def postprocess(self, content):
|
||||
#
|
||||
# Ensure proper rendering of empty arrays.
|
||||
#
|
||||
if content.aty is None:
|
||||
return Typed.postprocess(self, content)
|
||||
else:
|
||||
return content.data
|
||||
|
||||
def setaty(self, content):
|
||||
"""
|
||||
Grab the (aty) soap-enc:arrayType and attach it to the
|
||||
content for proper array processing later in end().
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
@return: self
|
||||
@rtype: L{Encoded}
|
||||
"""
|
||||
name = 'arrayType'
|
||||
ns = (None, 'http://schemas.xmlsoap.org/soap/encoding/')
|
||||
aty = content.node.get(name, ns)
|
||||
if aty is not None:
|
||||
content.aty = aty
|
||||
parts = aty.split('[')
|
||||
ref = parts[0]
|
||||
if len(parts) == 2:
|
||||
self.applyaty(content, ref)
|
||||
else:
|
||||
pass # (2) dimensional array
|
||||
return self
|
||||
|
||||
def applyaty(self, content, xty):
|
||||
"""
|
||||
Apply the type referenced in the I{arrayType} to the content
|
||||
(child nodes) of the array. Each element (node) in the array
|
||||
that does not have an explicit xsi:type attribute is given one
|
||||
based on the I{arrayType}.
|
||||
@param content: An array content.
|
||||
@type content: L{Content}
|
||||
@param xty: The XSI type reference.
|
||||
@type xty: str
|
||||
@return: self
|
||||
@rtype: L{Encoded}
|
||||
"""
|
||||
name = 'type'
|
||||
ns = Namespace.xsins
|
||||
parent = content.node
|
||||
for child in parent.getChildren():
|
||||
ref = child.get(name, ns)
|
||||
if ref is None:
|
||||
parent.addPrefix(ns[0], ns[1])
|
||||
attr = ':'.join((ns[0], name))
|
||||
child.set(attr, xty)
|
||||
return self
|
||||
|
||||
def promote(self, content):
|
||||
"""
|
||||
Promote (replace) the content.data with the first attribute
|
||||
of the current content.data that is a I{list}. Note: the
|
||||
content.data may be empty or contain only _x attributes.
|
||||
In either case, the content.data is assigned an empty list.
|
||||
@param content: An array content.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
for n,v in content.data:
|
||||
if isinstance(v, list):
|
||||
content.data = v
|
||||
return
|
||||
content.data = []
|
||||
@@ -0,0 +1,141 @@
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the (LGPL) GNU Lesser General Public License as
|
||||
# published by the Free Software Foundation; either version 3 of the
|
||||
# License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU Library Lesser General Public License for more details at
|
||||
# ( http://www.gnu.org/licenses/lgpl.html ).
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
# written by: Jeff Ortel ( jortel@redhat.com )
|
||||
|
||||
"""
|
||||
Provides typed unmarshaller classes.
|
||||
"""
|
||||
|
||||
from logging import getLogger
|
||||
from suds import *
|
||||
from suds.umx import *
|
||||
from suds.umx.core import Core
|
||||
from suds.resolver import NodeResolver, Frame
|
||||
from suds.sudsobject import Factory
|
||||
|
||||
log = getLogger(__name__)
|
||||
|
||||
|
||||
#
|
||||
# Add typed extensions
|
||||
# type = The expected xsd type
|
||||
# real = The 'true' XSD type
|
||||
#
|
||||
Content.extensions.append('type')
|
||||
Content.extensions.append('real')
|
||||
|
||||
|
||||
class Typed(Core):
|
||||
"""
|
||||
A I{typed} XML unmarshaller
|
||||
@ivar resolver: A schema type resolver.
|
||||
@type resolver: L{NodeResolver}
|
||||
"""
|
||||
|
||||
def __init__(self, schema):
|
||||
"""
|
||||
@param schema: A schema object.
|
||||
@type schema: L{xsd.schema.Schema}
|
||||
"""
|
||||
self.resolver = NodeResolver(schema)
|
||||
|
||||
def process(self, node, type):
|
||||
"""
|
||||
Process an object graph representation of the xml L{node}.
|
||||
@param node: An XML tree.
|
||||
@type node: L{sax.element.Element}
|
||||
@param type: The I{optional} schema type.
|
||||
@type type: L{xsd.sxbase.SchemaObject}
|
||||
@return: A suds object.
|
||||
@rtype: L{Object}
|
||||
"""
|
||||
content = Content(node)
|
||||
content.type = type
|
||||
return Core.process(self, content)
|
||||
|
||||
def reset(self):
|
||||
log.debug('reset')
|
||||
self.resolver.reset()
|
||||
|
||||
def start(self, content):
|
||||
#
|
||||
# Resolve to the schema type; build an object and setup metadata.
|
||||
#
|
||||
if content.type is None:
|
||||
found = self.resolver.find(content.node)
|
||||
if found is None:
|
||||
log.error(self.resolver.schema)
|
||||
raise TypeNotFound(content.node.qname())
|
||||
content.type = found
|
||||
else:
|
||||
known = self.resolver.known(content.node)
|
||||
frame = Frame(content.type, resolved=known)
|
||||
self.resolver.push(frame)
|
||||
real = self.resolver.top().resolved
|
||||
content.real = real
|
||||
cls_name = real.name
|
||||
if cls_name is None:
|
||||
cls_name = content.node.name
|
||||
content.data = Factory.object(cls_name)
|
||||
md = content.data.__metadata__
|
||||
md.sxtype = real
|
||||
|
||||
def end(self, content):
|
||||
self.resolver.pop()
|
||||
|
||||
def unbounded(self, content):
|
||||
return content.type.unbounded()
|
||||
|
||||
def nillable(self, content):
|
||||
resolved = content.type.resolve()
|
||||
return ( content.type.nillable or \
|
||||
(resolved.builtin() and resolved.nillable ) )
|
||||
|
||||
def append_attribute(self, name, value, content):
|
||||
"""
|
||||
Append an attribute name/value into L{Content.data}.
|
||||
@param name: The attribute name
|
||||
@type name: basestring
|
||||
@param value: The attribute's value
|
||||
@type value: basestring
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
type = self.resolver.findattr(name)
|
||||
if type is None:
|
||||
log.warn('attribute (%s) type, not-found', name)
|
||||
else:
|
||||
value = self.translated(value, type)
|
||||
Core.append_attribute(self, name, value, content)
|
||||
|
||||
def append_text(self, content):
|
||||
"""
|
||||
Append text nodes into L{Content.data}
|
||||
Here is where the I{true} type is used to translate the value
|
||||
into the proper python type.
|
||||
@param content: The current content being unmarshalled.
|
||||
@type content: L{Content}
|
||||
"""
|
||||
Core.append_text(self, content)
|
||||
known = self.resolver.top().resolved
|
||||
content.text = self.translated(content.text, known)
|
||||
|
||||
def translated(self, value, type):
|
||||
""" translate using the schema type """
|
||||
if value is not None:
|
||||
resolved = type.resolve()
|
||||
return resolved.translate(value)
|
||||
else:
|
||||
return value
|
||||
Reference in New Issue
Block a user