def createDC(root = None, tagName = DC_ROOT_TAG, ns = DC_NAMESPACE):
'''
@param root: the root tag of the document containing this element
@param tagName: the tagName
@param ns: the tag namespace
'''
return createMarkup(tagName, DC_PREFIX, ns, root)
def createLink(href, root = None, ns = ATOM_NAMESPACE, rel = None, itype = None, hreflang = None, title = None, length = None):
'''
@param href:
@param root: the document root element where attach the prefix:namespace for this element
@param rel: one of the Link.REL constants
@param type:
@param hreflang:
@param title: an atom.Title instance
@param length: length of the resource in bytes
'''
markup = createMarkup('link', ATOM_PREFIX, ns, root)
markup.set('href', href)
if rel is not None:
markup.set('rel', rel)
if itype is not None:
markup.set('type', itype)
if hreflang is not None:
markup.set('hreflang', hreflang)
if title is not None:
markup.set('title', title)
if length is not None:
markup.set('length', length)
return markup
def createAtom(root = None, tagName = ATOM_ROOT_TAG, ns = ATOM_NAMESPACE):
'''
Returns an ElementTree.Element representing an Atom tag
@param root: the root tag of the document containing this element
@param tagName: the tagName
@param ns: the tag namespace
@return: a new ElementTree.Element instance
'''
return createMarkup(tagName, ATOM_PREFIX, ns, root)
def createDate(root = None, body = None, ns = DC_NAMESPACE):
'''
@param root: the root tag of the document containing this element
@param body: the date value
@param ns: the tag namespace
'''
date = createMarkup('date', DC_PREFIX, ns, root)
if body is not None:
date.text = body
return date
def createWhere(root = None, body = None, ns = GEORSS_NAMESPACE):
'''
@param root: the root tag of the document containing this element
@param body: a gml.Polygon instance (for now....)
@param ns: the tag namespace
'''
where = createMarkup('where', GEORSS_PREFIX, ns, root)
if body is not None:
where.append(body)
return where
def create_osdescription(os_responses, os_description, query, ospath, root = None, tagName = OS_ROOT_TAG, ns = OS_NAMESPACE):
"""
@param osResponses: a list of OSResponse instances
@param os_description: an OpenSearchDescription instance
@param query: an OSQuery instance
"""
markup = createMarkup(OS_ROOT_TAG, OS_PREFIX, ns, root)
markup.append(create_short_name(os_description.os_short_name, root = markup))
markup.append(create_description(os_description.os_description, root = markup))
if hasattr(os_description, 'os_tags'):
markup.append(create_tags(os_description.os_tags, root = markup))
if hasattr(os_description, 'os_contact'):
markup.append(create_contact(os_description.os_contact, root = markup))
if hasattr(os_description, 'os_long_name'):
markup.append(create_long_name(os_description.os_long_name, root = markup))
if hasattr(os_description, 'os_developer'):
markup.append(create_developer(os_description.os_developer, root = markup))
if hasattr(os_description, 'os_attribution'):
markup.append(create_attribution(os_description.os_attribution, root = markup))
if hasattr(os_description, 'os_image') and isinstance(os_description.os_image, list):
for img in os_description.os_image:
markup.append(create_image(img.url, img.height, img.width, root = markup))
if hasattr(os_description, 'os_syndacation_right') and os_description.os_syndacation_right != OS_SYNDACATION_RIGHT_DEFAULT:
markup.append(create_syndacation_right(os_description.os_syndacation_right, root = markup))
if hasattr(os_description, 'os_adult_content'):
markup.append(create_adult_content(os_description.os_adult_content, root = markup))
if os_description.os_language and isinstance(os_description.os_language, list):
for item in os_description.os_language:
markup.append(create_language(item, root = markup))
if os_description.os_input_encoding and isinstance(os_description.os_input_encoding, list):
for item in os_description.os_input_encoding:
markup.append(create_input_encoding(item, root = markup))
if os_description.os_output_encoding and isinstance(os_description.os_output_encoding, list):
for item in os_description.os_output_encoding:
markup.append(create_output_encoding(item, root = markup))
for item in os_responses:
url = create_url(query, item.extension, ospath, root = markup)
markup.append(url)
return markup
def createTitle(root = None, ns = ATOM_NAMESPACE, body = None, itype = TEXT_TYPE):
"""
Creates an Atom.title element.
The 'body' parameter is assigned to the tag according to the 'itype' parameter;
itype == XHTML_TYPE ---> body must be an ElementTree.Element instance
itype == HTML_TYPE or TEXT_TYPE ---> body should be a text string
@param root: the document owning this tag
@param ns: the namespace associated with this tag
@param body: the tag content
@param itype: the tag content type. It accepts TEXT_TYPE, HTML_TYPE, XHTML_TYPE values
@return: an ElementTree.Element instance
"""
markup = createMarkup('title', ATOM_PREFIX, ns, root = root)
return _assignTypeAtribute(itype, markup, body)
def createLink(iri, rel = None, itype = None, root = None, ns = ATOM_NAMESPACE):
'''
@param iri: contains the link's IRI
@param rel: a string like 'self', 'first', 'last', ...
@param itype: an advisory media type as 'application/atom+xml'
@param root: the root tag of the document containing this element
@param ns: the tag namespace
@return: a new ElementTree.Element instance
'''
markup = createMarkup('link', ATOM_PREFIX, ns, root)
markup.set('href', iri)
if rel is not None:
markup.set('rel', rel)
if itype is not None:
markup.set('type', itype)
return markup
def create_url(query, response_type, ospath, root = None, tagName = OS_ROOT_TAG, ns = OS_NAMESPACE):
markup = createMarkup('Url', OS_PREFIX, ns, root)
markup.set("type", get_mimetype(response_type))
template_query = create_template_query(root, query)
query_template = ("%s%s?%s") % (ospath, response_type, template_query[:-1])
markup.set("template", query_template)
if query.rel is not None and query.rel != URL_REL_DEFAULT:
markup.set("rel", query.rel)
if query.indexOffset is not None and query.indexOffset != URL_INDEX_OFFSET_DEFAULT:
markup.set("indexOffset", str(query.indexOffset))
if query.pageOffset is not None and query.pageOffset != URL_PAGE_OFFSET_DEFAULT:
markup.set("pageOffset", str(query.pageOffset))
return markup
def create_query(mimetype, params_model, params_values, is_response = True, root = None, tag_name = OS_ROOT_TAG, ns = OS_NAMESPACE):
'''
Returns an ElementTree.Element representing an OpenSearch.Query tag
@param mimetype:
@param params_model: a list of OSParam instances
@param params_values: a dictionary containing one value or None to pair with the params_model
@param root: the root tag of the document containing this element
@param tagName: the tagName
@param ns: the tag namespace
@return: a new ElementTree.Element instance
'''
markup = createMarkup('Query', OS_PREFIX, ns, root)
markup.set("role", "request")
for param in params_model:
if param.par_name in params_values and params_values[param.par_name] is not None:
if param.term_name == 'searchTerms':
markup.set(param.term_name, ' '.join(str(x) for x in params_values[param.par_name]))
else:
markup.set(param.par_name, params_values[param.par_name])
return markup
def createEntry(iid, title, updated, \
author = None, content = None, link = None, \
published = None, root = None,
ns = ATOM_NAMESPACE):
'''
Constructor
@param iid: an atom.ID instance
@param title: an atom.Title instance
@param updated: an atom.Update instance
@param author: one or more atom.Author instances
@param content: an atom.Content instance
@param link: one or more atom.Link instances
@param published: an atom.Published instance
@param root: the document root element where attach the prefix:namespace for this element
'''
markup = createMarkup('entry', ATOM_PREFIX, ns, root)
markup.append(iid)
markup.append(title)
markup.append(updated)
if author is not None:
if isinstance(author, list):
extendElement(markup, author)
else:
markup.append(author)
if content is not None:
markup.append(content)
if link is not None:
markup.append(link)
if published is not None:
markup.append(published)
return markup
def createRights(root = None, ns = ATOM_NAMESPACE, body = None, itype = TEXT_TYPE):
markup = createMarkup('rights', ATOM_PREFIX, ns, root = root)
return _assignTypeAtribute(itype, markup, body)
def short_name_test(self):
markup = createMarkup(OS_ROOT_TAG, OS_PREFIX, OS_NAMESPACE)
markup.append(create_short_name("augh!",root = markup))
res = tostring(markup)
self.assertEqual(res, '<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">\
<ShortName>augh!</ShortName></OpenSearchDescription>', "Error")
def createContributor(root = None, ns = ATOM_NAMESPACE, uri = None, email = None):
markup = createMarkup('contributor', ATOM_PREFIX, ns, root)
return _createPerson(markup, uri, email)
