def testBinding(self) -> None:
class a:
def __init__(self, v: str) -> None:
self.v = v[3:-3]
def __str__(self) -> str:
return "<<<%s>>>" % self.v
dtA = rdflib.URIRef("urn:dt:a")
bind(dtA, a)
va = a("<<<2>>>")
la = Literal(va, normalize=True)
self.assertEqual(la.value, va)
self.assertEqual(la.datatype, dtA)
la2 = Literal("<<<2>>>", datatype=dtA)
self.assertTrue(isinstance(la2.value, a))
self.assertEqual(la2.value.v, va.v)
class b:
def __init__(self, v: str) -> None:
self.v = v[3:-3]
def __str__(self) -> str:
return "B%s" % self.v
dtB = rdflib.URIRef("urn:dt:b")
bind(dtB, b, None, lambda x: "<<<%s>>>" % x)
vb = b("<<<3>>>")
lb = Literal(vb, normalize=True)
self.assertEqual(lb.value, vb)
self.assertEqual(lb.datatype, dtB)
def rdf_bind_to_string(rdf_type):
"""Python2/3 compatibility wrapper around rdflib.term.bind that binds a
term to the appropriate string type.
"""
string_type = unicode if sys.version_info < (3, ) else str # noqa
bind(rdf_type, string_type)
def testBinding(self):
class a:
def __init__(self,v):
self.v=v[3:-3]
def __str__(self):
return '<<<%s>>>'%self.v
dtA=rdflib.URIRef('urn:dt:a')
bind(dtA,a)
va=a("<<<2>>>")
la=Literal(va, normalize=True)
self.assertEqual(la.value,va)
self.assertEqual(la.datatype, dtA)
la2=Literal("<<<2>>>", datatype=dtA)
self.assertTrue(isinstance(la2.value, a))
self.assertEqual(la2.value.v,va.v)
class b:
def __init__(self,v):
self.v=v[3:-3]
def __str__(self):
return 'B%s'%self.v
dtB=rdflib.URIRef('urn:dt:b')
bind(dtB,b,None,lambda x: '<<<%s>>>'%x)
vb=b("<<<3>>>")
lb=Literal(vb, normalize=True)
self.assertEqual(lb.value,vb)
self.assertEqual(lb.datatype, dtB)
def testSpecificBinding(self) -> None:
def lexify(s: str) -> str:
return "--%s--" % s
def unlexify(s: str) -> str:
return s[2:-2]
datatype = rdflib.URIRef("urn:dt:mystring")
# Datatype-specific rule
bind(datatype, str, unlexify, lexify, datatype_specific=True)
s = "Hello"
normal_l = Literal(s)
self.assertEqual(str(normal_l), s)
self.assertEqual(normal_l.toPython(), s)
self.assertEqual(normal_l.datatype, None)
specific_l = Literal("--%s--" % s, datatype=datatype)
self.assertEqual(str(specific_l), lexify(s))
self.assertEqual(specific_l.toPython(), s)
self.assertEqual(specific_l.datatype, datatype)
you can also add your own.
This example shows how :meth:`rdflib.term.bind` lets you register new
mappings between literal datatypes and python objects
"""
from rdflib import Graph, Literal, Namespace, XSD
from rdflib.term import bind
if __name__ == '__main__':
# complex numbers are not registered by default
# no custom constructor/serializer needed since
# complex('(2+3j)') works fine
bind(XSD.complexNumber, complex)
ns = Namespace("urn:my:namespace:")
c = complex(2, 3)
l = Literal(c)
g = Graph()
g.add((ns.mysubject, ns.myprop, l))
n3 = g.serialize(format='n3')
# round-trip through n3
g2 = Graph()
from six import with_metaclass
from rdflib.term import URIRef
from rdflib.term import bind
from gutenberg._domain_model.exceptions import UnsupportedFeatureException
from gutenberg._domain_model.types import validate_etextno
from gutenberg._util.abc import abstractclassmethod
from gutenberg._util.objects import all_subclasses
from gutenberg.acquire.metadata import load_metadata
import sys
# Add a binding for Project Gutenberg's Language datatype
if sys.version_info < (3, ):
bind(URIRef('http://purl.org/dc/terms/RFC4646'), unicode)
else:
bind(URIRef('http://purl.org/dc/terms/RFC4646'), str)
def get_metadata(feature_name, etextno):
"""Looks up the value of a meta-data feature for a given text.
Arguments:
feature_name (str): The name of the meta-data to look up.
etextno (int): The identifier of the Gutenberg text for which to look
up the meta-data.
Returns:
frozenset: The values of the meta-data for the text or an empty set if
the text does not have meta-data associated with the feature.
DCT = Namespace("http://purl.org/dc/terms/")
DCAT = Namespace("http://www.w3.org/ns/dcat#")
ADMS = Namespace("http://www.w3.org/ns/adms#")
VCARD = Namespace("http://www.w3.org/2006/vcard/ns#")
FOAF = Namespace("http://xmlns.com/foaf/0.1/")
SCHEMA = Namespace('http://schema.org/')
TIME = Namespace('http://www.w3.org/2006/time')
LOCN = Namespace('http://www.w3.org/ns/locn#')
GSP = Namespace('http://www.opengis.net/ont/geosparql#')
OWL = Namespace('http://www.w3.org/2002/07/owl#')
SPDX = Namespace('http://spdx.org/rdf/terms#')
HYDRA = Namespace('http://www.w3.org/ns/hydra/core#')
bind(datatype='http://www.opengis.net/ont/geosparql#asWKT', pythontype=str)
NAMESPACES = {
'dct': DCT,
'dcat': DCAT,
'adms': ADMS,
'vcard': VCARD,
'foaf': FOAF,
'schema': SCHEMA,
'time': TIME,
'skos': SKOS,
'locn': LOCN,
'gsp': GSP,
'owl': OWL,
'spdx': SPDX,
you can also add your own.
This example shows how :meth:`rdflib.term.bind` lets you register new
mappings between literal datatypes and Python objects
"""
from rdflib import Graph, Literal, Namespace, XSD
from rdflib import term
if __name__ == "__main__":
# Complex numbers are not registered by default
# No custom constructor/serializer needed since
# complex('(2+3j)') works fine
term.bind(XSD.complexNumber, complex)
# Create a complex number RDFlib Literal
EG = Namespace("http://example.com/")
c = complex(2, 3)
l = Literal(c)
# Add it to a graph
g = Graph()
g.add((EG.mysubject, EG.myprop, l))
# Print the triple to see what it looks like
print(list(g)[0])
# prints: (
# rdflib.term.URIRef('http://example.com/mysubject'),
# rdflib.term.URIRef('http://example.com/myprop'),
# rdflib.term.Literal(
from json import loads, dumps
from rdflib.term import Literal, bind, Identifier, URIRef
import six
from .quantity import Quantity
from .utils import FCN
from . import BASE_SCHEMA_URL
bind(URIRef(BASE_SCHEMA_URL + '/datatype/quantity'),
Quantity,
constructor=Quantity.parse,
lexicalizer=Quantity.__str__)
bind(URIRef(BASE_SCHEMA_URL + '/datatype/list'),
list,
constructor=loads,
lexicalizer=dumps)
bind(URIRef(BASE_SCHEMA_URL + '/datatype/object'),
dict,
constructor=loads,
lexicalizer=lambda x: dumps(x, sort_keys=True))
# XXX: RDFLib should take the first match for a python type, so we'll translate into the
# list and object types above
bind(URIRef('http://markw.cc/yarom/schema/datatype/list'),
list,
constructor=loads,
lexicalizer=dumps)
bind(URIRef('http://markw.cc/yarom/schema/datatype/object'),
dict,
constructor=loads,
"""
from rdflib import Graph, Literal
from rdflib.namespace import Namespace, RDF, DCTERMS
from rdflib.term import bind
from pyspark.sql import SparkSession, SQLContext, Row
from pyspark import SparkContext
import sys, csv, io, json, boto3, re
""" Edit these variables! """
PGTERMS = Namespace(u'http://www.gutenberg.org/2009/pgterms/')
BUCKET = 'YOUR_BUCKET_NAME' # name of your bucket
PGPATH = 's3n://' + BUCKET + '/gutenberg_dataset/' # path where Gutenberg data resides
WORKINGDIR = 's3n://' + BUCKET + '/results/' # path where you are storing your results
PGCAT = WORKINGDIR + 'pgcat.json/part-00000' # path to your catalogue index (expects json)
bind(DCTERMS.RFC4646, str)
def cnt_pronouns(id, text):
""" Count gender pronouns in a single ebook
Note: performs case-insensitive matching
"""
mcount = len(
re.findall(r'\b(he|him|himself|his)\b', str(text), re.IGNORECASE))
fcount = len(
re.findall(r'\b(she|her|herself|hers)\b', str(text), re.IGNORECASE))
result = [id, mcount, fcount]
return result
def get_keys(bucket_name):
"""
rdflib.term.bind lets you register new mappings between literal
datatypes and python objects
"""
from rdflib import Graph, Literal, Namespace, XSD
from rdflib.term import bind
# complex numbers are not registered by default
# no custom constructor/serializer needed since
# complex('(2+3j)') works fine
bind(XSD.complexNumber, complex)
ns=Namespace("urn:my:namespace:")
c=complex(2,3)
l=Literal(c)
g=Graph()
g.add((ns.mysubject, ns.myprop, l))
n3=g.serialize(format='n3')
# round-trip through n3
g2=Graph()
g2.parse(data=n3, format='n3')
an RDF graph.
"""
from rdflib.term import bind, URIRef
from rdflib.graph import Graph
from rdflib.namespace import Namespace
from sparql import a, SPARQLEndpoint, SelectQuery
# dump lots of debug info
DEBUG = False
# by default return rdflib.term.Literals as Unicode strings
bind(None, unicode)
class RDFClassManager(object):
"""A container like object which represents a SPARQL query and returns
RDFClass objects.
"""
def __init__(self, cls, query=None):
self.cls = cls
if query:
self.query = query
else:
self.query = SelectQuery().select("?resource").where("?resource", a,
cls.class_uri)
from six import with_metaclass
from rdflib.term import URIRef
from rdflib.term import bind
from gutenberg._domain_model.exceptions import UnsupportedFeatureException
from gutenberg._domain_model.types import validate_etextno
from gutenberg._util.abc import abstractclassmethod
from gutenberg._util.objects import all_subclasses
from gutenberg.acquire.metadata import load_metadata
import sys
# Add a binding for Project Gutenberg's Language datatype
if sys.version_info < (3,):
bind(URIRef('http://purl.org/dc/terms/RFC4646'), unicode)
else:
bind(URIRef('http://purl.org/dc/terms/RFC4646'), str)
def get_metadata(feature_name, etextno):
"""Looks up the value of a meta-data feature for a given text.
Arguments:
feature_name (str): The name of the meta-data to look up.
etextno (int): The identifier of the Gutenberg text for which to look
up the meta-data.
Returns:
frozenset: The values of the meta-data for the text or an empty set if
the text does not have meta-data associated with the feature.
from urllib import urlopen, quote_plus
NSS = { 'atom':'http://www.w3.org/2005/Atom',
'zapi':'http://zotero.org/ns/api',
'x':'http://www.w3.org/1999/xhtml' }
DC = Namespace('http://purl.org/dc/terms/')
SCH = Namespace('http://schema.org/')
def yearmonth2date(ym):
y,m = [ int(x) for x in ym.split('-') ]
return datetime.date(y,m,1)
def date2yearmonth(d):
return date.year + '-' + date.month
bind(XSD.gYearMonth, datetime.date, yearmonth2date, date2yearmonth)
def allbut(unwanted, d):
return { k:v for k,v in d.iteritems() if not k in unwanted }
def entry2dict(entry):
rows = entry.iterfind('.//x:tr', NSS)
kfun = lambda x: x[0]
items = [ (row.attrib['class'], row.find('x:td', NSS).text)
for row in rows ]
return dict([(k, [ x[1] for x in g ])
for k,g in groupby(sorted(items, key=kfun), kfun) ])
def load_graph(url):
r = None
while True:
