def parse(self, source, **keyword_args): if type(source) == types.StringType: if re.match(r'(?m)^\s*<', source) != None: file = StringIO(source) else: file = urllib.urlopen(source) else: file = source if hasattr(self, 'handler'): self.tmp_handler = self.handler if keyword_args.has_key('handler'): self.tmp_handler = keyword_args['handler'] if isPy2: self.parser = xml.sax.make_parser() self.parser.setFeature(feature_namespaces, 0) self.parser.setContentHandler(self) else: self.parser = saxexts.make_parser() self.parser.setDocumentHandler(self) self.parser.setErrorHandler(self) self.namespace_stack = [ { '_Default' : None, 'xmlns' : xmlns_ns } ] self.node_stack = [ ] self.result = None if isPy2: self.parser.parse(file) else: self.parser.parseFile(file) return self.result
def _load(self, file): p = saxexts.make_parser() p.setDocumentHandler(self) p.parseFile(file) assert len(self.stack) == 1 result = self.stack[0] # self._clear() return result
def process(self, uri): parser = saxexts.make_parser() parser.setDocumentHandler(self.handler) try: f = open(uri) parser.parseFile(f) except IOError,e: raise NaturalXMLException("Could not open file: %s" % uri)
def _load(self, file): p = saxexts.make_parser() p.setDocumentHandler(self) p.parseFile(file) assert len(self.stack) == 1 result = self.stack[0] self._clear() return result
def _readXML(self, inFile): "Read in XML tree from file object." p = saxexts.make_parser() dh = SaxBuilder() p.setDocumentHandler(dh) p.parseFile(inFile) p.close() return dh.document
def make_objects(url,element,list_elems={},ign_elems={},rep_field={}): dh=DocHandler(element,list_elems,ign_elems,rep_field) eh=saxutils.ErrorPrinter() parser=saxexts.make_parser() parser.setDocumentHandler(dh) parser.setErrorHandler(eh) parser.parse(url) return dh.get_objects()
def make_objects(url, element, list_elems={}, ign_elems={}, rep_field={}): dh = DocHandler(element, list_elems, ign_elems, rep_field) eh = saxutils.ErrorPrinter() parser = saxexts.make_parser() parser.setDocumentHandler(dh) parser.setErrorHandler(eh) parser.parse(url) return dh.get_objects()
def _load(self, file): "Read one value from the open file" p = saxexts.make_parser() p.setDocumentHandler(self) p.parseFile(file) assert len(self.data_stack) == 1 # leave the instance in a steady state result = self.data_stack[0] self._clear() return result
def sysupdate(): '''Updates denu database of installed programs. Variable:installed.''' handler = installedHandler() parser = saxexts.make_parser() parser.setDocumentHandler(handler) prgmDB = open(config['default'] + "prgmDB.xml", 'r') parser.parseFile(prgmDB) prgmDB.close() d_open(config['default'] + "installed.xml", "installed") buildIdChildRelations(['installed']) return "Successful."
def run(self, text): try: from xml.sax.saxexts import make_parser p = make_parser("xml.sax.drivers.drv_sgmlop") from xml.dom.ext.reader import Sax start = time.time() self.lastResult = Sax.FromXml(text, parser=p) end = time.time() self.lastTiming = end - start return 1 except Exception, e: self.failMsg = str(e) return 0
def test2(filename='.md/Executions.xml'): p = saxexts.make_parser() print "Beginning performance tests" for psize in [10, 100]: t1 = time.time() for i in range(0, psize): rf = ExecutionFile(filename) rf.load() rf.execution.nextRun() rf.save() t2 = time.time() print "files written %d in %d seconds" % (psize, t2-t1)
def __init__(self, filename, fileset=".", **kw): self.xth = XTreeHandler(IgnoreWhiteSpace='yes', RemoveWhiteSpace='yes', CreateElementMap='yes') self.xth.registerElementClass(Execution) self.xth.registerElementClass(Run) try: self.saxp = kw['sax_parser'] except: self.saxp = saxexts.make_parser() self.saxp.setDocumentHandler(self.xth) self.filename = filename self.fileset = fileset self.execution = None self.backup_on_change = kw.get('backups', 1)
def __init__(self, outer_env={}, parser=None): if parser == None: self.parser = saxexts.make_parser() else: self.parser = parser self.xth = XTreeHandler(IgnoreWhiteSpace='yes', RemoveWhiteSpace='yes', CreateElementMap='yes', RequireUserClasses='yes') for x in outer_env.keys(): if type(outer_env[x]) == types.ClassType: self.xth.registerElementClass(outer_env[x]) self.parser.setDocumentHandler(self.xth)
def parse_fh(fh, cb): # Create a parser parser = saxexts.make_parser() # Create the handler ch = ParseXML(cb) # Tell the parser to use our handler parser.setDocumentHandler(ch) # Parse the file parser.parseFile(fh) # Close the parser parser.close()
def go(outer_env): if len(sys.argv) < 2: print "Usage: python saxtree.py <document>" print print " <document>: file name of the document to parse" sys.exit(1) p = saxexts.make_parser() xth = XTreeHandler(IgnoreWhiteSpace='yes', RemoveWhiteSpace='yes', CreateElementMap='yes') for x in outer_env.keys(): if type(outer_env[x]) == types.ClassType: print "registering %s" % x xth.registerElementClass(outer_env[x]) p.setDocumentHandler(xth) Ok=None try: p.parse(sys.argv[1]) print "Parse complete:" print " Elements: %d" % xth.elems print " Attributes: %d" % xth.attrs print " Proc instrs: %d" % xth.pis print " elements: %s" % `xth.getElementMap().keys()` document = xth.getDocument() print " Document has %d children " % len(document.getChildren()) content = document.getChildren('Content') prologue = [] prologue.append('<?xml>') prologue.append('<!-- Outline Tool by George K. Thiruvathukal -->') print content[0].toXML(prologue=prologue, indent_text=" ") topics = content[0].getChildren('Topic') print "%d content objects" % len(content) print "%d topic objects" % len(topics) topics = content[0].getChildren(Topic) print "%d topic objects" % len(topics) analyzeTopics(topics) except IOError,e: print "\nERROR: "+sys.argv[1]+": "+str(e)
def Load(self): try: self.document() self.layer() parser = saxexts.make_parser() parser.setDocumentHandler(SVGHandler(self)) try: self.file.seek(0) file = self.file except: file = streamfilter.StringDecode(self.match.string, self.file) parser.parseFile(file) self.end_all() self.object.load_Completed() return self.object except: warn_tb('INTERNAL') raise
def _unmarshal(self): self.parse_value_stack = [[]] self.parse_type_stack = [] self.parse_keep_text = 0 self.parse_base64 = 0 self.parser = saxexts.make_parser() self.parser.setDocumentHandler(self) self.parser.setErrorHandler(self) lines = [] stream = self.stream line = stream.readline() while (line != "\f\n") and (line != ""): lines.append(line) line = stream.readline() if len(lines) == 0: raise EOFError stream = StringIO(string.join(lines)) self.parser.parseFile(stream) self.parser.close() return self.parse_value_stack[0][0]
def parseAndGenerate(outfileName, subclassFilename, prefix, \ xschemaFileName): #IPShell(vars(), '*** (parseAndGenerate) starting.') #parser = saxexts.make_parser('xml.sax.drivers2.drv_libxmlop') #parser = saxexts.make_parser() parser = saxexts.make_parser("xml.sax.drivers2.drv_pyexpat") #print "Parser: %s (%s, %s)" % \ # (parser.get_parser_name(),parser.get_parser_version(), # parser.get_driver_version()) #print 'dir(parser):', dir(parser) dh = XschemaHandler() #parser.setDocumentHandler(dh) parser.setContentHandler(dh) #IPShell(vars(), '*** (parseAndGenerate) before parse.') parser.parse(xschemaFileName) #IPShell(vars(), '*** (parseAndGenerate) after parse.') root = dh.getRoot() root.annotate() #response = raw_input('Press Enter') #root.show(sys.stdout, 0) #print '=' * 50 #print ']]] root: ', root, '[[[' generate(outfileName, subclassFilename, prefix, root)
def _unmarshal(self): self.parse_value_stack = [ {} ] self.parse_utype_stack = [ DICT ] self.parse_type_stack = [ ] self.parser = saxexts.make_parser() self.parser.setDocumentHandler(self) self.parser.setErrorHandler(self) lines = [] stream = self.stream # FIXME SAX parsers should support this on streams line = stream.readline() while (line != "\f\n") and (line != ""): lines.append(line) line = stream.readline() if len(lines) == 0: raise EOFError stream = StringIO(string.join(lines)) self.parser.parseFile(stream) o = self.parse_value_stack[0] delattr(self, 'parse_value_stack') self.parser.close() return o
def _unmarshal(self): self.parse_value_stack = [{}] self.parse_utype_stack = [DICT] self.parse_type_stack = [] self.parser = saxexts.make_parser() self.parser.setDocumentHandler(self) self.parser.setErrorHandler(self) lines = [] stream = self.stream # FIXME SAX parsers should support this on streams line = stream.readline() while (line != "\f\n") and (line != ""): lines.append(line) line = stream.readline() if len(lines) == 0: raise EOFError stream = StringIO(string.join(lines)) self.parser.parseFile(stream) o = self.parse_value_stack[0] delattr(self, 'parse_value_stack') self.parser.close() return o
in_sysID = trail[0] if len(trail) == 2: out_sysID = trail[1] else: out_sysID = "" for (arg, val) in args: if arg == "-d": driver = "xml.sax.drivers.drv_" + val elif arg == "-e": esis = 1 elif arg == "-s": silent = 1 p = saxexts.make_parser(driver) p.setErrorHandler(saxutils.ErrorPrinter()) if out_sysID == "": out = sys.stdout else: try: out = urllib2.urlopen(out_sysID) except IOError, e: print out_sysID + ": " + str(e) if esis: dh = saxutils.ESISDocHandler(out) else: dh = saxutils.Canonizer(out)
from xml.sax import saxlib import sys, time if len(sys.argv) < 3: print "Usage: python <parser> <document>" print print " <document>: file name of the document to parse" print " <parser>: driver package name" sys.exit(1) # Load parser and driver print "\nLoading parser..." try: p = saxexts.make_parser("xml.sax.drivers.drv_" + sys.argv[1]) except saxlib.SAXException, e: print "ERROR: Parser not available" sys.exit(1) # Ready, set, go! sum = 0 print "Starting parse..." for ix in range(3): start = time.clock() OK = 0 pt = 0 try: p.parse(sys.argv[2])
# $Id: test_pattern.py,v 1.1 1999/04/11 16:09:15 dieter Exp dieter $ """Test for PyXPath.""" from xml.dom.sax_builder import SaxBuilder from xml.sax.saxexts import make_parser from xml.sax.saxutils import ErrorPrinter from dmutil.xsl.xpath import makeParser, Env from dmutil.xsl.DomFactory import IdDecl import dmutil.xsl ############################################################################## # build a DOM tree dh= SaxBuilder() p= make_parser(); p.setDocumentHandler(dh); p.setErrorHandler(ErrorPrinter()) p.parse('%s/test_pattern.xml' % dmutil.xsl.__path__[0]); p.close() domtree= dh.document ############################################################################## # create an idmap provider # this is only necessary when "id" patterns are used idmapper= IdDecl({'product':'id'}) # apply it to "domtree" # this gives "domtree" the infrastructure for "id" pattern handling idmapper(domtree) d= domtree ############################################################################## # create Parser and variable environment p= makeParser(); e=Env(); e.setVariable('x','Hallo') # child::para
def get_parser(dtdmodules, handlerclass=ObjectParserHandler, callback=_default_parser_callback): from xml.sax import saxexts handler = handlerclass(callback, dtdmodules) parser = saxexts.make_parser() parser.setDocumentHandler(handler) return parser
# # If this goes well, a directory would be created containing the persistent # representation of a document # from xml.sax import saxexts from pparser import PElementParser from os import system system('rm -rf xyz') pp = PElementParser('xyz', saxexts.make_parser()) pp.process('test1.xml')
from xml.sax import saxlib import sys,time if len(sys.argv)<3: print "Usage: python <parser> <document>" print print " <document>: file name of the document to parse" print " <parser>: driver package name" sys.exit(1) # Load parser and driver print "\nLoading parser..." try: p=saxexts.make_parser("xml.sax.drivers.drv_" + sys.argv[1]) except saxlib.SAXException,e: print "ERROR: Parser not available" sys.exit(1) # Ready, set, go! sum=0 print "Starting parse..." for ix in range(3): start=time.clock() OK=0 pt=0 try: p.parse(sys.argv[2])
in_sysID=trail[0] if len(trail)==2: out_sysID=trail[1] else: out_sysID="" for (arg,val) in args: if arg=="-d": driver="xml.sax.drivers.drv_" + val elif arg=="-e": esis=1 elif arg=="-s": silent=1 p=saxexts.make_parser(driver) p.setErrorHandler(saxutils.ErrorPrinter()) if out_sysID=="": out=sys.stdout else: try: out=urllib2.urlopen(out_sysID) except IOError,e: print out_sysID+": "+str(e) if esis: dh=saxutils.ESISDocHandler(out) else: dh=saxutils.Canonizer(out)
## else: ## res = saxlib.EntityResolver.resolveEntity(name,publicId,systemId) ## print "--> res",res,type(res) ## return res if len(sys.argv)<2: print "Usage: %s <sheet.sheet>" % sys.argv[0] print print " <sheet.sheet>: file name of the sheet to check" sys.exit(1) # Load parser and driver p=saxexts.make_parser() #p=saxexts.XMLValParserFactory.make_parser() ch=CounterHandler() p.setDocumentHandler(ch) #p.setEntityResolver(BasicEntityResolver()) fnames =sys.argv[1:] def make_langresult(langdict,colsize): langres = map(lambda s,colsize=colsize: string.ljust(s,colsize), map(lambda (cc,count),total=langdict['']: ("%s:%d%%" % (cc,100*count/total)), filter(lambda (cc,count): cc, langdict.items()))) langres.sort() return langres
# $Id: test_pattern.py,v 1.1 1999/04/11 16:09:15 dieter Exp dieter $ """Test for PyXPath.""" from xml.dom.sax_builder import SaxBuilder from xml.sax.saxexts import make_parser from xml.sax.saxutils import ErrorPrinter from dmutil.xsl.xpath import makeParser, Env from dmutil.xsl.DomFactory import IdDecl import dmutil.xsl ############################################################################## # build a DOM tree dh = SaxBuilder() p = make_parser() p.setDocumentHandler(dh) p.setErrorHandler(ErrorPrinter()) p.parse('%s/test_pattern.xml' % dmutil.xsl.__path__[0]) p.close() domtree = dh.document ############################################################################## # create an idmap provider # this is only necessary when "id" patterns are used idmapper = IdDecl({'product': 'id'}) # apply it to "domtree" # this gives "domtree" the infrastructure for "id" pattern handling idmapper(domtree) d = domtree ############################################################################## # create Parser and variable environment