home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / python-support / python-rdflib / rdflib / syntax / serializers / RecursiveSerializer.py < prev    next >
Encoding:
Python Source  |  2007-04-04  |  3.9 KB  |  127 lines
  1. from rdflib.BNode import BNode
  2. from rdflib.Literal import Literal
  3. from rdflib.URIRef import URIRef
  4.  
  5. from rdflib.syntax.serializers.AbstractSerializer import AbstractSerializer
  6.  
  7. from rdflib import RDF, RDFS
  8.  
  9.  
  10. class RecursiveSerializer(AbstractSerializer):
  11.  
  12.     topClasses = [RDFS.Class]
  13.     predicateOrder = [RDF.type, RDFS.label]
  14.     maxDepth = 10
  15.     indentString = u"  "
  16.     
  17.     def __init__(self, store):
  18.  
  19.         super(RecursiveSerializer, self).__init__(store)
  20.         self.stream = None
  21.         self.reset()
  22.  
  23.     def addNamespace(self, prefix, uri):
  24.         self.namespaces[prefix] = uri
  25.         
  26.     def checkSubject(self, subject):
  27.         """Check to see if the subject should be serialized yet"""
  28.         if ((self.isDone(subject))
  29.             or (subject not in self._subjects)
  30.             or ((subject in self._topLevels) and (self.depth > 1))
  31.             or (isinstance(subject, URIRef) and (self.depth >= self.maxDepth))
  32.             ):
  33.             return False
  34.         return True
  35.  
  36.     def isDone(self, subject):
  37.         """Return true if subject is serialized"""
  38.         return subject in self._serialized
  39.     
  40.     def orderSubjects(self):
  41.         seen = {}
  42.         subjects = []
  43.  
  44.         for classURI in self.topClasses:
  45.             members = list(self.store.subjects(RDF.type, classURI))
  46.             members.sort()
  47.             
  48.             for member in members:
  49.                 subjects.append(member)
  50.                 self._topLevels[member] = True
  51.                 seen[member] = True
  52.  
  53.         recursable = [(isinstance(subject,BNode), self.refCount(subject), subject) for subject in self._subjects
  54.                       if subject not in seen]
  55.  
  56.         recursable.sort()
  57.         subjects.extend([subject for (isbnode, refs, subject) in recursable])
  58.                 
  59.         return subjects
  60.     
  61.     def preprocess(self):
  62.         for triple in self.store.triples((None,None,None)):
  63.             self.preprocessTriple(triple)
  64.  
  65.     def preprocessTriple(self, (s,p,o)):
  66.         references = self.refCount(o) + 1
  67.         self._references[o] = references
  68.         self._subjects[s] = True
  69.  
  70.     def refCount(self, node):
  71.         """Return the number of times this node has been referenced in the object position"""
  72.         return self._references.get(node, 0)
  73.     
  74.     def reset(self):
  75.         self.depth = 0
  76.         self.lists = {}
  77.         self.namespaces = {}
  78.         self._references = {}
  79.         self._serialized = {}
  80.         self._subjects = {}
  81.         self._topLevels = {}
  82.  
  83.     def buildPredicateHash(self, subject):
  84.         """Build a hash key by predicate to a list of objects for the given subject"""
  85.         properties = {}
  86.         for s,p,o in self.store.triples((subject, None, None)):
  87.             oList = properties.get(p, [])
  88.             oList.append(o)
  89.             properties[p] = oList
  90.         return properties
  91.             
  92.     def sortProperties(self, properties):
  93.         """Take a hash from predicate uris to lists of values.
  94.            Sort the lists of values.  Return a sorted list of properties."""
  95.         # Sort object lists
  96.         for prop, objects in properties.items():
  97.             objects.sort()
  98.  
  99.         # Make sorted list of properties
  100.         propList = []
  101.         seen = {}
  102.         for prop in self.predicateOrder:
  103.             if (prop in properties) and (prop not in seen):
  104.                 propList.append(prop)
  105.                 seen[prop] = True
  106.         props = properties.keys()
  107.         props.sort()
  108.         for prop in props:
  109.             if prop not in seen:
  110.                 propList.append(prop)
  111.                 seen[prop] = True
  112.         return propList
  113.  
  114.     def subjectDone(self, subject):
  115.         """Mark a subject as done."""
  116.         self._serialized[subject] = True
  117.  
  118.     def indent(self, modifier=0):
  119.         """Returns indent string multiplied by the depth"""
  120.         return (self.depth+modifier)*self.indentString
  121.         
  122.     def write(self, text):
  123.         """Write text in given encoding."""
  124.         self.stream.write(text.encode(self.encoding, 'replace'))
  125.  
  126.     
  127.