Python ConjunctiveGraph.subjects方法代碼示例

# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import subjects [as 別名]
def check_type_definitions(vocabfile):
    graph = Graph()
    try:
        graph.parse(vocabfile)
    except:
        return False
    all_definitions = True
    
    testo = vocab_type_definitions_test['rdfs']
    subjects = []
    subs = graph.subjects(namespaces['rdf']['type'], URIRef(testo))
    for s in subs:
        subjects.append(s)
    if subjects:
        objects = vocab_type_definitions_rdfs
    else:
        objects = vocab_type_definitions_owl
    for o in objects: 
        subs = graph.subjects(namespaces['rdf']['type'], o)
        done = []
        for s in subs:
            if s in done:
               continue
            done.append(s) 
            definition = False
            vals = graph.objects(s, namespaces['rdfs']['isDefinedBy'])
            for val in vals:
               definition = True
            all_definitions = all_definitions and definition
    return all_definitions

# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import subjects [as 別名]
def check_propeties(vocabfile):
    graph = Graph()
    try:
        graph.parse(vocabfile)
    except:
        return {}

    subject = none
    for s in graph.subjects(namespaces['dc']['title'], None):
        subject = s
    if not subject:
        for s in graph.subjects(namespaces['dcterms']['title'], None):
            subject = s
    if not subject:
        for s in graph.subjects(namespaces['dc']['creator'], None):
            subject = s
    if not subject:
        for s in graph.subjects(namespaces['dcterms']['creator'], None):
            subject = s

    properties = {}

    #Identifier
    identifier = []
    ids = graph.objects(subject, namespaces['dc']['identifier'])
    for id in ids:
        identifier = id
    if not identifier:
        ids = graph.objects(subject, namespaces['dcterms']['identifier'])
        for id in ids:
            identifier.append(id)
    properties['identifier'] = [id]
    
    #hasFormat
    format = False
    
    prop1 = True
    prop2 = False
    prop3 = False
    properties['format'] = []
    for fm in graph.objects(subject, namespaces['dcterms']['hasFormat']):
        properties['format'].append(fm)
        bnodes = graph.objects(fm, namespaces['dc']['format'])
        for b in bnodes:
            for value in graph.objects(b, namespaces['rdf']['value']):
                prop1 = True
            for value in graph.objects(b, namespaces['rdfs']['label']):
                prop2 = True
            for value in graph.objects(b, namespaces['rdfs']['type']):
                prop3 = True
        if not 'all' in properties:
            properties['all'] = prop1 and prop2 and prop3
        else:
            properties['all'] = properties['all'] and prop1 and prop2 and prop3

    conforms = False
    if identifier and properties['format'] and properties['all']:
         conforms = True
    
    return (conforms, properties)

# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import subjects [as 別名]
class RdfParser(object):
	"""A basic wrapper for RdfLib's RDF parser.
	This class aims to accomplish easier parsing, extraction of Models,
	etc."""

	def __init__(self, rdf, format='guess'):
		"""Init the parser with the graph string."""
		self.graph = Graph()
		if format == 'guess':
			format = self.__guess_format(rdf)
			print 'RdfParser guesses format to be: %s' % format
		try:
			self.graph.load(StringIO(rdf), format=format)
		except:
			print "Failed to parse RDF:"
			print rdf[0:100]

	def extract(self, datatype):
		"""Extract all of the data of a given datatype."""
		data = []
		ns = RdfSerializer.NAMESPACES['sylph'] # TODO: Awkward.
		for sub in self.graph.subjects(RDF.type, ns[datatype]):
			idx = str(sub)
			item = {'uri': idx}
			for pred, obj in self.graph.predicate_objects(sub):
				if pred == RDF.type:
					continue
				if obj == ns['None']:
					obj = None
				elif type(obj) == URIRef:
					obj = unicode(obj)
				elif type(obj) == Literal:
					obj = obj.toPython()
					if type(obj) == Literal: # Don't be silly, RdfLib!
						obj = unicode(obj)

				predstr = str(pred).rpartition('#')[2].rpartition('/')[2]
				item[predstr] = obj
			data.append(item)
		return data

	@staticmethod
	def __guess_format(st):
		"""Guess the format of the input string."""
		# TODO: At present, it can only guess between XML and n3, even
		# then this is a vague heuristic.
		if st.startswith('<'):
			return 'xml'
		return 'n3'

# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import subjects [as 別名]
def schemadoc(uris): 
   G = Graph()
   for uri in uris: 
      G.parse(uri)

   print """
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Schema Documentation</title>
<style type="text/css">
body { margin: 1em; font-family: Georgia, sans-serif; }
h1 { font-family: Tahoma, sans-serif; }
h2, h3, h4, h5, h6 { font-family: Arial, sans-serif; }
a { font-weight: bold; color: #036; }
dt.class { margin-top: 0.75em; }
dt.property { margin-top: 0.75em; }
address { padding-top: 0.35em; border-top: 2px solid #369; }
</style>
</head>
<body>
<h1>Schema Documentation</h1>
"""
   classes = []
   for metaclass in [RDFS.Class, OWL.Class]: 
      for uri in G.subjects(RDF.type, metaclass): 
         if not isinstance(uri, URIRef): continue

         c = Class(uri)
         c.classes = [Class(u) for u in G.objects(uri, RDFS.subClassOf)
                      if isinstance(u, URIRef)]
         for prop in G.subjects(RDFS.domain, uri): 
            p = Property(prop)
            ranges = [Class(u) for u in G.objects(prop, RDFS.range)]
            c.properties.append((p, ranges))
         # c.properties = [Property(u) for u in G.subjects(RDFS.domain, uri)]
         c.comments = [str(s) for s in G.objects(uri, RDFS.comment)]
         classes.append(c)

   print '<h2>Classes</h2>'
   print '<ul>'
   for c in sorted(classes): 
      print '<li>'
      print '<dl>'
      print '<dt class="class">'
      sys.stdout.write(c.name())

      if c.classes: 
         o = ', '.join(cls.name(format='text') for cls in sorted(c.classes))
         print '(' + o + ')'
      else: print
      print '</dt>'

      for comment in c.comments: 
         print '<dd>'
         print comment
         print '</dd>'

      for prop, ranges in sorted(c.properties): 
         print '<dd>'
         print '   ' + prop.name()
         if ranges: 
            print ' => ' + ', '.join(range.name() for range in ranges)
         print '</dd>'
      print '</dt>'
      print '</li>'
   print '</ul>'

   print '<h2>Properties</h2>'
   properties = []
   print '<dl>'
   for propclass in [RDF.Property, OWL.FunctionalProperty,
                     OWL.InverseFunctionalProperty]: 
      for uri in G.subjects(RDF.type, propclass): 
         if not isinstance(uri, URIRef): continue

         p = Property(uri)
         properties.append(p)
         p.kind = Class(propclass)
         p.domains = [Class(u) for u in G.objects(uri, RDFS.domain)
                      if isinstance(u, URIRef)]
         p.ranges = [Class(u) for u in G.objects(uri, RDFS.range) 
                     if isinstance(u, URIRef)]
         p.comments = [str(s) for s in G.objects(uri, RDFS.comment)]

   for p in sorted(properties): 
      print '<dt class="property">'
      print p.name() + ' (' + p.kind.name(format='text') + ')'
      print '</dt>'

      for comment in p.comments: 
         print '<dd>'
         print comment
         print '</dd>'

      if p.domains: 
         print '<dd>domain: '
         print ', '.join(domain.name() for domain in p.domains)
         print '</dd>'

      if p.ranges: 
#.........這裏部分代碼省略.........

# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import subjects [as 別名]
def testN3Store(store="default", configString=None):
    g = ConjunctiveGraph(store=store)
    if configString:
        g.destroy(configString)
        g.open(configString)
    g.parse(StringInputSource(testN3), format="n3")
    print g.store
    try:
        for s,p,o in g.triples((None,implies,None)):
            formulaA = s
            formulaB = o

        assert type(formulaA)==QuotedGraph and type(formulaB)==QuotedGraph
        a = URIRef('http://test/a')
        b = URIRef('http://test/b')
        c = URIRef('http://test/c')
        d = URIRef('http://test/d')
        v = Variable('y')

        universe = ConjunctiveGraph(g.store)

        #test formula as terms
        assert len(list(universe.triples((formulaA,implies,formulaB))))==1

        #test variable as term and variable roundtrip
        assert len(list(formulaB.triples((None,None,v))))==1
        for s,p,o in formulaB.triples((None,d,None)):
            if o != c:
                assert isinstance(o,Variable)
                assert o == v
        s = list(universe.subjects(RDF.type, RDFS.Class))[0]
        assert isinstance(s,BNode)
        assert len(list(universe.triples((None,implies,None)))) == 1
        assert len(list(universe.triples((None,RDF.type,None)))) ==1
        assert len(list(formulaA.triples((None,RDF.type,None))))==1
        assert len(list(formulaA.triples((None,None,None))))==2
        assert len(list(formulaB.triples((None,None,None))))==2
        assert len(list(universe.triples((None,None,None))))==3
        assert len(list(formulaB.triples((None,URIRef('http://test/d'),None))))==2
        assert len(list(universe.triples((None,URIRef('http://test/d'),None))))==1

        #context tests
        #test contexts with triple argument
        assert len(list(universe.contexts((a,d,c))))==1

        #Remove test cases
        universe.remove((None,implies,None))
        assert len(list(universe.triples((None,implies,None))))==0
        assert len(list(formulaA.triples((None,None,None))))==2
        assert len(list(formulaB.triples((None,None,None))))==2

        formulaA.remove((None,b,None))
        assert len(list(formulaA.triples((None,None,None))))==1
        formulaA.remove((None,RDF.type,None))
        assert len(list(formulaA.triples((None,None,None))))==0

        universe.remove((None,RDF.type,RDFS.Class))


        #remove_context tests
        universe.remove_context(formulaB)
        assert len(list(universe.triples((None,RDF.type,None))))==0
        assert len(universe)==1
        assert len(formulaB)==0

        universe.remove((None,None,None))
        assert len(universe)==0

        g.store.destroy(configString)
    except:
        g.store.destroy(configString)
        raise

# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import subjects [as 別名]
def update_rdf_for_conversion(prefix, vocab_properties, rdf_vocab_properties):

    #(id, base, prefix) = get_vocab_base(vocabfile)
    html_vocab_properties = {}
    html_vocab_properties['format'] = 'text/html'
    html_vocab_properties['name'] = "%s.html"%os.path.splitext(rdf_vocab_properties['name'])[0]
    html_vocab_properties['path'] = rdf_vocab_properties['path'].replace(rdf_vocab_properties['name'], html_vocab_properties['name'])
    html_vocab_properties['uri'] = rdf_vocab_properties['uri'].replace(rdf_vocab_properties['name'], html_vocab_properties['name'])

    newrdf_vocab_properties = {}
    newrdf_vocab_properties['format'] = 'application/rdf+xml'
    newrdf_vocab_properties['name'] = "%s_modified.rdf"%os.path.splitext(rdf_vocab_properties['name'])[0]
    newrdf_vocab_properties['path'] = rdf_vocab_properties['path'].replace(rdf_vocab_properties['name'], newrdf_vocab_properties['name'])
    newrdf_vocab_properties['uri'] = rdf_vocab_properties['uri'].replace(rdf_vocab_properties['name'], newrdf_vocab_properties['name'])

    graph = Graph()
    graph.parse(rdf_vocab_properties['path'])

    subject = None
    for s in graph.subjects(namespaces['rdf']['type'], URIRef(namespaces['owl']['Ontology'])):
        subject = s

    #graph2 = Graph()
    graph_ns = []
    for nsprefix, nsurl in graph.namespaces():
        graph_ns.append(str(nsurl))
    for prefix, url in namespaces.iteritems():
        if not str(url) in graph_ns:
            graph.bind(prefix, URIRef(url))

    
    #properties = get_vocab_properties(prefix)
    #subject = None
    #for s in graph.subjects(namespaces['dc']['title'], None):
    #    subject = s
    #if not subject:
    #    for s in graph.subjects(namespaces['dcterms']['title'], None):
    #        subject = s
    #if not subject:
    #    for s in graph.subjects(namespaces['dc']['creator'], None):
    #        subject = s
    #if not subject:
    #    for s in graph.subjects(namespaces['dcterms']['creator'], None):
    #        subject = s

    formatNode1 = BNode()
    formatNode2 = BNode()

    #Add vocabulary properties identifier and format
    graph.add((subject, namespaces['dc']['identifier'], URIRef(rdf_vocab_properties['uri'])))
    graph.add((subject, namespaces['dcterms']['isVersionOf'], URIRef(vocab_properties['preferredNamespaceUri'])))
    graph.add((subject, namespaces['dcterms']['hasFormat'], URIRef(rdf_vocab_properties['uri'])))
    graph.add((subject, namespaces['dcterms']['hasFormat'], URIRef(html_vocab_properties['uri'])))
    graph.add((subject, namespaces['vann']['preferredNamespaceUri'], URIRef(vocab_properties['preferredNamespaceUri'])))
    graph.add((subject, namespaces['vann']['preferredNamespacePrefix'], URIRef(vocab_properties['preferredNamespacePrefix'])))

    graph.add((URIRef(html_vocab_properties['uri']), namespaces['rdf']['type'], URIRef(namespaces['dctype']['Text'])))
    graph.add((URIRef(html_vocab_properties['uri']), namespaces['dc']['format'], formatNode1))
    graph.add((formatNode1, namespaces['rdf']['value'], Literal('text/html')))
    graph.add((formatNode1, namespaces['rdfs']['label'], Literal('HTML')))
    graph.add((formatNode1, namespaces['rdf']['type'], URIRef(namespaces['dcterms']['IMT'])))

    graph.add((URIRef(rdf_vocab_properties['uri']), namespaces['rdf']['type'], URIRef(namespaces['dctype']['Text'])))
    graph.add((URIRef(rdf_vocab_properties['uri']), namespaces['dc']['format'], formatNode2))
    graph.add((formatNode2, namespaces['rdf']['value'], Literal('application/rdf+xml')))
    graph.add((formatNode2, namespaces['rdfs']['label'], Literal('RDF')))
    graph.add((formatNode2, namespaces['rdf']['type'], URIRef(namespaces['dcterms']['IMT'])))

    #Add rdfs:isDefinedBy for each class / property / term of the vocabulary
    #Find if schema is rdfs / owl. This defines the possible types (rdf:type) for each class / property / term
    #testo = vocab_type_definitions_test['rdfs']
    #subjects = []
    #subs = graph.subjects(namespaces['rdf']['type'], URIRef(testo))
    #for s in subs:
    #    subjects.append(s)
    #if subjects:
    #    objects = vocab_type_definitions_rdfs
    #else:
    #    objects = vocab_type_definitions_owl

    #For all subjects that are of the type found above, add rdfs:isDefinedBy
    #for o in objects: 
    #    subs = graph.subjects(namespaces['rdf']['type'], o)
    #    for s in subs:
    #        graph.add((s, namespaces['rdfs']['isDefinedBy'], URIRef(vocab_properties['preferredNamespaceUri'])))

    list_of_terms = get_terms(rdf_vocab_properties['path'])
    for s in list_of_terms:
        graph.add((URIRef(s), namespaces['rdfs']['isDefinedBy'], URIRef(vocab_properties['preferredNamespaceUri'])))

    rdf_str = None
    rdf_str = graph.serialize(format="pretty-xml")
    #f = codecs.open(newrdf_vocab_properties['path'], 'w', 'utf-8')
    f = codecs.open(newrdf_vocab_properties['path'], 'w')
    f.write(rdf_str)
    f.close()
    return (newrdf_vocab_properties, html_vocab_properties)