def get_default_cache(): global default_cache if default_cache == None: default_cache = cacheRepository() # now we can activate the entity loader libxml2.setEntityLoader(libxml2_entity_loader) return default_cache
def _render(self, source_xml, content_type): """ Render document using libxslt. """ global xslt_cache # handle URI's as if they were in the ZODB resolver = UriResolver(self).resolve libxml2.setEntityLoader(resolver) stylesheet = self() key = self.absolute_url(1) if cache_on and xslt_cache.has_key(key): style = xslt_cache[key] else: styledoc = libxml2.parseDoc(stylesheet) style = libxslt.parseStylesheetDoc(styledoc) if cache_on: xslt_cache[key] = style doc = libxml2.parseDoc(source_xml) result = style.applyStylesheet(doc, None) result_string = '' try: if not RENDERVIAFILE: result_string = style.saveResultToString(result) else: # this is how we have to do things prior to the # 1.0.21 release of libxslt, a pretty horrible hack fn = tempfile.mktemp() style.saveResultToFilename(fn, result, 0) f = file(fn) result_string = f.read() f.close() os.remove(fn) finally: if not cache_on: style.freeStylesheet() doc.freeDoc() result.freeDoc() return result_string
# libxml2.substituteEntitiesDefault(1) testsuite = libxml2.parseFile(CONF) # # Error and warnng callbacks # def callback(ctx, str): global log log.write("%s%s" % (ctx, str)) libxml2.registerErrorHandler(callback, "") libxml2.setEntityLoader(resolver) root = testsuite.getRootElement() if root.name != 'testSuite': print "%s doesn't start with a testSuite element, aborting" % (CONF) sys.exit(1) if quiet == 0: print "Running Relax NG testsuite" handle_testSuite(root) if quiet == 0 or nb_schemas_failed != 0: print "\nTOTAL:\nfound %d test schemas: %d success %d failures" % ( nb_schemas_tests, nb_schemas_success, nb_schemas_failed) if quiet == 0 or nb_instances_failed != 0: print "found %d test instances: %d success %d failures" % ( nb_instances_tests, nb_instances_success, nb_instances_failed)
<struct>&simplestruct2.ent;</struct> """ expect="""10 struct 0 0 1 struct 0 0 1 descr 1 1 15 struct 0 0 """ res="" simplestruct2_ent="""<descr/>""" def myResolver(URL, ID, ctxt): if URL == "simplestruct2.ent": return(str_io(simplestruct2_ent)) return None libxml2.setEntityLoader(myResolver) input = libxml2.inputBuffer(str_io(s)) reader = input.newTextReader("test3") reader.SetParserProp(libxml2.PARSER_SUBST_ENTITIES,1) while reader.Read() == 1: res = res + "%s %s %d %d\n" % (reader.NodeType(),reader.Name(), reader.Depth(),reader.IsEmptyElement()) if res != expect: print("test3 failed: unexpected output") print(res) sys.exit(1) # # cleanup
# # Parse the conf file # libxml2.substituteEntitiesDefault(1); testsuite = libxml2.parseFile(CONF) # # Error and warnng callbacks # def callback(ctx, str): global log log.write("%s%s" % (ctx, str)) libxml2.registerErrorHandler(callback, "") libxml2.setEntityLoader(resolver) root = testsuite.getRootElement() if root.name != 'testSuite': print "%s doesn't start with a testSuite element, aborting" % (CONF) sys.exit(1) if quiet == 0: print "Running Relax NG testsuite" handle_testSuite(root) if quiet == 0 or nb_schemas_failed != 0: print "\nTOTAL:\nfound %d test schemas: %d success %d failures" % ( nb_schemas_tests, nb_schemas_success, nb_schemas_failed) if quiet == 0 or nb_instances_failed != 0: print "found %d test instances: %d success %d failures" % ( nb_instances_tests, nb_instances_success, nb_instances_failed)
try: import StringIO str_io = StringIO.StringIO except: import io str_io = io.StringIO # Memory debug specific libxml2.debugMemory(1) def myResolver(URL, ID, ctxt): return (str_io("<foo/>")) libxml2.setEntityLoader(myResolver) doc = libxml2.parseFile("doesnotexist.xml") root = doc.children if root.name != "foo": print("root element name error") sys.exit(1) doc.freeDoc() i = 0 while i < 5000: doc = libxml2.parseFile("doesnotexist.xml") root = doc.children if root.name != "foo": print("root element name error") sys.exit(1)
def initialize(): get_default_cache() libxml2.setEntityLoader(libxml2_entity_loader)
# logging init logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) log = logging.getLogger(__name__) # libxml2 init def _libxml2_error_handler(ctxt, err): log.error('libxml2: %s %s', ctxt, err) def _libxml2_entity_loader(url, id, ctxt): return None libxml2.registerErrorHandler(_libxml2_error_handler, None) libxml2.setEntityLoader(_libxml2_entity_loader) # custom exceptions class MyXmlParserBaseExc(Exception): """Base parser exception""" pass class MyXmlParserXSDInitExc(MyXmlParserBaseExc): """XSD initialization exception""" pass class MyXmlParserXmlParseExc(MyXmlParserBaseExc): """XML file parse exception"""
def toString( xslPath, xslParams=None, xslBasePath=None, rootTagName='pyxslt', encoding='ASCII', prettyPrintXml=False, **elements): """ Serialize a dictionary of Python objects to an XML document, transform that document using an XSL template, then return the textual version of the document. @param xslPath: The path to the XSL file that should be used to transform the serialized Python objects. @type xslPath: C{str} containing the path to an XSL stylesheet. @param xslParams: Parameters to pass to the XSL stylesheet. @type xslParams: C{dict} @param xslBasePath: The path to prepend to absolute stylesheet references. @type xslBasePath: C{str} @param rootTagName: The name of the XML tag that will enclose the serialized Python objects. @type rootTagName: C{str} @param encoding: The character encoding to use when outputting the final XML document. Values such as C{UTF-8}, C{ISO-8859-1}, C{ASCII}, etc. are appropriate. @type encoding: C{str} @param prettyPrintXml: C{True} to indent the final XML output, C{False} to return the bare XML without any extraneous spaces or linefeeds. @type prettyPrintXml: C{bool} @return: The given Python objects as a transformed XML document. @rtype: C{str} """ # Initialize the entity loader if we were given a base path. if xslBasePath: entityLoader = EntityLoader(xslBasePath, os.getcwd()) libxml2.setEntityLoader(entityLoader) # Load the stylesheet. try: # Parse the stylesheet. xslDoc = libxml2.parseFile(xslPath) stylesheet = libxslt.parseStylesheetDoc(xslDoc) except: # Free the XSL document. try: xslDoc.freeDoc() except: pass # Re-raise the exception. raise # Render the arguments with the stylesheet. try: # Create the Serializer. ser = serialize.Serializer(rootTagName=rootTagName) # Serialize the elements. ser.serialize(**elements) # Apply the stylesheet to the serialized arguments. out = stylesheet.applyStylesheet(ser.xmlDoc, xslParams) # Return the rendered content. return out.serialize(encoding=encoding, format=prettyPrintXml) finally: try: out.freeDoc() except: pass try: stylesheet.freeStylesheet() except: pass try: doc.freeDoc() except: pass
# Turn the reStructuredText document tree into a reStructuredText # XML document. restXml = restxmldoc.RestXmlDocument(restDoc, smartPunctuation) # Use the document's stylesheet if the caller did not give us an # override stylesheet. if not xslPath: xslPath = restXml.xslTemplate # Initialize the entity loader if we were given a base path. if xslBasePath: entityLoader = loader.EntityLoader( xslBasePath, os.path.dirname(restPath)) libxml2.setEntityLoader(entityLoader) # Load the XSL file. stylesheet = xslt.Stylesheet(xslPath) # Is this a multiple-instance document (multidoc)? If so, we need # to process the file multiple times, one for each document # instance. If not, just process the current document. resultDocuments = [] if restDoc.settings.restxsl_multidoc: # Generate a document for each of the multidoc's children. for mdChildIndex, mdChild in enumerate( restXml.doc.xpathEval('//pyxslt[@multidoc="true"]/*')): # Get the name of the document using the multidoc XPATH # expression.