def load(self, xml):
lookup = etree.ElementNamespaceClassLookup()
parser = etree.XMLParser()
parser.set_element_class_lookup(lookup)
namespace = lookup.get_namespace(style_ns)
namespace.update(dict(style=Style))
self._data = etree.fromstring(xml, parser=parser)
def createFromExisting(cls, source):
"""
Create a TouchOSCLayout instance from an existing TouchOSC Layout.
@type source: filename or fileobject
@param source: Path to an existing .touchosc file, or
TouchOSC index.xml file (from unzipping .touchosc file)
@rtype: Layout
@return: An instance containing the layout
"""
fallback = etree.ElementDefaultClassLookup()
lookupTabpages = etree.ElementNamespaceClassLookup(fallback)
namespace = lookupTabpages.get_namespace(None)
namespace['tabpage'] = tabpage.Tabpage
lookupControls = etree.AttributeBasedElementClassLookup(
'type', controls.type_class_mapping, lookupTabpages)
layoutParser = etree.XMLParser(remove_blank_text=True)
layoutParser.setElementClassLookup(lookupControls)
if type(source) is str:
(path, fname) = os.path.split(source)
(name, extension) = os.path.splitext(fname)
if extension == ".touchosc":
f = ZipFile(source, "r")
layoutTree = etree.parse(StringIO(f.read("index.xml")),
layoutParser)
f.close()
elif extension == ".xml":
name = None
layoutTree = etree.parse(source, layoutParser)
return Layout(layoutTree, name)
def make_custom_class_lookup():
lookup = etree.ElementNamespaceClassLookup(objectify.ObjectifyElementClassLookup())
ns_lookup = lookup.get_namespace(None)
# add any custom class here
ns_lookup['WebApp'] = WebApp
ns_lookup['WebAppAuthRecord'] = WebAppAuthRecord
ns_lookup['ServiceResponse'] = ServiceResponse
return lookup
def __init__(self):
lookup = etree.ElementNamespaceClassLookup()
parser = etree.XMLParser(remove_blank_text=True)
parser.set_element_class_lookup(lookup)
namespace = lookup.get_namespace(NS_DCIF)
namespace['dataCategory'] = self.tag_class
self._tree = etree.parse(self.__file__, parser=parser)
def __init__(self, element_class, namespace=None, schema=None):
self.element_class = element_class
lookup = etree.ElementNamespaceClassLookup()
namespace = lookup.get_namespace(namespace)
namespace[None] = self.element_class
namespace.update({
cls.__name__.lower(): cls
for cls in all_subclasses(self.element_class)
})
self.parser = objectify.makeparser(remove_comments=True,
no_network=True)
self.parser.set_element_class_lookup(lookup)
self.schema = etree.RelaxNG(etree.parse(schema))
def build_parser() -> etree.XMLParser:
parser = objectify.makeparser(remove_blank_text=True)
lookup = etree.ElementNamespaceClassLookup(fallback=objectify.ObjectifyElementClassLookup())
parser.set_element_class_lookup(lookup)
namespace = lookup.get_namespace(SYNC_AGENZIA_FAKE_NS)
for element in (ApeElement, AllegatoElement, IncaricoElement,
InfoElement, DatoDisponibileElement, InfoInseriteElement, DatiDisponibiliElement):
namespace[element.tag_name] = element
return parser
def _initialize():
global MODULE_PARSER, _Element
# fallback = etree.ElementDefaultClassLookup(element=etree.Element)
# lookup = etree.ElementNamespaceClassLookup(fallback)
lookup = etree.ElementNamespaceClassLookup()
# MODULE_PARSER = etree.XMLParser()
MODULE_PARSER = etree.XMLParser(remove_blank_text=True)
MODULE_PARSER.setElementClassLookup(lookup)
_Element = MODULE_PARSER.makeelement
# objectify.setDefaultParser(MODULE_PARSER)
namespace = etree.Namespace(EDXLDE_NS)
for name, klass in element_map:
namespace[name] = klass
def __create_parsing_lookup(self):
lookup = etree.ElementNamespaceClassLookup(
objectify.ObjectifyElementClassLookup())
for mapping in self.get_mappings():
de_cls = mapping.data_element_class
if issubclass(de_cls, XmlLinkedDataElement):
continue
xml_ns = mapping.configuration.get_option(XML_NAMESPACE_OPTION)
xml_tag = bytes_(mapping.configuration.get_option(XML_TAG_OPTION))
ns_cls_map = lookup.get_namespace(xml_ns)
if xml_tag in ns_cls_map:
raise ValueError('Duplicate tag "%s" in namespace "%s" '
'(trying to register class %s)'
% (xml_tag, xml_ns, de_cls))
ns_cls_map[xml_tag] = de_cls
ns_cls_map['link'] = XmlLinkedDataElement
return lookup
def __init__(self, f):
lookup = etree.ElementNamespaceClassLookup()
namespace = lookup.get_namespace('http://purl.org/net/xbiblio/csl')
namespace[None] = CitationStylesElement
namespace.update(dict([(cls.__name__.replace('_', '-').lower(), cls)
for cls in CitationStylesElement.__subclasses__()]))
self.parser = etree.XMLParser(remove_comments=True, encoding='UTF-8',
no_network=True)
self.parser.set_element_class_lookup(lookup)
self.schema = etree.RelaxNG(etree.parse(SCHEMA_PATH))
self.xml = etree.parse(f, self.parser)#, base_url=".")
if not self.schema.validate(self.xml):
err = self.schema.error_log
#raise Exception("XML file didn't pass schema validation:\n%s" % err)
warn("XML file didn't pass schema validation:\n%s" % err)
# TODO: proper error reporting
self.root = self.xml.getroot()
def make_parser(cls):
"""Create a parser with custom tag handling."""
parser = etree.XMLParser(**config['parser_options'])
lookup = etree.ElementNamespaceClassLookup()
parser.set_element_class_lookup(lookup)
namespace = lookup.get_namespace('http://www.tei-c.org/ns/1.0')
namespace[None] = TEITag
def _handlers(target_class):
for subcls in target_class.__subclasses__():
yield from _handlers(subcls)
try:
for target in subcls.targets:
yield subcls, target
except AttributeError:
pass
for handler, target in _handlers(TEITag):
namespace[target] = handler
return parser
def __new__(cls, raw_xml):
mof_json_path = _get_mof_json_path()
if not os.path.exists(mof_json_path):
raise RuntimeError("Must run 'make parsers'")
ns_class_lookup = etree.ElementNamespaceClassLookup()
_ovf_envelope_ns = ns_class_lookup.get_namespace(_OvfElement.NAMESPACE)
_ovf_envelope_ns.update(
cls._recurse_class_tree(_OvfElement, {None: _OvfElement}))
ovf_class_lookup = _OvfXmlClassLookup()
# pylint: disable=no-member
ovf_class_lookup.set_fallback(ns_class_lookup)
# pylint: enable=no-member
parser = etree.XMLParser(attribute_defaults=False,
dtd_validation=False,
ns_clean=True,
schema=None,
remove_comments=True,
remove_pis=True,
remove_blank_text=True)
parser.set_element_class_lookup(ovf_class_lookup)
return etree.XML(raw_xml, parser=parser)
def __init__(self):
self.parser = etree.XMLParser()
fallback = etree.ElementDefaultClassLookup(PDFXML)
lookup = etree.ElementNamespaceClassLookup(fallback)
namespace = lookup.get_namespace(None)
#leafs
namespace['name'] = PDFName
namespace['string'] = PDFString
namespace['number'] = PDFNumber
namespace['null'] = PDFNull
namespace['bool'] = PDFBool
namespace['R'] = PDFR
namespace['header'] = PDFHeader
namespace['startxref'] = PDFStartxref
namespace['data'] = PDFData
#trees
namespace['entry'] = PDFEntry
namespace['dictionary'] = PDFDictionary
namespace['stream'] = PDFStream
namespace['pdf'] = PDFPdf
namespace['pdf_update'] = PDFUpdate
namespace['indirect_object'] = PDFIndirect
namespace['array'] = PDFArray
self.parser.set_element_class_lookup(lookup)
# encoding: utf-8
"""
Initializes oxml sub-package, including registering custom element classes
corresponding to Open XML elements.
"""
from __future__ import absolute_import
from lxml import etree
from .ns import NamespacePrefixedTag, nsmap
# configure XML parser
element_class_lookup = etree.ElementNamespaceClassLookup()
oxml_parser = etree.XMLParser(remove_blank_text=True, resolve_entities=False)
oxml_parser.set_element_class_lookup(element_class_lookup)
def parse_xml(xml):
"""
Return root lxml element obtained by parsing XML character string in
*xml*, which can be either a Python 2.x string or unicode. The custom
parser is used, so custom element classes are produced for elements in
*xml* that have them.
"""
root_element = etree.fromstring(xml, oxml_parser)
return root_element
def register_element_cls(tag, cls):
"""
def drop_tree(self):
"""
Remove the element from the xml tree with all its decendants.
"""
parent = self.getparent()
assert parent is not None
parent.remove(self)
def getTag(self):
"""
Returns the element tag without the namespace.
"""
ind = self.tag.find('}')
if ind < 0:
tag = self.tag
else:
tag = self.tag[ind+1:]
return self.nsprefix+':'+tag
### The XML parser for OOXML documents
lookup = ET.ElementNamespaceClassLookup()
OOXMLParser = ET.XMLParser()
OOXMLParser.set_element_class_lookup(lookup)
NSMAP = {}
Initializes lxml parser and makes available a handful of functions that wrap
its typical uses.
"""
from __future__ import absolute_import
from lxml import etree, objectify
from .ns import NamespacePrefixedTag
# oxml-specific constants
XSD_TRUE = '1'
# configure objectified XML parser
_fallback_lookup = objectify.ObjectifyElementClassLookup()
_element_class_lookup = etree.ElementNamespaceClassLookup(_fallback_lookup)
oxml_parser = etree.XMLParser(remove_blank_text=True)
oxml_parser.set_element_class_lookup(_element_class_lookup)
def parse_xml_bytes(xml_bytes):
"""
Return root lxml element obtained by parsing XML contained in *xml_bytes*.
"""
root_element = objectify.fromstring(xml_bytes, oxml_parser)
return root_element
def register_custom_element_class(nsptag_str, cls):
"""
Register the lxml custom element class *cls* with the parser to be used
if False:
# Custom class chooser works as xmlparser
parser = etree.XMLParser()
parser.set_element_class_lookup(MyLookup())
objtree = etree.fromstring(response, parser)
print(objtree)
print(objtree[2])
print(objtree[3].getchildren())
print(objtree[3][0].try_me())
print(objtree[3][0].getchildren()[0].text) # data.webauthrecord.id
if False:
# use a default namespace solution
parser = etree.XMLParser()
lookup = etree.ElementNamespaceClassLookup()
parser.set_element_class_lookup(lookup)
ns_lookup = lookup.get_namespace(None)
ns_lookup['WebAppAuthRecord'] = api_objects.WebAppAuthRecord
objtree = etree.fromstring(response, parser)
print(objtree)
print(objtree[2])
print(objtree[3].getchildren())
print(objtree[3][0].try_me())
print(objtree[3][0].getchildren()[0].text) # data.webauthrecord.id
class MyLookupObjectify(objectify.ObjectifyElementClassLookup):
def lookup(self, node_type, document, namespace, name):
print(f"MyLookupObjectify {name}")
if name == 'WebAppAuthRecord':
return api_objects.WebAppAuthRecord # be a bit more selective here ...
def _register_mathml_classes(parser):
lookup = _etree.ElementNamespaceClassLookup()
parser.set_element_class_lookup(lookup)
lxml_math_namespace = lookup.get_namespace(MATHML_NAMESPACE_URI)
lxml_math_namespace.update(_all_mathml_classes)
return etree.fromstring(string, parser=XMLParser)
@staticmethod
def to_string(element):
if callable(element):
element = element()
return etree.tostring(
element,
encoding='utf-8',
xml_declaration=True,
pretty_print=True,
)
XMLParserLookup = etree.ElementNamespaceClassLookup(
fallback=etree.ElementDefaultClassLookup(element=ElementBase))
XMLParser = etree.XMLParser(encoding='utf-8', no_network=False)
XMLParser.set_element_class_lookup(XMLParserLookup)
E = ElementMaker(
nsmap=SOAP_NSMAP,
makeelement=XMLParser.makeelement,
)
S = ElementMaker(
namespace=SOAP_ENV_URI,
nsmap=SOAP_NSMAP,
makeelement=XMLParser.makeelement,
)
