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 / serializers / TurtleSerializer.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  8.0 KB  |  220 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import urlparse
  5. from xml.sax.saxutils import escape, quoteattr
  6. from rdflib.BNode import BNode
  7. from rdflib.Literal import Literal
  8. from rdflib.URIRef import URIRef
  9. from rdflib.syntax.xml_names import split_uri
  10. from rdflib.syntax.serializers.RecursiveSerializer import RecursiveSerializer
  11. from rdflib.exceptions import Error
  12. from rdflib import RDF, RDFS
  13. SUBJECT = 0
  14. VERB = 1
  15. OBJECT = 2
  16.  
  17. class TurtleSerializer(RecursiveSerializer):
  18.     short_name = 'turtle'
  19.     indentString = '    '
  20.     
  21.     def __init__(self, store):
  22.         super(TurtleSerializer, self).__init__(store)
  23.         self.reset()
  24.         self.stream = None
  25.  
  26.     
  27.     def reset(self):
  28.         super(TurtleSerializer, self).reset()
  29.         self._shortNames = { }
  30.         self._started = False
  31.  
  32.     
  33.     def getQName(self, uri):
  34.         if isinstance(uri, URIRef):
  35.             
  36.             try:
  37.                 parts = self.store.compute_qname(uri)
  38.             except Exception:
  39.                 e = None
  40.                 parts = None
  41.  
  42.             if parts:
  43.                 (prefix, namespace, local) = parts
  44.                 if local.find('.') != -1:
  45.                     return None
  46.                 self.addNamespace(prefix, namespace)
  47.                 return u'%s:%s' % (prefix, local)
  48.         
  49.  
  50.     
  51.     def preprocessTriple(self, triple):
  52.         super(TurtleSerializer, self).preprocessTriple(triple)
  53.         for node in triple:
  54.             self.getQName(node)
  55.         
  56.         p = triple[1]
  57.         if isinstance(p, BNode):
  58.             self._references[p] = self.refCount(p) + 1
  59.         
  60.  
  61.     
  62.     def label(self, node):
  63.         qname = self.getQName(node)
  64.         if qname is None:
  65.             return node.n3()
  66.         return qname
  67.  
  68.     
  69.     def startDocument(self):
  70.         self._started = True
  71.         ns_list = list(self.store.namespaces())
  72.         ns_list.sort()
  73.         if len(ns_list) == 0:
  74.             return None
  75.         for prefix, uri in ns_list:
  76.             self.write('\n' + self.indent() + '@prefix %s: %s.' % (prefix, uri))
  77.         
  78.         self.write('\n')
  79.  
  80.     
  81.     def endDocument(self):
  82.         pass
  83.  
  84.     
  85.     def isValidList(self, l):
  86.         '''Checks if l is a valid RDF list, i.e. no nodes have other properties.'''
  87.         
  88.         try:
  89.             if not self.store.value(l, RDF.first):
  90.                 return False
  91.         except:
  92.             return False
  93.  
  94.         while l:
  95.             if l != RDF.nil and len(list(self.store.predicate_objects(l))) != 2:
  96.                 return False
  97.             l = self.store.value(l, RDF.rest)
  98.             continue
  99.             len(list(self.store.predicate_objects(l))) != 2
  100.         return True
  101.  
  102.     
  103.     def doList(self, l):
  104.         while l:
  105.             item = self.store.value(l, RDF.first)
  106.             if item:
  107.                 self.path(item, SUBJECT)
  108.                 self.subjectDone(l)
  109.             
  110.             l = self.store.value(l, RDF.rest)
  111.  
  112.     
  113.     def p_squared(self, node, position):
  114.         if not isinstance(node, BNode) and node in self._serialized and self.refCount(node) > 1 or position == SUBJECT:
  115.             return False
  116.         if self.isValidList(node):
  117.             self.write(' (')
  118.             self.depth += 2
  119.             self.doList(node)
  120.             self.depth -= 2
  121.             self.write(' )')
  122.             return True
  123.         self.subjectDone(node)
  124.         self.write(' [')
  125.         self.depth += 2
  126.         self.predicateList(node)
  127.         self.depth -= 2
  128.         self.write(']')
  129.         return True
  130.  
  131.     
  132.     def p_default(self, node, ignore):
  133.         self.write(' ' + self.label(node))
  134.         return True
  135.  
  136.     
  137.     def path(self, node, position):
  138.         if not self.p_squared(node, position) or self.p_default(node, position):
  139.             raise Error("Cannot serialize node '%s'" % (node,))
  140.         self.p_default(node, position)
  141.  
  142.     
  143.     def verb(self, node):
  144.         if node == RDF.type:
  145.             self.write(' a')
  146.         else:
  147.             self.path(node, VERB)
  148.  
  149.     
  150.     def objectList(self, objects):
  151.         if len(objects) == 0:
  152.             return None
  153.         self.path(objects[0], OBJECT)
  154.         for obj in objects[1:]:
  155.             self.write(',\n' + self.indent(2))
  156.             self.path(obj, OBJECT)
  157.         
  158.  
  159.     
  160.     def predicateList(self, subject):
  161.         properties = self.buildPredicateHash(subject)
  162.         propList = self.sortProperties(properties)
  163.         if len(propList) == 0:
  164.             return None
  165.         self.verb(propList[0])
  166.         self.objectList(properties[propList[0]])
  167.         for predicate in propList[1:]:
  168.             self.write(';\n' + self.indent(1))
  169.             self.verb(predicate)
  170.             self.objectList(properties[predicate])
  171.         
  172.  
  173.     
  174.     def s_squared(self, subject):
  175.         if self.refCount(subject) > 0 or not isinstance(subject, BNode):
  176.             return False
  177.         self.write('\n' + self.indent() + ' [')
  178.         self.depth += 1
  179.         self.predicateList(subject)
  180.         self.depth -= 1
  181.         self.write('].')
  182.         return True
  183.  
  184.     
  185.     def s_default(self, subject):
  186.         self.write('\n' + self.indent())
  187.         self.path(subject, SUBJECT)
  188.         self.predicateList(subject)
  189.         self.write('. ')
  190.         return True
  191.  
  192.     
  193.     def statement(self, subject):
  194.         self.subjectDone(subject)
  195.         if not self.s_squared(subject):
  196.             self.s_default(subject)
  197.         
  198.  
  199.     
  200.     def serialize(self, stream, base = None, encoding = None, **args):
  201.         self.reset()
  202.         self.stream = stream
  203.         self.base = base
  204.         self.preprocess()
  205.         subjects_list = self.orderSubjects()
  206.         self.startDocument()
  207.         firstTime = True
  208.         for subject in subjects_list:
  209.             if not self.isDone(subject):
  210.                 if firstTime:
  211.                     firstTime = False
  212.                 else:
  213.                     self.write('\n')
  214.                 self.statement(subject)
  215.                 continue
  216.         
  217.         self.endDocument()
  218.  
  219.  
  220.