home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / rdflib / syntax / parsers / RDFXMLHandler.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  16.5 KB  |  557 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''
  5. '''
  6. from rdflib import RDF, RDFS
  7. from rdflib import URIRef, BNode, Literal
  8. from rdflib.exceptions import ParserError, Error
  9. from rdflib.syntax.xml_names import is_ncname
  10. from xml.sax.saxutils import handler, quoteattr, escape
  11. from urlparse import urljoin, urldefrag
  12. RDFNS = RDF.RDFNS
  13. UNQUALIFIED = {
  14.     'about': RDF.about,
  15.     'ID': RDF.ID,
  16.     'type': RDF.type,
  17.     'resource': RDF.resource,
  18.     'parseType': RDF.parseType }
  19. CORE_SYNTAX_TERMS = [
  20.     RDF.RDF,
  21.     RDF.ID,
  22.     RDF.about,
  23.     RDF.parseType,
  24.     RDF.resource,
  25.     RDF.nodeID,
  26.     RDF.datatype]
  27. SYNTAX_TERMS = CORE_SYNTAX_TERMS + [
  28.     RDF.Description,
  29.     RDF.li]
  30. OLD_TERMS = [
  31.     RDFNS['aboutEach'],
  32.     RDFNS['aboutEachPrefix'],
  33.     RDFNS['bagID']]
  34. NODE_ELEMENT_EXCEPTIONS = CORE_SYNTAX_TERMS + [
  35.     RDF.li] + OLD_TERMS
  36. NODE_ELEMENT_ATTRIBUTES = [
  37.     RDF.ID,
  38.     RDF.nodeID,
  39.     RDF.about]
  40. PROPERTY_ELEMENT_EXCEPTIONS = CORE_SYNTAX_TERMS + [
  41.     RDF.Description] + OLD_TERMS
  42. PROPERTY_ATTRIBUTE_EXCEPTIONS = CORE_SYNTAX_TERMS + [
  43.     RDF.Description,
  44.     RDF.li] + OLD_TERMS
  45. PROPERTY_ELEMENT_ATTRIBUTES = [
  46.     RDF.ID,
  47.     RDF.resource,
  48.     RDF.nodeID]
  49. XMLNS = 'http://www.w3.org/XML/1998/namespace'
  50. BASE = (XMLNS, 'base')
  51. LANG = (XMLNS, 'lang')
  52.  
  53. class BagID(URIRef):
  54.     __slots__ = [
  55.         'li']
  56.     
  57.     def __init__(self, val):
  58.         super(URIRef, self).__init__(val)
  59.         self.li = 0
  60.  
  61.     
  62.     def next_li(self):
  63.         self.li += 1
  64.         return URIRef(RDFNS + '_%s' % self.li)
  65.  
  66.  
  67.  
  68. class ElementHandler(object):
  69.     __slots__ = [
  70.         'start',
  71.         'char',
  72.         'end',
  73.         'li',
  74.         'id',
  75.         'base',
  76.         'subject',
  77.         'predicate',
  78.         'object',
  79.         'list',
  80.         'language',
  81.         'datatype',
  82.         'declared',
  83.         'data']
  84.     
  85.     def __init__(self):
  86.         self.start = None
  87.         self.char = None
  88.         self.end = None
  89.         self.li = 0
  90.         self.id = None
  91.         self.base = None
  92.         self.subject = None
  93.         self.object = None
  94.         self.list = None
  95.         self.language = None
  96.         self.datatype = None
  97.         self.declared = None
  98.         self.data = None
  99.  
  100.     
  101.     def next_li(self):
  102.         self.li += 1
  103.         return URIRef(RDFNS + '_%s' % self.li)
  104.  
  105.  
  106.  
  107. class RDFXMLHandler(handler.ContentHandler):
  108.     
  109.     def __init__(self, store):
  110.         self.store = store
  111.         self.preserve_bnode_ids = False
  112.         self.reset()
  113.  
  114.     
  115.     def reset(self):
  116.         document_element = ElementHandler()
  117.         document_element.start = self.document_element_start
  118.         
  119.         document_element.end = lambda name, qname: pass
  120.         self.stack = [
  121.             None,
  122.             document_element]
  123.         self.ids = { }
  124.         self.bnode = { }
  125.         self._ns_contexts = [
  126.             { }]
  127.         self._current_context = self._ns_contexts[-1]
  128.  
  129.     
  130.     def setDocumentLocator(self, locator):
  131.         self.locator = locator
  132.  
  133.     
  134.     def startDocument(self):
  135.         pass
  136.  
  137.     
  138.     def startPrefixMapping(self, prefix, namespace):
  139.         self._ns_contexts.append(self._current_context.copy())
  140.         self._current_context[namespace] = prefix
  141.         self.store.bind(prefix, URIRef(namespace), override = False)
  142.  
  143.     
  144.     def endPrefixMapping(self, prefix):
  145.         self._current_context = self._ns_contexts[-1]
  146.         del self._ns_contexts[-1]
  147.  
  148.     
  149.     def startElementNS(self, name, qname, attrs):
  150.         stack = self.stack
  151.         stack.append(ElementHandler())
  152.         current = self.current
  153.         parent = self.parent
  154.         base = attrs.get(BASE, None)
  155.         if base is not None:
  156.             (base, frag) = urldefrag(base)
  157.         elif parent:
  158.             base = parent.base
  159.         
  160.         if base is None:
  161.             if not self.locator.getPublicId():
  162.                 pass
  163.             systemId = self.locator.getSystemId()
  164.             if systemId:
  165.                 (base, frag) = urldefrag(systemId)
  166.             
  167.         
  168.         current.base = base
  169.         language = attrs.get(LANG, None)
  170.         if language is None:
  171.             if parent:
  172.                 language = parent.language
  173.             
  174.         
  175.         current.language = language
  176.         current.start(name, qname, attrs)
  177.  
  178.     
  179.     def endElementNS(self, name, qname):
  180.         self.current.end(name, qname)
  181.         self.stack.pop()
  182.  
  183.     
  184.     def characters(self, content):
  185.         char = self.current.char
  186.         if char:
  187.             char(content)
  188.         
  189.  
  190.     
  191.     def ignorableWhitespace(self, content):
  192.         pass
  193.  
  194.     
  195.     def processingInstruction(self, target, data):
  196.         pass
  197.  
  198.     
  199.     def add_reified(self, sid, .2):
  200.         (s, p, o) = .2
  201.         self.store.add((sid, RDF.type, RDF.Statement))
  202.         self.store.add((sid, RDF.subject, s))
  203.         self.store.add((sid, RDF.predicate, p))
  204.         self.store.add((sid, RDF.object, o))
  205.  
  206.     
  207.     def error(self, message):
  208.         locator = self.locator
  209.         info = '%s:%s:%s: ' % (locator.getSystemId(), locator.getLineNumber(), locator.getColumnNumber())
  210.         raise ParserError(info + message)
  211.  
  212.     
  213.     def get_current(self):
  214.         return self.stack[-2]
  215.  
  216.     current = property(get_current)
  217.     
  218.     def get_next(self):
  219.         return self.stack[-1]
  220.  
  221.     next = property(get_next)
  222.     
  223.     def get_parent(self):
  224.         return self.stack[-3]
  225.  
  226.     parent = property(get_parent)
  227.     
  228.     def absolutize(self, uri):
  229.         result = urljoin(self.current.base, uri, allow_fragments = 1)
  230.         if uri and uri[-1] == '#' and result[-1] != '#':
  231.             result = '%s#' % result
  232.         
  233.         return URIRef(result)
  234.  
  235.     
  236.     def convert(self, name, qname, attrs):
  237.         if name[0] is None:
  238.             name = URIRef(name[1])
  239.         else:
  240.             name = URIRef(''.join(name))
  241.         atts = { }
  242.         for n, v in attrs.items():
  243.             if n[0] is None:
  244.                 att = URIRef(n[1])
  245.             else:
  246.                 att = URIRef(''.join(n))
  247.             if att.startswith(XMLNS) or att[0:3].lower() == 'xml':
  248.                 continue
  249.             if att in UNQUALIFIED:
  250.                 atts[RDFNS[att]] = v
  251.                 continue
  252.             atts[URIRef(att)] = v
  253.         
  254.         return (name, atts)
  255.  
  256.     
  257.     def document_element_start(self, name, qname, attrs):
  258.         if name[0] and URIRef(''.join(name)) == RDF.RDF:
  259.             next = self.next
  260.             next.start = self.node_element_start
  261.             next.end = self.node_element_end
  262.         else:
  263.             self.node_element_start(name, qname, attrs)
  264.  
  265.     
  266.     def node_element_start(self, name, qname, attrs):
  267.         (name, atts) = self.convert(name, qname, attrs)
  268.         current = self.current
  269.         absolutize = self.absolutize
  270.         next = self.next
  271.         next.start = self.property_element_start
  272.         next.end = self.property_element_end
  273.         if name in NODE_ELEMENT_EXCEPTIONS:
  274.             self.error('Invalid node element URI: %s' % name)
  275.         
  276.         if RDF.ID in atts:
  277.             if RDF.about in atts or RDF.nodeID in atts:
  278.                 self.error('Can have at most one of rdf:ID, rdf:about, and rdf:nodeID')
  279.             
  280.             id = atts[RDF.ID]
  281.             if not is_ncname(id):
  282.                 self.error('rdf:ID value is not a valid NCName: %s' % id)
  283.             
  284.             subject = absolutize('#%s' % id)
  285.             if subject in self.ids:
  286.                 self.error("two elements cannot use the same ID: '%s'" % subject)
  287.             
  288.             self.ids[subject] = 1
  289.         elif RDF.nodeID in atts:
  290.             if RDF.ID in atts or RDF.about in atts:
  291.                 self.error('Can have at most one of rdf:ID, rdf:about, and rdf:nodeID')
  292.             
  293.             nodeID = atts[RDF.nodeID]
  294.             if not is_ncname(nodeID):
  295.                 self.error('rdf:nodeID value is not a valid NCName: %s' % nodeID)
  296.             
  297.             if self.preserve_bnode_ids is False:
  298.                 if nodeID in self.bnode:
  299.                     subject = self.bnode[nodeID]
  300.                 else:
  301.                     subject = BNode()
  302.                     self.bnode[nodeID] = subject
  303.             else:
  304.                 subject = BNode(nodeID)
  305.         elif RDF.about in atts:
  306.             if RDF.ID in atts or RDF.nodeID in atts:
  307.                 self.error('Can have at most one of rdf:ID, rdf:about, and rdf:nodeID')
  308.             
  309.             subject = absolutize(atts[RDF.about])
  310.         else:
  311.             subject = BNode()
  312.         if name != RDF.Description:
  313.             self.store.add((subject, RDF.type, absolutize(name)))
  314.         
  315.         language = current.language
  316.         for att in atts:
  317.             if not att.startswith(RDFNS):
  318.                 predicate = absolutize(att)
  319.                 
  320.                 try:
  321.                     object = Literal(atts[att], language)
  322.                 except Error:
  323.                     e = None
  324.                     self.error(e.msg)
  325.                 except:
  326.                     None<EXCEPTION MATCH>Error
  327.                 
  328.  
  329.             None<EXCEPTION MATCH>Error
  330.             if att == RDF.type:
  331.                 predicate = RDF.type
  332.                 object = absolutize(atts[RDF.type])
  333.             elif att in NODE_ELEMENT_ATTRIBUTES:
  334.                 continue
  335.             elif att in PROPERTY_ATTRIBUTE_EXCEPTIONS:
  336.                 self.error('Invalid property attribute URI: %s' % att)
  337.                 continue
  338.             else:
  339.                 predicate = absolutize(att)
  340.                 
  341.                 try:
  342.                     object = Literal(atts[att], language)
  343.                 except Error:
  344.                     e = None
  345.                     self.error(e.msg)
  346.  
  347.             self.store.add((subject, predicate, object))
  348.         
  349.         current.subject = subject
  350.  
  351.     
  352.     def node_element_end(self, name, qname):
  353.         self.parent.object = self.current.subject
  354.  
  355.     
  356.     def property_element_start(self, name, qname, attrs):
  357.         (name, atts) = self.convert(name, qname, attrs)
  358.         current = self.current
  359.         absolutize = self.absolutize
  360.         next = self.next
  361.         object = None
  362.         current.data = None
  363.         current.list = None
  364.         if not name.startswith(RDFNS):
  365.             current.predicate = absolutize(name)
  366.         elif name == RDF.li:
  367.             current.predicate = current.next_li()
  368.         elif name in PROPERTY_ELEMENT_EXCEPTIONS:
  369.             self.error('Invalid property element URI: %s' % name)
  370.         else:
  371.             current.predicate = absolutize(name)
  372.         id = atts.get(RDF.ID, None)
  373.         if id is not None:
  374.             if not is_ncname(id):
  375.                 self.error('rdf:ID value is not a value NCName: %s' % id)
  376.             
  377.             current.id = absolutize('#%s' % id)
  378.         else:
  379.             current.id = None
  380.         resource = atts.get(RDF.resource, None)
  381.         nodeID = atts.get(RDF.nodeID, None)
  382.         parse_type = atts.get(RDF.parseType, None)
  383.         if resource is not None and nodeID is not None:
  384.             self.error('Property element cannot have both rdf:nodeID and rdf:resource')
  385.         
  386.         if resource is not None:
  387.             object = absolutize(resource)
  388.             next.start = self.node_element_start
  389.             next.end = self.node_element_end
  390.         elif nodeID is not None:
  391.             if not is_ncname(nodeID):
  392.                 self.error('rdf:nodeID value is not a valid NCName: %s' % nodeID)
  393.             
  394.             if self.preserve_bnode_ids is False:
  395.                 if nodeID in self.bnode:
  396.                     object = self.bnode[nodeID]
  397.                 else:
  398.                     subject = BNode()
  399.                     self.bnode[nodeID] = subject
  400.                     object = subject
  401.             else:
  402.                 object = subject = BNode(nodeID)
  403.             next.start = self.node_element_start
  404.             next.end = self.node_element_end
  405.         elif parse_type is not None:
  406.             for att in atts:
  407.                 if att != RDF.parseType and att != RDF.ID:
  408.                     self.error("Property attr '%s' now allowed here" % att)
  409.                     continue
  410.             
  411.             if parse_type == 'Resource':
  412.                 current.subject = object = BNode()
  413.                 current.char = self.property_element_char
  414.                 next.start = self.property_element_start
  415.                 next.end = self.property_element_end
  416.             elif parse_type == 'Collection':
  417.                 current.char = None
  418.                 object = current.list = RDF.nil
  419.                 next.start = self.node_element_start
  420.                 next.end = self.list_node_element_end
  421.             else:
  422.                 object = Literal('', None, RDF.XMLLiteral)
  423.                 current.char = self.literal_element_char
  424.                 current.declared = { }
  425.                 next.start = self.literal_element_start
  426.                 next.char = self.literal_element_char
  427.                 next.end = self.literal_element_end
  428.             current.object = object
  429.             return None
  430.         object = None
  431.         current.char = self.property_element_char
  432.         next.start = self.node_element_start
  433.         next.end = self.node_element_end
  434.         datatype = current.datatype = atts.get(RDF.datatype, None)
  435.         language = current.language
  436.         if datatype is not None:
  437.             datatype = absolutize(datatype)
  438.         else:
  439.             for att in atts:
  440.                 if not att.startswith(RDFNS):
  441.                     predicate = absolutize(att)
  442.                 elif att in PROPERTY_ELEMENT_ATTRIBUTES:
  443.                     continue
  444.                 elif att in PROPERTY_ATTRIBUTE_EXCEPTIONS:
  445.                     self.error('Invalid property attribute URI: %s' % att)
  446.                 else:
  447.                     predicate = absolutize(att)
  448.                 if att == RDF.type:
  449.                     o = URIRef(atts[att])
  450.                 else:
  451.                     o = Literal(atts[att], language, datatype)
  452.                 if object is None:
  453.                     object = BNode()
  454.                 
  455.                 self.store.add((object, predicate, o))
  456.             
  457.         if object is None:
  458.             current.data = ''
  459.             current.object = None
  460.         else:
  461.             current.data = None
  462.             current.object = object
  463.  
  464.     
  465.     def property_element_char(self, data):
  466.         current = self.current
  467.         if current.data is not None:
  468.             current.data += data
  469.         
  470.  
  471.     
  472.     def property_element_end(self, name, qname):
  473.         current = self.current
  474.         if current.data is not None and current.object is None:
  475.             current.object = Literal(current.data, current.language, current.datatype)
  476.             current.data = None
  477.         
  478.         if self.next.end == self.list_node_element_end:
  479.             if current.object != RDF.nil:
  480.                 self.store.add((current.list, RDF.rest, RDF.nil))
  481.             
  482.         
  483.         if current.object is not None:
  484.             self.store.add((self.parent.subject, current.predicate, current.object))
  485.             if current.id is not None:
  486.                 self.add_reified(current.id, (self.parent.subject, current.predicate, current.object))
  487.             
  488.         
  489.         current.subject = None
  490.  
  491.     
  492.     def list_node_element_end(self, name, qname):
  493.         current = self.current
  494.         if self.parent.list == RDF.nil:
  495.             list = BNode()
  496.             self.parent.list = list
  497.             self.store.add((self.parent.list, RDF.first, current.subject))
  498.             self.parent.object = list
  499.             self.parent.char = None
  500.         else:
  501.             list = BNode()
  502.             self.store.add((self.parent.list, RDF.rest, list))
  503.             self.store.add((list, RDF.first, current.subject))
  504.             self.parent.list = list
  505.  
  506.     
  507.     def literal_element_start(self, name, qname, attrs):
  508.         current = self.current
  509.         self.next.start = self.literal_element_start
  510.         self.next.char = self.literal_element_char
  511.         self.next.end = self.literal_element_end
  512.         current.declared = self.parent.declared.copy()
  513.         if name[0]:
  514.             prefix = self._current_context[name[0]]
  515.             if prefix:
  516.                 current.object = '<%s:%s' % (prefix, name[1])
  517.             else:
  518.                 current.object = '<%s' % name[1]
  519.             if name[0] not in current.declared:
  520.                 current.declared[name[0]] = prefix
  521.                 if prefix:
  522.                     current.object += ' xmlns:%s="%s"' % (prefix, name[0])
  523.                 else:
  524.                     current.object += ' xmlns="%s"' % name[0]
  525.             
  526.         else:
  527.             current.object = '<%s' % name[1]
  528.         for name, value in attrs.items():
  529.             if name[0]:
  530.                 if name[0] not in current.declared:
  531.                     current.declared[name[0]] = self._current_context[name[0]]
  532.                 
  533.                 name = current.declared[name[0]] + ':' + name[1]
  534.             else:
  535.                 name = name[1]
  536.             current.object += ' %s=%s' % (name, quoteattr(value))
  537.         
  538.         current.object += '>'
  539.  
  540.     
  541.     def literal_element_char(self, data):
  542.         self.current.object += escape(data)
  543.  
  544.     
  545.     def literal_element_end(self, name, qname):
  546.         if name[0]:
  547.             prefix = self._current_context[name[0]]
  548.             if prefix:
  549.                 end = u'</%s:%s>' % (prefix, name[1])
  550.             else:
  551.                 end = u'</%s>' % name[1]
  552.         else:
  553.             end = u'</%s>' % name[1]
  554.         self.parent.object += self.current.object + end
  555.  
  556.  
  557.