1485 lines
48 KiB
Python
1485 lines
48 KiB
Python
#!/usr/bin/python
|
|
#
|
|
# Copyright (C) 2006 Google Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
|
|
"""Contains classes representing Atom elements.
|
|
|
|
Module objective: provide data classes for Atom constructs. These classes hide
|
|
the XML-ness of Atom and provide a set of native Python classes to interact
|
|
with.
|
|
|
|
Conversions to and from XML should only be necessary when the Atom classes
|
|
"touch the wire" and are sent over HTTP. For this reason this module
|
|
provides methods and functions to convert Atom classes to and from strings.
|
|
|
|
For more information on the Atom data model, see RFC 4287
|
|
(http://www.ietf.org/rfc/rfc4287.txt)
|
|
|
|
AtomBase: A foundation class on which Atom classes are built. It
|
|
handles the parsing of attributes and children which are common to all
|
|
Atom classes. By default, the AtomBase class translates all XML child
|
|
nodes into ExtensionElements.
|
|
|
|
ExtensionElement: Atom allows Atom objects to contain XML which is not part
|
|
of the Atom specification, these are called extension elements. If a
|
|
classes parser encounters an unexpected XML construct, it is translated
|
|
into an ExtensionElement instance. ExtensionElement is designed to fully
|
|
capture the information in the XML. Child nodes in an XML extension are
|
|
turned into ExtensionElements as well.
|
|
"""
|
|
|
|
|
|
__author__ = 'api.jscudder (Jeffrey Scudder)'
|
|
|
|
try:
|
|
from xml.etree import cElementTree as ElementTree
|
|
except ImportError:
|
|
try:
|
|
import cElementTree as ElementTree
|
|
except ImportError:
|
|
try:
|
|
from xml.etree import ElementTree
|
|
except ImportError:
|
|
from elementtree import ElementTree
|
|
import warnings
|
|
|
|
|
|
# XML namespaces which are often used in Atom entities.
|
|
ATOM_NAMESPACE = 'http://www.w3.org/2005/Atom'
|
|
ELEMENT_TEMPLATE = '{http://www.w3.org/2005/Atom}%s'
|
|
APP_NAMESPACE = 'http://purl.org/atom/app#'
|
|
APP_TEMPLATE = '{http://purl.org/atom/app#}%s'
|
|
|
|
# This encoding is used for converting strings before translating the XML
|
|
# into an object.
|
|
XML_STRING_ENCODING = 'utf-8'
|
|
# The desired string encoding for object members. set or monkey-patch to
|
|
# unicode if you want object members to be Python unicode strings, instead of
|
|
# encoded strings
|
|
MEMBER_STRING_ENCODING = 'utf-8'
|
|
#MEMBER_STRING_ENCODING = unicode
|
|
|
|
# If True, all methods which are exclusive to v1 will raise a
|
|
# DeprecationWarning
|
|
ENABLE_V1_WARNINGS = False
|
|
|
|
|
|
def v1_deprecated(warning=None):
|
|
"""Shows a warning if ENABLE_V1_WARNINGS is True.
|
|
|
|
Function decorator used to mark methods used in v1 classes which
|
|
may be removed in future versions of the library.
|
|
"""
|
|
warning = warning or ''
|
|
# This closure is what is returned from the deprecated function.
|
|
def mark_deprecated(f):
|
|
# The deprecated_function wraps the actual call to f.
|
|
def optional_warn_function(*args, **kwargs):
|
|
if ENABLE_V1_WARNINGS:
|
|
warnings.warn(warning, DeprecationWarning, stacklevel=2)
|
|
return f(*args, **kwargs)
|
|
# Preserve the original name to avoid masking all decorated functions as
|
|
# 'deprecated_function'
|
|
try:
|
|
optional_warn_function.func_name = f.func_name
|
|
except TypeError:
|
|
pass # In Python2.3 we can't set the func_name
|
|
return optional_warn_function
|
|
return mark_deprecated
|
|
|
|
|
|
def CreateClassFromXMLString(target_class, xml_string, string_encoding=None):
|
|
"""Creates an instance of the target class from the string contents.
|
|
|
|
Args:
|
|
target_class: class The class which will be instantiated and populated
|
|
with the contents of the XML. This class must have a _tag and a
|
|
_namespace class variable.
|
|
xml_string: str A string which contains valid XML. The root element
|
|
of the XML string should match the tag and namespace of the desired
|
|
class.
|
|
string_encoding: str The character encoding which the xml_string should
|
|
be converted to before it is interpreted and translated into
|
|
objects. The default is None in which case the string encoding
|
|
is not changed.
|
|
|
|
Returns:
|
|
An instance of the target class with members assigned according to the
|
|
contents of the XML - or None if the root XML tag and namespace did not
|
|
match those of the target class.
|
|
"""
|
|
encoding = string_encoding or XML_STRING_ENCODING
|
|
if encoding and isinstance(xml_string, unicode):
|
|
xml_string = xml_string.encode(encoding)
|
|
tree = ElementTree.fromstring(xml_string)
|
|
return _CreateClassFromElementTree(target_class, tree)
|
|
|
|
|
|
CreateClassFromXMLString = v1_deprecated(
|
|
'Please use atom.core.parse with atom.data classes instead.')(
|
|
CreateClassFromXMLString)
|
|
|
|
|
|
def _CreateClassFromElementTree(target_class, tree, namespace=None, tag=None):
|
|
"""Instantiates the class and populates members according to the tree.
|
|
|
|
Note: Only use this function with classes that have _namespace and _tag
|
|
class members.
|
|
|
|
Args:
|
|
target_class: class The class which will be instantiated and populated
|
|
with the contents of the XML.
|
|
tree: ElementTree An element tree whose contents will be converted into
|
|
members of the new target_class instance.
|
|
namespace: str (optional) The namespace which the XML tree's root node must
|
|
match. If omitted, the namespace defaults to the _namespace of the
|
|
target class.
|
|
tag: str (optional) The tag which the XML tree's root node must match. If
|
|
omitted, the tag defaults to the _tag class member of the target
|
|
class.
|
|
|
|
Returns:
|
|
An instance of the target class - or None if the tag and namespace of
|
|
the XML tree's root node did not match the desired namespace and tag.
|
|
"""
|
|
if namespace is None:
|
|
namespace = target_class._namespace
|
|
if tag is None:
|
|
tag = target_class._tag
|
|
if tree.tag == '{%s}%s' % (namespace, tag):
|
|
target = target_class()
|
|
target._HarvestElementTree(tree)
|
|
return target
|
|
else:
|
|
return None
|
|
|
|
|
|
class ExtensionContainer(object):
|
|
|
|
def __init__(self, extension_elements=None, extension_attributes=None,
|
|
text=None):
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
self.text = text
|
|
|
|
__init__ = v1_deprecated(
|
|
'Please use data model classes in atom.data instead.')(
|
|
__init__)
|
|
|
|
# Three methods to create an object from an ElementTree
|
|
def _HarvestElementTree(self, tree):
|
|
# Fill in the instance members from the contents of the XML tree.
|
|
for child in tree:
|
|
self._ConvertElementTreeToMember(child)
|
|
for attribute, value in tree.attrib.iteritems():
|
|
self._ConvertElementAttributeToMember(attribute, value)
|
|
# Encode the text string according to the desired encoding type. (UTF-8)
|
|
if tree.text:
|
|
if MEMBER_STRING_ENCODING is unicode:
|
|
self.text = tree.text
|
|
else:
|
|
self.text = tree.text.encode(MEMBER_STRING_ENCODING)
|
|
|
|
def _ConvertElementTreeToMember(self, child_tree, current_class=None):
|
|
self.extension_elements.append(_ExtensionElementFromElementTree(
|
|
child_tree))
|
|
|
|
def _ConvertElementAttributeToMember(self, attribute, value):
|
|
# Encode the attribute value's string with the desired type Default UTF-8
|
|
if value:
|
|
if MEMBER_STRING_ENCODING is unicode:
|
|
self.extension_attributes[attribute] = value
|
|
else:
|
|
self.extension_attributes[attribute] = value.encode(
|
|
MEMBER_STRING_ENCODING)
|
|
|
|
# One method to create an ElementTree from an object
|
|
def _AddMembersToElementTree(self, tree):
|
|
for child in self.extension_elements:
|
|
child._BecomeChildElement(tree)
|
|
for attribute, value in self.extension_attributes.iteritems():
|
|
if value:
|
|
if isinstance(value, unicode) or MEMBER_STRING_ENCODING is unicode:
|
|
tree.attrib[attribute] = value
|
|
else:
|
|
# Decode the value from the desired encoding (default UTF-8).
|
|
tree.attrib[attribute] = value.decode(MEMBER_STRING_ENCODING)
|
|
if self.text:
|
|
if isinstance(self.text, unicode) or MEMBER_STRING_ENCODING is unicode:
|
|
tree.text = self.text
|
|
else:
|
|
tree.text = self.text.decode(MEMBER_STRING_ENCODING)
|
|
|
|
def FindExtensions(self, tag=None, namespace=None):
|
|
"""Searches extension elements for child nodes with the desired name.
|
|
|
|
Returns a list of extension elements within this object whose tag
|
|
and/or namespace match those passed in. To find all extensions in
|
|
a particular namespace, specify the namespace but not the tag name.
|
|
If you specify only the tag, the result list may contain extension
|
|
elements in multiple namespaces.
|
|
|
|
Args:
|
|
tag: str (optional) The desired tag
|
|
namespace: str (optional) The desired namespace
|
|
|
|
Returns:
|
|
A list of elements whose tag and/or namespace match the parameters
|
|
values
|
|
"""
|
|
|
|
results = []
|
|
|
|
if tag and namespace:
|
|
for element in self.extension_elements:
|
|
if element.tag == tag and element.namespace == namespace:
|
|
results.append(element)
|
|
elif tag and not namespace:
|
|
for element in self.extension_elements:
|
|
if element.tag == tag:
|
|
results.append(element)
|
|
elif namespace and not tag:
|
|
for element in self.extension_elements:
|
|
if element.namespace == namespace:
|
|
results.append(element)
|
|
else:
|
|
for element in self.extension_elements:
|
|
results.append(element)
|
|
|
|
return results
|
|
|
|
|
|
class AtomBase(ExtensionContainer):
|
|
|
|
_children = {}
|
|
_attributes = {}
|
|
|
|
def __init__(self, extension_elements=None, extension_attributes=None,
|
|
text=None):
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
self.text = text
|
|
|
|
__init__ = v1_deprecated(
|
|
'Please use data model classes in atom.data instead.')(
|
|
__init__)
|
|
|
|
def _ConvertElementTreeToMember(self, child_tree):
|
|
# Find the element's tag in this class's list of child members
|
|
if self.__class__._children.has_key(child_tree.tag):
|
|
member_name = self.__class__._children[child_tree.tag][0]
|
|
member_class = self.__class__._children[child_tree.tag][1]
|
|
# If the class member is supposed to contain a list, make sure the
|
|
# matching member is set to a list, then append the new member
|
|
# instance to the list.
|
|
if isinstance(member_class, list):
|
|
if getattr(self, member_name) is None:
|
|
setattr(self, member_name, [])
|
|
getattr(self, member_name).append(_CreateClassFromElementTree(
|
|
member_class[0], child_tree))
|
|
else:
|
|
setattr(self, member_name,
|
|
_CreateClassFromElementTree(member_class, child_tree))
|
|
else:
|
|
ExtensionContainer._ConvertElementTreeToMember(self, child_tree)
|
|
|
|
def _ConvertElementAttributeToMember(self, attribute, value):
|
|
# Find the attribute in this class's list of attributes.
|
|
if self.__class__._attributes.has_key(attribute):
|
|
# Find the member of this class which corresponds to the XML attribute
|
|
# (lookup in current_class._attributes) and set this member to the
|
|
# desired value (using self.__dict__).
|
|
if value:
|
|
# Encode the string to capture non-ascii characters (default UTF-8)
|
|
if MEMBER_STRING_ENCODING is unicode:
|
|
setattr(self, self.__class__._attributes[attribute], value)
|
|
else:
|
|
setattr(self, self.__class__._attributes[attribute],
|
|
value.encode(MEMBER_STRING_ENCODING))
|
|
else:
|
|
ExtensionContainer._ConvertElementAttributeToMember(
|
|
self, attribute, value)
|
|
|
|
# Three methods to create an ElementTree from an object
|
|
def _AddMembersToElementTree(self, tree):
|
|
# Convert the members of this class which are XML child nodes.
|
|
# This uses the class's _children dictionary to find the members which
|
|
# should become XML child nodes.
|
|
member_node_names = [values[0] for tag, values in
|
|
self.__class__._children.iteritems()]
|
|
for member_name in member_node_names:
|
|
member = getattr(self, member_name)
|
|
if member is None:
|
|
pass
|
|
elif isinstance(member, list):
|
|
for instance in member:
|
|
instance._BecomeChildElement(tree)
|
|
else:
|
|
member._BecomeChildElement(tree)
|
|
# Convert the members of this class which are XML attributes.
|
|
for xml_attribute, member_name in self.__class__._attributes.iteritems():
|
|
member = getattr(self, member_name)
|
|
if member is not None:
|
|
if isinstance(member, unicode) or MEMBER_STRING_ENCODING is unicode:
|
|
tree.attrib[xml_attribute] = member
|
|
else:
|
|
tree.attrib[xml_attribute] = member.decode(MEMBER_STRING_ENCODING)
|
|
# Lastly, call the ExtensionContainers's _AddMembersToElementTree to
|
|
# convert any extension attributes.
|
|
ExtensionContainer._AddMembersToElementTree(self, tree)
|
|
|
|
|
|
def _BecomeChildElement(self, tree):
|
|
"""
|
|
|
|
Note: Only for use with classes that have a _tag and _namespace class
|
|
member. It is in AtomBase so that it can be inherited but it should
|
|
not be called on instances of AtomBase.
|
|
|
|
"""
|
|
new_child = ElementTree.Element('')
|
|
tree.append(new_child)
|
|
new_child.tag = '{%s}%s' % (self.__class__._namespace,
|
|
self.__class__._tag)
|
|
self._AddMembersToElementTree(new_child)
|
|
|
|
def _ToElementTree(self):
|
|
"""
|
|
|
|
Note, this method is designed to be used only with classes that have a
|
|
_tag and _namespace. It is placed in AtomBase for inheritance but should
|
|
not be called on this class.
|
|
|
|
"""
|
|
new_tree = ElementTree.Element('{%s}%s' % (self.__class__._namespace,
|
|
self.__class__._tag))
|
|
self._AddMembersToElementTree(new_tree)
|
|
return new_tree
|
|
|
|
def ToString(self, string_encoding='UTF-8'):
|
|
"""Converts the Atom object to a string containing XML."""
|
|
return ElementTree.tostring(self._ToElementTree(), encoding=string_encoding)
|
|
|
|
def __str__(self):
|
|
return self.ToString()
|
|
|
|
|
|
class Name(AtomBase):
|
|
"""The atom:name element"""
|
|
|
|
_tag = 'name'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Name
|
|
|
|
Args:
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def NameFromString(xml_string):
|
|
return CreateClassFromXMLString(Name, xml_string)
|
|
|
|
|
|
class Email(AtomBase):
|
|
"""The atom:email element"""
|
|
|
|
_tag = 'email'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Email
|
|
|
|
Args:
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
text: str The text data in the this element
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def EmailFromString(xml_string):
|
|
return CreateClassFromXMLString(Email, xml_string)
|
|
|
|
|
|
class Uri(AtomBase):
|
|
"""The atom:uri element"""
|
|
|
|
_tag = 'uri'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Uri
|
|
|
|
Args:
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
text: str The text data in the this element
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def UriFromString(xml_string):
|
|
return CreateClassFromXMLString(Uri, xml_string)
|
|
|
|
|
|
class Person(AtomBase):
|
|
"""A foundation class from which atom:author and atom:contributor extend.
|
|
|
|
A person contains information like name, email address, and web page URI for
|
|
an author or contributor to an Atom feed.
|
|
"""
|
|
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
_children['{%s}name' % (ATOM_NAMESPACE)] = ('name', Name)
|
|
_children['{%s}email' % (ATOM_NAMESPACE)] = ('email', Email)
|
|
_children['{%s}uri' % (ATOM_NAMESPACE)] = ('uri', Uri)
|
|
|
|
def __init__(self, name=None, email=None, uri=None,
|
|
extension_elements=None, extension_attributes=None, text=None):
|
|
"""Foundation from which author and contributor are derived.
|
|
|
|
The constructor is provided for illustrative purposes, you should not
|
|
need to instantiate a Person.
|
|
|
|
Args:
|
|
name: Name The person's name
|
|
email: Email The person's email address
|
|
uri: Uri The URI of the person's webpage
|
|
extension_elements: list A list of ExtensionElement instances which are
|
|
children of this element.
|
|
extension_attributes: dict A dictionary of strings which are the values
|
|
for additional XML attributes of this element.
|
|
text: String The text contents of the element. This is the contents
|
|
of the Entry's XML text node. (Example: <foo>This is the text</foo>)
|
|
"""
|
|
|
|
self.name = name
|
|
self.email = email
|
|
self.uri = uri
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
self.text = text
|
|
|
|
|
|
class Author(Person):
|
|
"""The atom:author element
|
|
|
|
An author is a required element in Feed.
|
|
"""
|
|
|
|
_tag = 'author'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Person._children.copy()
|
|
_attributes = Person._attributes.copy()
|
|
#_children = {}
|
|
#_attributes = {}
|
|
|
|
def __init__(self, name=None, email=None, uri=None,
|
|
extension_elements=None, extension_attributes=None, text=None):
|
|
"""Constructor for Author
|
|
|
|
Args:
|
|
name: Name
|
|
email: Email
|
|
uri: Uri
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
text: str The text data in the this element
|
|
"""
|
|
|
|
self.name = name
|
|
self.email = email
|
|
self.uri = uri
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
self.text = text
|
|
|
|
|
|
def AuthorFromString(xml_string):
|
|
return CreateClassFromXMLString(Author, xml_string)
|
|
|
|
|
|
class Contributor(Person):
|
|
"""The atom:contributor element"""
|
|
|
|
_tag = 'contributor'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Person._children.copy()
|
|
_attributes = Person._attributes.copy()
|
|
|
|
def __init__(self, name=None, email=None, uri=None,
|
|
extension_elements=None, extension_attributes=None, text=None):
|
|
"""Constructor for Contributor
|
|
|
|
Args:
|
|
name: Name
|
|
email: Email
|
|
uri: Uri
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
text: str The text data in the this element
|
|
"""
|
|
|
|
self.name = name
|
|
self.email = email
|
|
self.uri = uri
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
self.text = text
|
|
|
|
|
|
def ContributorFromString(xml_string):
|
|
return CreateClassFromXMLString(Contributor, xml_string)
|
|
|
|
|
|
class Link(AtomBase):
|
|
"""The atom:link element"""
|
|
|
|
_tag = 'link'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
_attributes['rel'] = 'rel'
|
|
_attributes['href'] = 'href'
|
|
_attributes['type'] = 'type'
|
|
_attributes['title'] = 'title'
|
|
_attributes['length'] = 'length'
|
|
_attributes['hreflang'] = 'hreflang'
|
|
|
|
def __init__(self, href=None, rel=None, link_type=None, hreflang=None,
|
|
title=None, length=None, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Link
|
|
|
|
Args:
|
|
href: string The href attribute of the link
|
|
rel: string
|
|
type: string
|
|
hreflang: string The language for the href
|
|
title: string
|
|
length: string The length of the href's destination
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
text: str The text data in the this element
|
|
"""
|
|
|
|
self.href = href
|
|
self.rel = rel
|
|
self.type = link_type
|
|
self.hreflang = hreflang
|
|
self.title = title
|
|
self.length = length
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def LinkFromString(xml_string):
|
|
return CreateClassFromXMLString(Link, xml_string)
|
|
|
|
|
|
class Generator(AtomBase):
|
|
"""The atom:generator element"""
|
|
|
|
_tag = 'generator'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
_attributes['uri'] = 'uri'
|
|
_attributes['version'] = 'version'
|
|
|
|
def __init__(self, uri=None, version=None, text=None,
|
|
extension_elements=None, extension_attributes=None):
|
|
"""Constructor for Generator
|
|
|
|
Args:
|
|
uri: string
|
|
version: string
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.uri = uri
|
|
self.version = version
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
def GeneratorFromString(xml_string):
|
|
return CreateClassFromXMLString(Generator, xml_string)
|
|
|
|
|
|
class Text(AtomBase):
|
|
"""A foundation class from which atom:title, summary, etc. extend.
|
|
|
|
This class should never be instantiated.
|
|
"""
|
|
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
_attributes['type'] = 'type'
|
|
|
|
def __init__(self, text_type=None, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Text
|
|
|
|
Args:
|
|
text_type: string
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.type = text_type
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
class Title(Text):
|
|
"""The atom:title element"""
|
|
|
|
_tag = 'title'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Text._children.copy()
|
|
_attributes = Text._attributes.copy()
|
|
|
|
def __init__(self, title_type=None, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Title
|
|
|
|
Args:
|
|
title_type: string
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.type = title_type
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def TitleFromString(xml_string):
|
|
return CreateClassFromXMLString(Title, xml_string)
|
|
|
|
|
|
class Subtitle(Text):
|
|
"""The atom:subtitle element"""
|
|
|
|
_tag = 'subtitle'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Text._children.copy()
|
|
_attributes = Text._attributes.copy()
|
|
|
|
def __init__(self, subtitle_type=None, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Subtitle
|
|
|
|
Args:
|
|
subtitle_type: string
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.type = subtitle_type
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def SubtitleFromString(xml_string):
|
|
return CreateClassFromXMLString(Subtitle, xml_string)
|
|
|
|
|
|
class Rights(Text):
|
|
"""The atom:rights element"""
|
|
|
|
_tag = 'rights'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Text._children.copy()
|
|
_attributes = Text._attributes.copy()
|
|
|
|
def __init__(self, rights_type=None, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Rights
|
|
|
|
Args:
|
|
rights_type: string
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.type = rights_type
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def RightsFromString(xml_string):
|
|
return CreateClassFromXMLString(Rights, xml_string)
|
|
|
|
|
|
class Summary(Text):
|
|
"""The atom:summary element"""
|
|
|
|
_tag = 'summary'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Text._children.copy()
|
|
_attributes = Text._attributes.copy()
|
|
|
|
def __init__(self, summary_type=None, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Summary
|
|
|
|
Args:
|
|
summary_type: string
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.type = summary_type
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def SummaryFromString(xml_string):
|
|
return CreateClassFromXMLString(Summary, xml_string)
|
|
|
|
|
|
class Content(Text):
|
|
"""The atom:content element"""
|
|
|
|
_tag = 'content'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Text._children.copy()
|
|
_attributes = Text._attributes.copy()
|
|
_attributes['src'] = 'src'
|
|
|
|
def __init__(self, content_type=None, src=None, text=None,
|
|
extension_elements=None, extension_attributes=None):
|
|
"""Constructor for Content
|
|
|
|
Args:
|
|
content_type: string
|
|
src: string
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.type = content_type
|
|
self.src = src
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
def ContentFromString(xml_string):
|
|
return CreateClassFromXMLString(Content, xml_string)
|
|
|
|
|
|
class Category(AtomBase):
|
|
"""The atom:category element"""
|
|
|
|
_tag = 'category'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
_attributes['term'] = 'term'
|
|
_attributes['scheme'] = 'scheme'
|
|
_attributes['label'] = 'label'
|
|
|
|
def __init__(self, term=None, scheme=None, label=None, text=None,
|
|
extension_elements=None, extension_attributes=None):
|
|
"""Constructor for Category
|
|
|
|
Args:
|
|
term: str
|
|
scheme: str
|
|
label: str
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.term = term
|
|
self.scheme = scheme
|
|
self.label = label
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def CategoryFromString(xml_string):
|
|
return CreateClassFromXMLString(Category, xml_string)
|
|
|
|
|
|
class Id(AtomBase):
|
|
"""The atom:id element."""
|
|
|
|
_tag = 'id'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Id
|
|
|
|
Args:
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def IdFromString(xml_string):
|
|
return CreateClassFromXMLString(Id, xml_string)
|
|
|
|
|
|
class Icon(AtomBase):
|
|
"""The atom:icon element."""
|
|
|
|
_tag = 'icon'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Icon
|
|
|
|
Args:
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def IconFromString(xml_string):
|
|
return CreateClassFromXMLString(Icon, xml_string)
|
|
|
|
|
|
class Logo(AtomBase):
|
|
"""The atom:logo element."""
|
|
|
|
_tag = 'logo'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Logo
|
|
|
|
Args:
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def LogoFromString(xml_string):
|
|
return CreateClassFromXMLString(Logo, xml_string)
|
|
|
|
|
|
class Draft(AtomBase):
|
|
"""The app:draft element which indicates if this entry should be public."""
|
|
|
|
_tag = 'draft'
|
|
_namespace = APP_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for app:draft
|
|
|
|
Args:
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def DraftFromString(xml_string):
|
|
return CreateClassFromXMLString(Draft, xml_string)
|
|
|
|
|
|
class Control(AtomBase):
|
|
"""The app:control element indicating restrictions on publication.
|
|
|
|
The APP control element may contain a draft element indicating whether or
|
|
not this entry should be publicly available.
|
|
"""
|
|
|
|
_tag = 'control'
|
|
_namespace = APP_NAMESPACE
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
_children['{%s}draft' % APP_NAMESPACE] = ('draft', Draft)
|
|
|
|
def __init__(self, draft=None, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for app:control"""
|
|
|
|
self.draft = draft
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def ControlFromString(xml_string):
|
|
return CreateClassFromXMLString(Control, xml_string)
|
|
|
|
|
|
class Date(AtomBase):
|
|
"""A parent class for atom:updated, published, etc."""
|
|
|
|
#TODO Add text to and from time conversion methods to allow users to set
|
|
# the contents of a Date to a python DateTime object.
|
|
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
class Updated(Date):
|
|
"""The atom:updated element."""
|
|
|
|
_tag = 'updated'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Date._children.copy()
|
|
_attributes = Date._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Updated
|
|
|
|
Args:
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def UpdatedFromString(xml_string):
|
|
return CreateClassFromXMLString(Updated, xml_string)
|
|
|
|
|
|
class Published(Date):
|
|
"""The atom:published element."""
|
|
|
|
_tag = 'published'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Date._children.copy()
|
|
_attributes = Date._attributes.copy()
|
|
|
|
def __init__(self, text=None, extension_elements=None,
|
|
extension_attributes=None):
|
|
"""Constructor for Published
|
|
|
|
Args:
|
|
text: str The text data in the this element
|
|
extension_elements: list A list of ExtensionElement instances
|
|
extension_attributes: dict A dictionary of attribute value string pairs
|
|
"""
|
|
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def PublishedFromString(xml_string):
|
|
return CreateClassFromXMLString(Published, xml_string)
|
|
|
|
|
|
class LinkFinder(object):
|
|
"""An "interface" providing methods to find link elements
|
|
|
|
Entry elements often contain multiple links which differ in the rel
|
|
attribute or content type. Often, developers are interested in a specific
|
|
type of link so this class provides methods to find specific classes of
|
|
links.
|
|
|
|
This class is used as a mixin in Atom entries and feeds.
|
|
"""
|
|
|
|
def GetSelfLink(self):
|
|
"""Find the first link with rel set to 'self'
|
|
|
|
Returns:
|
|
An atom.Link or none if none of the links had rel equal to 'self'
|
|
"""
|
|
|
|
for a_link in self.link:
|
|
if a_link.rel == 'self':
|
|
return a_link
|
|
return None
|
|
|
|
def GetEditLink(self):
|
|
for a_link in self.link:
|
|
if a_link.rel == 'edit':
|
|
return a_link
|
|
return None
|
|
|
|
def GetEditMediaLink(self):
|
|
for a_link in self.link:
|
|
if a_link.rel == 'edit-media':
|
|
return a_link
|
|
return None
|
|
|
|
def GetNextLink(self):
|
|
for a_link in self.link:
|
|
if a_link.rel == 'next':
|
|
return a_link
|
|
return None
|
|
|
|
def GetLicenseLink(self):
|
|
for a_link in self.link:
|
|
if a_link.rel == 'license':
|
|
return a_link
|
|
return None
|
|
|
|
def GetAlternateLink(self):
|
|
for a_link in self.link:
|
|
if a_link.rel == 'alternate':
|
|
return a_link
|
|
return None
|
|
|
|
|
|
class FeedEntryParent(AtomBase, LinkFinder):
|
|
"""A super class for atom:feed and entry, contains shared attributes"""
|
|
|
|
_children = AtomBase._children.copy()
|
|
_attributes = AtomBase._attributes.copy()
|
|
_children['{%s}author' % ATOM_NAMESPACE] = ('author', [Author])
|
|
_children['{%s}category' % ATOM_NAMESPACE] = ('category', [Category])
|
|
_children['{%s}contributor' % ATOM_NAMESPACE] = ('contributor', [Contributor])
|
|
_children['{%s}id' % ATOM_NAMESPACE] = ('id', Id)
|
|
_children['{%s}link' % ATOM_NAMESPACE] = ('link', [Link])
|
|
_children['{%s}rights' % ATOM_NAMESPACE] = ('rights', Rights)
|
|
_children['{%s}title' % ATOM_NAMESPACE] = ('title', Title)
|
|
_children['{%s}updated' % ATOM_NAMESPACE] = ('updated', Updated)
|
|
|
|
def __init__(self, author=None, category=None, contributor=None,
|
|
atom_id=None, link=None, rights=None, title=None, updated=None,
|
|
text=None, extension_elements=None, extension_attributes=None):
|
|
self.author = author or []
|
|
self.category = category or []
|
|
self.contributor = contributor or []
|
|
self.id = atom_id
|
|
self.link = link or []
|
|
self.rights = rights
|
|
self.title = title
|
|
self.updated = updated
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
class Source(FeedEntryParent):
|
|
"""The atom:source element"""
|
|
|
|
_tag = 'source'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = FeedEntryParent._children.copy()
|
|
_attributes = FeedEntryParent._attributes.copy()
|
|
_children['{%s}generator' % ATOM_NAMESPACE] = ('generator', Generator)
|
|
_children['{%s}icon' % ATOM_NAMESPACE] = ('icon', Icon)
|
|
_children['{%s}logo' % ATOM_NAMESPACE] = ('logo', Logo)
|
|
_children['{%s}subtitle' % ATOM_NAMESPACE] = ('subtitle', Subtitle)
|
|
|
|
def __init__(self, author=None, category=None, contributor=None,
|
|
generator=None, icon=None, atom_id=None, link=None, logo=None,
|
|
rights=None, subtitle=None, title=None, updated=None, text=None,
|
|
extension_elements=None, extension_attributes=None):
|
|
"""Constructor for Source
|
|
|
|
Args:
|
|
author: list (optional) A list of Author instances which belong to this
|
|
class.
|
|
category: list (optional) A list of Category instances
|
|
contributor: list (optional) A list on Contributor instances
|
|
generator: Generator (optional)
|
|
icon: Icon (optional)
|
|
id: Id (optional) The entry's Id element
|
|
link: list (optional) A list of Link instances
|
|
logo: Logo (optional)
|
|
rights: Rights (optional) The entry's Rights element
|
|
subtitle: Subtitle (optional) The entry's subtitle element
|
|
title: Title (optional) the entry's title element
|
|
updated: Updated (optional) the entry's updated element
|
|
text: String (optional) The text contents of the element. This is the
|
|
contents of the Entry's XML text node.
|
|
(Example: <foo>This is the text</foo>)
|
|
extension_elements: list (optional) A list of ExtensionElement instances
|
|
which are children of this element.
|
|
extension_attributes: dict (optional) A dictionary of strings which are
|
|
the values for additional XML attributes of this element.
|
|
"""
|
|
|
|
self.author = author or []
|
|
self.category = category or []
|
|
self.contributor = contributor or []
|
|
self.generator = generator
|
|
self.icon = icon
|
|
self.id = atom_id
|
|
self.link = link or []
|
|
self.logo = logo
|
|
self.rights = rights
|
|
self.subtitle = subtitle
|
|
self.title = title
|
|
self.updated = updated
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
|
|
def SourceFromString(xml_string):
|
|
return CreateClassFromXMLString(Source, xml_string)
|
|
|
|
|
|
class Entry(FeedEntryParent):
|
|
"""The atom:entry element"""
|
|
|
|
_tag = 'entry'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = FeedEntryParent._children.copy()
|
|
_attributes = FeedEntryParent._attributes.copy()
|
|
_children['{%s}content' % ATOM_NAMESPACE] = ('content', Content)
|
|
_children['{%s}published' % ATOM_NAMESPACE] = ('published', Published)
|
|
_children['{%s}source' % ATOM_NAMESPACE] = ('source', Source)
|
|
_children['{%s}summary' % ATOM_NAMESPACE] = ('summary', Summary)
|
|
_children['{%s}control' % APP_NAMESPACE] = ('control', Control)
|
|
|
|
def __init__(self, author=None, category=None, content=None,
|
|
contributor=None, atom_id=None, link=None, published=None, rights=None,
|
|
source=None, summary=None, control=None, title=None, updated=None,
|
|
extension_elements=None, extension_attributes=None, text=None):
|
|
"""Constructor for atom:entry
|
|
|
|
Args:
|
|
author: list A list of Author instances which belong to this class.
|
|
category: list A list of Category instances
|
|
content: Content The entry's Content
|
|
contributor: list A list on Contributor instances
|
|
id: Id The entry's Id element
|
|
link: list A list of Link instances
|
|
published: Published The entry's Published element
|
|
rights: Rights The entry's Rights element
|
|
source: Source the entry's source element
|
|
summary: Summary the entry's summary element
|
|
title: Title the entry's title element
|
|
updated: Updated the entry's updated element
|
|
control: The entry's app:control element which can be used to mark an
|
|
entry as a draft which should not be publicly viewable.
|
|
text: String The text contents of the element. This is the contents
|
|
of the Entry's XML text node. (Example: <foo>This is the text</foo>)
|
|
extension_elements: list A list of ExtensionElement instances which are
|
|
children of this element.
|
|
extension_attributes: dict A dictionary of strings which are the values
|
|
for additional XML attributes of this element.
|
|
"""
|
|
|
|
self.author = author or []
|
|
self.category = category or []
|
|
self.content = content
|
|
self.contributor = contributor or []
|
|
self.id = atom_id
|
|
self.link = link or []
|
|
self.published = published
|
|
self.rights = rights
|
|
self.source = source
|
|
self.summary = summary
|
|
self.title = title
|
|
self.updated = updated
|
|
self.control = control
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
__init__ = v1_deprecated('Please use atom.data.Entry instead.')(__init__)
|
|
|
|
|
|
def EntryFromString(xml_string):
|
|
return CreateClassFromXMLString(Entry, xml_string)
|
|
|
|
|
|
class Feed(Source):
|
|
"""The atom:feed element"""
|
|
|
|
_tag = 'feed'
|
|
_namespace = ATOM_NAMESPACE
|
|
_children = Source._children.copy()
|
|
_attributes = Source._attributes.copy()
|
|
_children['{%s}entry' % ATOM_NAMESPACE] = ('entry', [Entry])
|
|
|
|
def __init__(self, author=None, category=None, contributor=None,
|
|
generator=None, icon=None, atom_id=None, link=None, logo=None,
|
|
rights=None, subtitle=None, title=None, updated=None, entry=None,
|
|
text=None, extension_elements=None, extension_attributes=None):
|
|
"""Constructor for Source
|
|
|
|
Args:
|
|
author: list (optional) A list of Author instances which belong to this
|
|
class.
|
|
category: list (optional) A list of Category instances
|
|
contributor: list (optional) A list on Contributor instances
|
|
generator: Generator (optional)
|
|
icon: Icon (optional)
|
|
id: Id (optional) The entry's Id element
|
|
link: list (optional) A list of Link instances
|
|
logo: Logo (optional)
|
|
rights: Rights (optional) The entry's Rights element
|
|
subtitle: Subtitle (optional) The entry's subtitle element
|
|
title: Title (optional) the entry's title element
|
|
updated: Updated (optional) the entry's updated element
|
|
entry: list (optional) A list of the Entry instances contained in the
|
|
feed.
|
|
text: String (optional) The text contents of the element. This is the
|
|
contents of the Entry's XML text node.
|
|
(Example: <foo>This is the text</foo>)
|
|
extension_elements: list (optional) A list of ExtensionElement instances
|
|
which are children of this element.
|
|
extension_attributes: dict (optional) A dictionary of strings which are
|
|
the values for additional XML attributes of this element.
|
|
"""
|
|
|
|
self.author = author or []
|
|
self.category = category or []
|
|
self.contributor = contributor or []
|
|
self.generator = generator
|
|
self.icon = icon
|
|
self.id = atom_id
|
|
self.link = link or []
|
|
self.logo = logo
|
|
self.rights = rights
|
|
self.subtitle = subtitle
|
|
self.title = title
|
|
self.updated = updated
|
|
self.entry = entry or []
|
|
self.text = text
|
|
self.extension_elements = extension_elements or []
|
|
self.extension_attributes = extension_attributes or {}
|
|
|
|
__init__ = v1_deprecated('Please use atom.data.Feed instead.')(__init__)
|
|
|
|
|
|
def FeedFromString(xml_string):
|
|
return CreateClassFromXMLString(Feed, xml_string)
|
|
|
|
|
|
class ExtensionElement(object):
|
|
"""Represents extra XML elements contained in Atom classes."""
|
|
|
|
def __init__(self, tag, namespace=None, attributes=None,
|
|
children=None, text=None):
|
|
"""Constructor for EtensionElement
|
|
|
|
Args:
|
|
namespace: string (optional) The XML namespace for this element.
|
|
tag: string (optional) The tag (without the namespace qualifier) for
|
|
this element. To reconstruct the full qualified name of the element,
|
|
combine this tag with the namespace.
|
|
attributes: dict (optinal) The attribute value string pairs for the XML
|
|
attributes of this element.
|
|
children: list (optional) A list of ExtensionElements which represent
|
|
the XML child nodes of this element.
|
|
"""
|
|
|
|
self.namespace = namespace
|
|
self.tag = tag
|
|
self.attributes = attributes or {}
|
|
self.children = children or []
|
|
self.text = text
|
|
|
|
def ToString(self):
|
|
element_tree = self._TransferToElementTree(ElementTree.Element(''))
|
|
return ElementTree.tostring(element_tree, encoding="UTF-8")
|
|
|
|
def _TransferToElementTree(self, element_tree):
|
|
if self.tag is None:
|
|
return None
|
|
|
|
if self.namespace is not None:
|
|
element_tree.tag = '{%s}%s' % (self.namespace, self.tag)
|
|
else:
|
|
element_tree.tag = self.tag
|
|
|
|
for key, value in self.attributes.iteritems():
|
|
element_tree.attrib[key] = value
|
|
|
|
for child in self.children:
|
|
child._BecomeChildElement(element_tree)
|
|
|
|
element_tree.text = self.text
|
|
|
|
return element_tree
|
|
|
|
def _BecomeChildElement(self, element_tree):
|
|
"""Converts this object into an etree element and adds it as a child node.
|
|
|
|
Adds self to the ElementTree. This method is required to avoid verbose XML
|
|
which constantly redefines the namespace.
|
|
|
|
Args:
|
|
element_tree: ElementTree._Element The element to which this object's XML
|
|
will be added.
|
|
"""
|
|
new_element = ElementTree.Element('')
|
|
element_tree.append(new_element)
|
|
self._TransferToElementTree(new_element)
|
|
|
|
def FindChildren(self, tag=None, namespace=None):
|
|
"""Searches child nodes for objects with the desired tag/namespace.
|
|
|
|
Returns a list of extension elements within this object whose tag
|
|
and/or namespace match those passed in. To find all children in
|
|
a particular namespace, specify the namespace but not the tag name.
|
|
If you specify only the tag, the result list may contain extension
|
|
elements in multiple namespaces.
|
|
|
|
Args:
|
|
tag: str (optional) The desired tag
|
|
namespace: str (optional) The desired namespace
|
|
|
|
Returns:
|
|
A list of elements whose tag and/or namespace match the parameters
|
|
values
|
|
"""
|
|
|
|
results = []
|
|
|
|
if tag and namespace:
|
|
for element in self.children:
|
|
if element.tag == tag and element.namespace == namespace:
|
|
results.append(element)
|
|
elif tag and not namespace:
|
|
for element in self.children:
|
|
if element.tag == tag:
|
|
results.append(element)
|
|
elif namespace and not tag:
|
|
for element in self.children:
|
|
if element.namespace == namespace:
|
|
results.append(element)
|
|
else:
|
|
for element in self.children:
|
|
results.append(element)
|
|
|
|
return results
|
|
|
|
|
|
def ExtensionElementFromString(xml_string):
|
|
element_tree = ElementTree.fromstring(xml_string)
|
|
return _ExtensionElementFromElementTree(element_tree)
|
|
|
|
|
|
def _ExtensionElementFromElementTree(element_tree):
|
|
element_tag = element_tree.tag
|
|
if '}' in element_tag:
|
|
namespace = element_tag[1:element_tag.index('}')]
|
|
tag = element_tag[element_tag.index('}')+1:]
|
|
else:
|
|
namespace = None
|
|
tag = element_tag
|
|
extension = ExtensionElement(namespace=namespace, tag=tag)
|
|
for key, value in element_tree.attrib.iteritems():
|
|
extension.attributes[key] = value
|
|
for child in element_tree:
|
|
extension.children.append(_ExtensionElementFromElementTree(child))
|
|
extension.text = element_tree.text
|
|
return extension
|
|
|
|
|
|
def deprecated(warning=None):
|
|
"""Decorator to raise warning each time the function is called.
|
|
|
|
Args:
|
|
warning: The warning message to be displayed as a string (optinoal).
|
|
"""
|
|
warning = warning or ''
|
|
# This closure is what is returned from the deprecated function.
|
|
def mark_deprecated(f):
|
|
# The deprecated_function wraps the actual call to f.
|
|
def deprecated_function(*args, **kwargs):
|
|
warnings.warn(warning, DeprecationWarning, stacklevel=2)
|
|
return f(*args, **kwargs)
|
|
# Preserve the original name to avoid masking all decorated functions as
|
|
# 'deprecated_function'
|
|
try:
|
|
deprecated_function.func_name = f.func_name
|
|
except TypeError:
|
|
# Setting the func_name is not allowed in Python2.3.
|
|
pass
|
|
return deprecated_function
|
|
return mark_deprecated
|