Python ParserCreate.CharacterDataHandler方法代码示例

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
    def photo_query(self, query):
        data = '<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><RetrieveImages xmlns="NWMLS:EverNet"><query>{0}</query></RetrieveImages></soap:Body></soap:Envelope>'.format(
            escape(query)
        )
        import socket

        socket.setdefaulttimeout(30)
        conn = httplib.HTTPConnection("images.idx.nwmls.com", timeout=30)
        conn.putrequest("POST", "/imageservice/imagequery.asmx")
        conn.putheader("Content-Type", "text/xml; charset=utf-8")
        conn.putheader("Soapaction", "NWMLS:EverNet/RetrieveImages")
        conn.putheader("Content-Length", "%d" % len(data))
        conn.endheaders()
        conn.send(data)
        logger.debug(">>> %s" % data)

        with tempfile.TemporaryFile() as response_file:
            response = conn.getresponse()
            tmp = response.read(1000)
            while tmp:
                response_file.write(tmp)
                tmp = response.read(1000)
                logger.debug("<<< %s" % tmp)
            response_file.seek(0)

            self.data = tempfile.TemporaryFile()
            self.in_envelope = False
            p = ParserCreate()
            p.StartElementHandler = self._start_element_get_envelope
            p.EndElementHandler = self._end_element_get_envelope
            p.CharacterDataHandler = self._char_data_get_envelope
            p.ParseFile(response_file)
        self.data.seek(0)
        return self.data

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
    def __init__(self):
        self.recent_files = []
        self.tlist = []
        self.item = None

        fname = os.path.expanduser(GRAMPS_FILENAME)
        if not os.path.exists(fname):
            return # it's the first time gramps has ever been run

        try:
            with open(fname, "rb") as xml_file:
                if USE_LOCK:
                    fcntl.lockf(xml_file, fcntl.LOCK_SH)

                parser = ParserCreate()
                parser.StartElementHandler = self.start_element
                parser.EndElementHandler = self.end_element
                parser.CharacterDataHandler = self.characters
                parser.ParseFile(xml_file)
            # all advisory locks on a file are released on close
        except IOError as err:
            logging.warning(
                _("Unable to open list of recent DBs file {fname}: {error}"
                 ).format(fname=fname, error=err))
        except ExpatError as err:
            logging.error(
                _("Error parsing list of recent DBs from file {fname}: "
                  "{error}.\nThis might indicate a damage to your files.\n"
                  "If you're sure there is no problem with other files, "
                  "delete it, and restart Gramps."
                 ).format(fname=fname, error=err))

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
    def __init__(self, filename):
        self.mesh = Mesh()
        self.mesh.metaData['filename'] = filename
        self.volume = self.mesh.newVolume()

        r = ParserCreate()
        r.StartElementHandler = self._StartElementHandler
        r.EndElementHandler = self._EndElementHandler
        r.CharacterDataHandler = self._CharacterDataHandler

        self._base = {}
        self._cur = self._base
        self._idMap = {}
        self._geometryList = []
        self._faceCount = 0
        r.ParseFile(open(filename, "r"))
        
        self.vertexCount = 0
        for instance_visual_scene in self._base['collada'][0]['scene'][0]['instance_visual_scene']:
            for node in self._idMap[instance_visual_scene['_url']]['node']:
                self._ProcessNode1(node)
        self.volume._prepareFaceCount(self._faceCount)
        for instance_visual_scene in self._base['collada'][0]['scene'][0]['instance_visual_scene']:
            for node in self._idMap[instance_visual_scene['_url']]['node']:
                self._ProcessNode2(node)

        scale = float(self._base['collada'][0]['asset'][0]['unit'][0]['_meter']) * 1000
        self.volume.vertexData *= scale
        
        self._base = None
        self._cur = None
        self._idMap = None
        
        self.volume.calculateNormals()

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
	def __init__(self, filename):
		self.obj = mesh.printableObject(os.path.basename(filename))
		self.mesh = self.obj._addMesh()

		r = ParserCreate()
		r.StartElementHandler = self._StartElementHandler
		r.EndElementHandler = self._EndElementHandler
		r.CharacterDataHandler = self._CharacterDataHandler

		self._base = {}
		self._cur = self._base
		self._idMap = {}
		self._geometryList = []
		self._faceCount = 0
		r.ParseFile(open(filename, "r"))
		
		self.vertexCount = 0
		for instance_visual_scene in self._base['collada'][0]['scene'][0]['instance_visual_scene']:
			for node in self._idMap[instance_visual_scene['_url']]['node']:
				self._ProcessNode1(node)
		self.mesh._prepareFaceCount(self._faceCount)
		for instance_visual_scene in self._base['collada'][0]['scene'][0]['instance_visual_scene']:
			for node in self._idMap[instance_visual_scene['_url']]['node']:
				self._ProcessNode2(node)

		scale = float(self._base['collada'][0]['asset'][0]['unit'][0]['_meter']) * 1000
		self.mesh.vertexes *= scale
		
		self._base = None
		self._cur = None
		self._idMap = None
		
		self.obj._postProcessAfterLoad()

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
 def get_parser(self):
     p = ParserCreate()
     p.buffer_text = True
     p.StartElementHandler = self.start_element
     p.EndElementHandler = self.end_element
     p.CharacterDataHandler = self.char_data
     return p

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
    def __init__(self):
        self.recent_files = []

        fname = os.path.expanduser(WEARNOW_FILENAME)
        if not os.path.exists(fname):
            return # it's the first time wearnow has ever been run

        try:
            with open(fname, "rb") as xml_file:
                if use_lock:
                    fcntl.lockf(xml_file,fcntl.LOCK_SH)

                p = ParserCreate()
                p.StartElementHandler = self.startElement
                p.EndElementHandler = self.endElement
                p.CharacterDataHandler = self.characters
                p.ParseFile(xml_file)
            # all advisory locks on a file are released on close
        except IOError as err:
            logging.warning(
                    _("Unable to open list of recent DBs file {fname}: {error}"
                        ).format(fname=fname, error=err))
        except Exception as err:
            logging.error(
                    _("Error parsing list of recent collections from file {fname}: {error}.\n"
                        "This might indicate a damage to your files.\n"
                        "If you're sure there is no problem with other files, "
                        "delete it, and restart ComfiSense."
                        ).format(fname=fname, error=err))

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
	def load(self, filename):
		r = ParserCreate()
		r.StartElementHandler = self._StartElementHandler
		r.EndElementHandler = self._EndElementHandler
		r.CharacterDataHandler = self._CharacterDataHandler

		self._base = {}
		self._cur = self._base
		self._idMap = {}
		self._geometryList = []
		r.ParseFile(open(filename, "r"))
		
		self.vertexCount = 0
		for instance_visual_scene in self._base['collada'][0]['scene'][0]['instance_visual_scene']:
			for node in self._idMap[instance_visual_scene['_url']]['node']:
				self._ProcessNode1(node)
		self._prepareVertexCount(self.vertexCount)
		for instance_visual_scene in self._base['collada'][0]['scene'][0]['instance_visual_scene']:
			for node in self._idMap[instance_visual_scene['_url']]['node']:
				self._ProcessNode2(node)

		scale = float(self._base['collada'][0]['asset'][0]['unit'][0]['_meter']) * 1000
		self.origonalVertexes *= scale
		
		self._base = None
		self._cur = None
		self._idMap = None
		
		self._postProcessAfterLoad()
		return self

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
def processReport(xmlFile):
  global reportData, tagStack

  guid = os.path.splitext(os.path.basename(xmlFile))[0]

  cursor = get_db().cursor()
  executeQuery(cursor,
              '''SELECT guid FROM #PFX#reports WHERE guid = %s''',
              (guid))
  report = cursor.fetchone()

  if report != None:
    os.remove(xmlFile)
    return

  source = open(xmlFile, 'rb')
  reportData = {'status': '', 'usefulness': 0, 'warnings': {}, 'requests': [], 'filters': [], 'subscriptions': [], 'extensions': [], 'errors': [], 'time': time()}
  tagStack = []

  parser = ParserCreate()
  parser.StartElementHandler = processElementStart
  parser.EndElementHandler = processElementEnd
  parser.CharacterDataHandler = processText
  try:
    parser.ParseFile(source)
  except ExpatError, error:
    reportData['warnings']['!parsing'] = 'Parsing error in the report: %s at line %i column %i' % (ErrorString(error.code), error.lineno, error.offset)

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
    def listing_query(self, query):
        data = '<?xml version="1.0" encoding="UTF-8"?><SOAP-ENV:Envelope xmlns:ns0="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="http://www.nwmls.com/EverNetServices" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"><SOAP-ENV:Header/><ns0:Body><ns1:{0}><ns1:v_strXmlQuery>{1}</ns1:v_strXmlQuery></ns1:{0}></ns0:Body></SOAP-ENV:Envelope>'.format(self.endpoint, escape(str(query)))

        response = session.post('http://evernet.nwmls.com/evernetqueryservice/evernetquery.asmx', headers = {
            'Soapaction': "http://www.nwmls.com/EverNetServices/{0}".format(self.endpoint),
            'Content-Type': 'text/xml; charset=utf-8',
        }, timeout=60*5, data=data, stream=True)

        logger.info('Sent request...')
        logger.debug('>>> %s' % data)

        with tempfile.TemporaryFile() as response_file:
            tmp = response.raw.read(1000)
            logger.info('Receiving data...')
            while tmp:
                response_file.write(tmp)
                tmp = response.raw.read(1000)
                logger.debug('<<< %s' % tmp)
            response_file.seek(0)

            self.data = tempfile.TemporaryFile()
            self.in_envelope = False
            p = ParserCreate()
            p.StartElementHandler = self._start_element_get_envelope
            p.EndElementHandler = self._end_element_get_envelope
            p.CharacterDataHandler = self._char_data_get_envelope
            response_file.seek(0)
            try:
                p.ParseFile(response_file)
            except ExpatError:
                logging.error("Error parsing XML response from Evernet.  This usually happens when the server returns an error message.  You can see the full response if you set the logging to DEBUG level")
                raise
        logger.info('All data received, starting parsing')
        self.data.seek(0)
        return self.data

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
 def parse(self, fileobj):
     from xml.parsers.expat import ParserCreate
     parser = ParserCreate()
     parser.StartElementHandler = self.handleBeginElement
     parser.EndElementHandler = self.handleEndElement
     parser.CharacterDataHandler = self.handleData
     parser.ParseFile(fileobj)
     return self.root

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
def weather_parser(xml): 
    handler = WeatherSaxHandler()
    parser = ParserCreate()
    parser.StartElementHandler = handler.start_element
    parser.EndElementHandler = handler.end_element
    parser.CharacterDataHandler = handler.char_data
    parser.Parse(xml)
    print(handler.weather)

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
def parse_weather(xml):
    handler = WeatherSaxHandler()
    parser = ParserCreate()
    parser.StartElementHandler = handler.start_element
    parser.EndElementHandler = handler.end_element
    parser.CharacterDataHandler = handler.char_data
    parser.Parse(xml)
    return weather_dict

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
def parse_weather(data):
    parser = ParserCreate()
    handler = WeatherSaxHandler()
    parser.StartElementHandler = handler.start_e
    parser.EndElementHandler = handler.end_e
    parser.CharacterDataHandler = handler.c_data
    handler.init()
    parser.Parse(data)
    return handler.weather

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
def xml_test():
    #操作XML有两种方法：DOM和SAX。
    #DOM会把整个XML读入内存，解析为树，因此占用内存大，解析慢，优点是可以任意遍历树的节点。
    #SAX是流模式，边读边解析，占用内存小，解析快，缺点是我们需要自己处理事件。
    
    #在Python中使用SAX解析XML非常简洁，通常我们关心的事件是start_element，end_element和char_data
    class DefaultSaxHandler(object):
        def __init__(self):
            self.weather = {}
            
        def start_element(self,name,attrs):
            if name=='yweather:location':
                self.weather['country'] = attrs['country']
                self.weather['city'] = attrs['city']
            if name=='yweather:astronomy':
                self.weather['sunrise'] = attrs['sunrise']
                self.weather['sunset'] = attrs['sunset']
                print(self.weather)
            #print('SAX: start_element:%s, attrs:%s' % (name,str(attrs)))
            
        def end_element(self,name):
            pass#print('SAX:end_element:%s' % name)
            
        def char_data(self,text):
            if not text:
                print('SAX:char_data:%s' % text)
            
    data = r'''<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
    <rss version="2.0" xmlns:yweather="http://xml.weather.yahoo.com/ns/rss/1.0" xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#">
    <channel>
        <title>Yahoo! Weather - Beijing, CN</title>
        <lastBuildDate>Wed, 27 May 2015 11:00 am CST</lastBuildDate>
        <yweather:location city="Beijing" region="" country="China"/>
        <yweather:units temperature="C" distance="km" pressure="mb" speed="km/h"/>
        <yweather:wind chill="28" direction="180" speed="14.48" />
        <yweather:atmosphere humidity="53" visibility="2.61" pressure="1006.1" rising="0" />
        <yweather:astronomy sunrise="4:51 am" sunset="7:32 pm"/>
        <item>
            <geo:lat>39.91</geo:lat>
            <geo:long>116.39</geo:long>
            <pubDate>Wed, 27 May 2015 11:00 am CST</pubDate>
            <yweather:condition text="Haze" code="21" temp="28" date="Wed, 27 May 2015 11:00 am CST" />
            <yweather:forecast day="Wed" date="27 May 2015" low="20" high="33" text="Partly Cloudy" code="30" />
            <yweather:forecast day="Thu" date="28 May 2015" low="21" high="34" text="Sunny" code="32" />
            <yweather:forecast day="Fri" date="29 May 2015" low="18" high="25" text="AM Showers" code="39" />
            <yweather:forecast day="Sat" date="30 May 2015" low="18" high="32" text="Sunny" code="32" />
            <yweather:forecast day="Sun" date="31 May 2015" low="20" high="37" text="Sunny" code="32" />
        </item>
    </channel>
    </rss>
    '''
    handler = DefaultSaxHandler()
    parser = ParserCreate()
    parser.StartElementHandler = handler.start_element
    parser.EndElementHandler = handler.end_element
    parser.CharacterDataHandler = handler.char_data
    parser.Parse(data)

# 需要导入模块: from xml.parsers.expat import ParserCreate [as 别名]
# 或者: from xml.parsers.expat.ParserCreate import CharacterDataHandler [as 别名]
    def parse ( self, xmldata ):
        from xml.parsers.expat import ParserCreate

        p = ParserCreate ( 'utf-8' )
        p.StartElementHandler = self.start_element
        p.EndElementHandler = self.end_element
        p.CharacterDataHandler = self.char_data
        p.Parse ( xmldata )
        return '\n'.join ( self.output )