def processFile(self, fname):
"""
Process a single xuff file
"""
xml = parse_xml(fname)
for e in xml:
if self.isXuffElement(e):
handler = None
try:
handler = getattr(self, 'handle_' + self.local_name(e))
except AttributeError:
self.error("Didn't understand %s instruction" % (e.tag))
if handler:
global _verbose
doVerbose = self.getAttr(e, 'verbose', 'unchanged')
oldVerbose = _verbose
if doVerbose != 'unchanged':
_verbose = doVerbose.lower() in [
'1', 'true', 't', 'on', 'yes', 'y'
]
timer = Timer()
handler(e)
if self.timing:
timer.show("<%10s>" % e.tag)
_verbose = oldVerbose
def startElement(self, name, attrs):
vars = self.stack[-1].copy()
self.stack.append(vars)
handler = self.handlers[name]
locator = self.locator
if locator is not None:
source = (locator.getSystemId(), locator.getLineNumber())
else:
source = ("unknown", 0)
handler(source, vars, attrs)
def startElement(self, name, attrs):
vars = self.stack[-1].copy()
self.stack.append(vars)
handler = self.handlers[name]
locator = self.locator
if locator is not None:
source = (locator.getSystemId(), locator.getLineNumber())
else:
source = ("unknown", 0)
handler(source, vars, attrs)
def endElementNS(self, name, qname):
last = self.stack.pop()
handler = self.end_handlers.get(name)
if handler:
try:
handler(self, last)
except:
raise HandlerError(sys.exc_info()[1], name[1], self.locator
), None, sys.exc_info()[2]
self.textstack.pop()
def endElementNS(self, name, qname):
last = self.stack.pop()
handler = self.end_handlers.get(name)
if handler:
try:
handler(self, last)
except:
raise HandlerError(sys.exc_info()[1], name[1],
self.locator), None, sys.exc_info()[2]
self.textstack.pop()
def endElement(self, name):
"""
Handle closing elements
:param name: Name of the element
:type name: String
"""
if name in self.ignore_end:
return
try:
handler = getattr(self, '_handle_end_%s' % name)
except AttributeError:
raise KeyError("Unknown element start '%s'" % name)
handler()
def endElement(self, name):
"""
Handle closing elements
:param name: Name of the element
:type name: String
"""
if name in self.ignore_end:
return
try:
handler = getattr(self, '_handle_end_%s' % name)
except AttributeError:
raise KeyError("Unknown element start '%s'" % name)
handler()
def startElement(self, name, attrs):
"""
Handle opening elements.
:param name: Name of the element
:type name: String
:param attrs: Attributes of the element
:type attrs: Dict
"""
if name in self.ignore_start:
return
try:
handler = getattr(self, '_handle_start_%s' % name)
except AttributeError:
raise KeyError("Unknown element start '%s'" % name)
handler(attrs)
def startElement(self, name, attrs):
"""
Handle opening elements.
:param name: Name of the element
:type name: String
:param attrs: Attributes of the element
:type attrs: Dict
"""
if name in self.ignore_start:
return
try:
handler = getattr(self, '_handle_start_%s' % name)
except AttributeError:
raise KeyError("Unknown element start '%s'" % name)
handler(attrs)
def walk(cls, n, handler=None, deepfirst=True):
if handler is None: handler = lambda x:x
node = n
if deepfirst:
stack = [node]
while stack:
node = stack.pop(0)
stack = list(node) + stack
yield handler(node)
else:
nodes = [node]
while nodes:
tohandle, nodes = nodes, []
for node in tohandle:
nodes.extend(node)
yield handler(node)
def readContent(self, handler, result=None):
buffer = ""
while True:
type = self.token[0]
if type == IgnorableWhitespace:
buffer += self.token[1]
elif type == Characters:
buffer += self.token[1]
elif type == EndElement:
break
yield
if isinstance(handler, types.ListType):
handler[0] = buffer
else:
handler(buffer)
if result:
yield Return(result)
def processFile(self, fname):
"""
Process a single xuff file
"""
xml = parse_xml(fname)
for e in xml:
if self.isXuffElement(e):
handler = None
try:
handler = getattr(self, 'handle_' + self.local_name(e))
except AttributeError:
self.error("Didn't understand %s instruction" % (e.tag))
if handler:
global _verbose
doVerbose = self.getAttr(e, 'verbose', 'unchanged')
oldVerbose = _verbose
if doVerbose != 'unchanged':
_verbose = doVerbose.lower() in ['1', 'true', 't', 'on', 'yes', 'y']
timer = Timer()
handler(e)
if self.timing:
timer.show("<%10s>" % e.tag)
_verbose = oldVerbose
def startElementNS(self, name, qname, attrs):
handler = self.start_handlers.get(name)
if handler:
try:
result = handler(self, attrs)
except:
raise HandlerError(sys.exc_info()[1], name[1], self.locator
), None, sys.exc_info()[2]
else:
result = None
if result is None:
# Just dup the top of the stack
result = self.stack[-1]
self.stack.append(result)
self.textstack.append(u'')
def startElementNS(self, name, qname, attrs):
handler = self.start_handlers.get(name)
if handler:
try:
result = handler(self, attrs)
except:
raise HandlerError(sys.exc_info()[1], name[1],
self.locator), None, sys.exc_info()[2]
else:
result = None
if result is None:
# Just dup the top of the stack
result = self.stack[-1]
self.stack.append(result)
self.textstack.append(u'')
def parse(parser, exporter, entity_type, handler, options):
input_file = None
match_string = '_%s.xml' % entity_type
in_file = first_file_match(match_string, options)
if options.date is not None:
input_file = "discogs_%s_%s.xml.gz" % (options.date, entity_type)
if not path.exists(input_file):
input_file = "discogs_%s_%s.xml" % (options.date, entity_type)
elif in_file is not None:
input_file = in_file
if input_file is None:
return
elif not path.exists(input_file):
return
parser.setContentHandler(handler(exporter, options))
try:
if input_file.endswith('.gz'):
parser.parse(gzip.open(input_file, 'rb'))
else:
parser.parse(input_file)
except ParserStopError as pse:
print "Parsed %d %s then stopped as requested." % (pse.records_parsed,
entity_type)
def fire(self, *args, **keywargs):
for handler in self.__handlers:
handler(*args, **keywargs)
