def jurisdictions_for_selector(selector_uri):
"""
Find out all the jurisdictions relevant to a selector/licenseclass
That is, find all the unique jurisdictions that licenses in this
selector have.
Returns:
A list of jurisdiction URIs
"""
if JURISDICTIONS_FOR_SELECTOR_CACHE.has_key(selector_uri):
return JURISDICTIONS_FOR_SELECTOR_CACHE[selector_uri]
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?jurisdiction
WHERE {
?license cc:licenseClass <%s> .
?license cc:jurisdiction ?jurisdiction . }"""
query = RDF.Query(qstring % selector_uri, query_language='sparql')
results = set([
str(result['jurisdiction'].uri) for result in query.execute(ALL_MODEL)
])
JURISDICTIONS_FOR_SELECTOR_CACHE[selector_uri] = results
return results
def __init__(self, uri):
# XXX do this as a dict later?
self._uri = uri
self._lclass = None
self._titles = None
self._descriptions = None
self._superseded_by = None
self._version = None
self._jurisdiction = None
self._deprecated = None
self._superseded = None
self._permits = None
self._requires = None
self._prohibits = None
self._code = None
self._logos = None
self._legalcodes = {}
# make sure the license actually exists
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
ASK { <%s> rdf:type cc:License . }"""
query = RDF.Query(qstring % self.uri, query_language='sparql')
uri_exists = query.execute(rdf_helper.ALL_MODEL).get_boolean()
if not uri_exists:
raise ExistentialException, \
"License <%(uri)s> does not exist in model given." % {
'uri': self.uri }
def active_languages():
"""Return a sequence of dicts, where each element consists of the
following keys:
* code: the language code
* name: the translated name of this language
for each available language."""
global _ACTIVE_LANGUAGES
if _ACTIVE_LANGUAGES:
return _ACTIVE_LANGUAGES
# get a list of avaialable translations
domain = base.queryUtility(ITranslationDomain,
ccorg_i18n_setup.I18N_DOMAIN)
lang_codes = set(domain.getCatalogsInfo().keys())
# determine the intersection of available translations and
# launched jurisdiction locales
launched_locales = set()
jurisdictions = cclicense_functions.get_valid_jurisdictions()
for jurisdiction in jurisdictions:
query_string = ('PREFIX dc: <http://purl.org/dc/elements/1.1/> '
'SELECT ?lang WHERE {'
' <%s> dc:language ?lang}') % jurisdiction
query = RDF.Query(str(query_string), query_language='sparql')
this_juri_locales = set([
locale_to_lower_upper(str(result['lang']))
for result in query.execute(rdf_helper.JURI_MODEL)
])
# Append those locales that are applicable to this domain
launched_locales.update(lang_codes.intersection(this_juri_locales))
# XXX: Have to hack in Esperanto here because it's technically an
# "Unported" language but there is no unported RDF jurisdiction in
# jurisdictions.rdf..
launched_locales.add('eo')
# make our sequence have a predictable order
launched_locales = list(launched_locales)
# this loop is long hand for clarity; it's only done once, so
# the additional performance cost should be negligible
result = []
for code in launched_locales:
if code == 'test': continue
gettext = ugettext_for_locale(negotiate_locale(code))
name = gettext(mappers.LANG_MAP[code])
result.append(dict(code=code, name=name))
result = sorted(result, key=lambda lang: lang['name'].lower())
_ACTIVE_LANGUAGES = result
return result
def get_deprecated(uri, model=ALL_MODEL):
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
ASK { <%s> cc:deprecatedOn ?date . }"""
query = RDF.Query(qstring % uri, query_language='sparql')
return query.execute(model).get_boolean()
def make_query(rdf, query):
model = RDF.Model()
parser = RDF.Parser()
parser.parse_into_model(model, rdf)
sparql = """
%s
%s""" % (PREFIX, query)
q = RDF.Query(sparql, query_language="sparql")
return q.execute(model)
def make_query(self, rdf, query):
"""Make sparql query."""
model = RDF.Model()
parser = RDF.Parser()
parser.parse_into_model(model, rdf)
sparql = """
%s
%s""" % (self.rdf_prefix, query)
q = RDF.Query(sparql, query_language="sparql")
return q.execute(model)
def get_requires(uri, model=ALL_MODEL):
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?requirement
WHERE {
<%s> cc:requires ?requirement .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
return tuple(str(p['requirement'].uri) for p in query.execute(model))
def get_logos(uri, model=ALL_MODEL):
qstring = """
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?img
WHERE {
<%s> foaf:logo ?img .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
return tuple(str(s['img'].uri) for s in query.execute(model))
def get_complete_metadata(self, user_uri, work_uri, format='json'):
work = Work.from_model(self._model, work_uri, user_uri)
if not self._can_access('read', work):
raise EntryAccessError("Can't access work {0}".format(work_uri))
if format not in ('ntriples', 'rdfxml', 'json'):
raise ParamError('invalid RDF format: {0}'.format(format))
query_format = """
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX catalog: <http://catalog.commonsmachinery.se/ns#>
PREFIX rem3: <http://scam.sf.net/schema#>
CONSTRUCT {
?s ?p ?o .
?work dc:source ?sourceWork .
}
WHERE
{
BIND (<%s> AS ?work)
BIND (<%s> AS ?user)
?work catalog:creator ?creator .
?work catalog:visible ?visible .
?work rem3:metadata ?workMetadata .
?work catalog:source ?sourceRef .
?sourceRef rem3:resource ?sourceWork .
{ ?sourceWork rem3:metadata ?sourceMetadata . }
UNION
{ ?sourceRef rem3:cachedExternalMetadata ?sourceMetadata . }
GRAPH ?g { ?s ?p ?o . }
FILTER((?g = ?workMetadata || ?g = ?sourceMetadata) &&
((?visible = "public") ||
(?visible = "private") && (?creator = ?user)))
}
"""
query_string = query_format % (work_uri, user_uri)
query = RDF.Query(query_string)
query_results = query.execute(self._model)
# TODO: use results.to_string() with proper format URIs
temp_model = RDF.Model(RDF.MemoryStorage())
for statement in query_results.as_stream():
temp_model.append(statement)
result = temp_model.to_string(name=format, base_uri=None)
return result
def get_prohibits(uri, model=ALL_MODEL):
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?prohibition
WHERE {
<%s> cc:prohibits ?prohibition .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
return tuple(str(p['prohibition'].uri) for p in query.execute(model))
def get_selector_id(uri):
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?lcode
WHERE {
<%s> cc:licenseCode ?lcode .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
solns = [i for i in query.execute(SEL_MODEL)]
return str(solns[0]['lcode'].literal_value['string'])
def get_license_code(uri, model=ALL_MODEL):
qstring = """
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?code
WHERE {
<%s> dc:identifier ?code .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
solns = [i for i in query.execute(model)]
return str(solns[0]['code'].literal_value['string'])
def get_license_class(uri, model=ALL_MODEL):
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?lclassuri
WHERE {
<%s> cc:licenseClass ?lclassuri .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
solns = [i for i in query.execute(model)]
return str(solns[0]['lclassuri'].uri)
def get_all_license_urls():
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?luri
WHERE {
?luri rdf:type cc:License .
}
"""
query = RDF.Query(qstring, query_language='sparql')
return tuple(
str(s['luri'].uri) for s in query.execute(rdf_helper.ALL_MODEL))
def selector_has_license(selector_uri, license_uri, model=ALL_MODEL):
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
ASK { <%s> cc:licenseClass <%s> . }"""
# can't interpolate empty strings
if selector_uri == '':
selector_uri = 'NONE'
if license_uri == '':
license_uri = 'NONE'
query = RDF.Query(qstring % (license_uri, selector_uri),
query_language='sparql')
return query.execute(model).get_boolean()
def get_license_uris(selector_uri, model=ALL_MODEL):
# FIXME: This function is never hit by any unit tests.
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?luri
WHERE {
?luri cc:licenseClass <%s> .
}
"""
query = RDF.Query(qstring % selector_uri, query_language='sparql')
return tuple(str(s['luri'].uri) for s in query.execute(model))
def get_selector_uris():
"""Returns a list of LicenseSelector URIs."""
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?uri
WHERE {
?uri rdf:type cc:LicenseSelector .
}
"""
query = RDF.Query(qstring, query_language='sparql')
return [str(s['uri'].uri) for s in query.execute(SEL_MODEL)]
def validate(g):
print >>sys.stderr, 'Validating domains/ranges ...',
for domain_constraint in RDF.Query('SELECT ?s ?o WHERE (?s <http://www.w3.org/2000/01/rdf-schema#domain> ?o)').execute(g):
if not domain_constraint['s'].is_resource() or not domain_constraint['o'].is_resource():
continue # for now
if domain_constraint['o'] in DOMAIN_OBJECT_EXCEPTIONS:
continue
for x in RDF.Query('SELECT ?s WHERE (?s <%s> ?o)' % domain_constraint['s'].uri).execute(g):
if domain_constraint['o'] not in _types(g, x['s']):
raise ValueError('property %s on %s violates rdfs:domain constraint of %s (found %r)' % (domain_constraint['s'], x['s'], domain_constraint['o'], [str(x) for x in _types(g, x['s'])]))
for range_constraint in RDF.Query('SELECT ?s ?o WHERE (?s <http://www.w3.org/2000/01/rdf-schema#range> ?o)').execute(g):
if not range_constraint['s'].is_resource() or not range_constraint['o'].is_resource():
continue # for now
if range_constraint['s'] in RANGE_PROPERTY_EXCEPTIONS or range_constraint['o'] in RANGE_OBJECT_EXCEPTIONS:
continue
for x in RDF.Query('SELECT ?o WHERE (?s <%s> ?o)' % range_constraint['s'].uri).execute(g):
if range_constraint['o'] in (RDF_NS.Literal, RDFS_NS.Literal):
if not x['o'].is_literal():
raise ValueError('property %s to %s violates rdfs:range constraint of %s (not is_literal())' % (range_constraint['s'], x['o'], range_constraint['o']))
else:
if range_constraint['o'] not in _types(g, x['o']):
raise ValueError('property %s to %s violates rdfs:range constraint of %s (found %r)' % (range_constraint['s'], x['o'], range_constraint['o'], [str(x) for x in _types(g, x['o'])]))
print >>sys.stderr, 'done'
def get_license_legalcodes(license_uri):
"""
Return a list of [(legalcode_uri, legalcode_lang)] for license_uri
If this is a single-legalcode option, it'll probably return
[(legalcode_uri, None)]
"""
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?legalcode
WHERE {
<%s> cc:legalcode ?legalcode }"""
query = RDF.Query(qstring % license_uri, query_language='sparql')
results = set()
for result in query.execute(ALL_MODEL):
legalcode_uri = str(result['legalcode'].uri)
qstring = """
PREFIX dcq: <http://purl.org/dc/terms/>
SELECT ?lang
WHERE {
<%s> dcq:language ?lang }"""
query = RDF.Query(qstring % legalcode_uri, query_language='sparql')
lang_results = [
str(result['lang']) for result in query.execute(ALL_MODEL)
]
if lang_results:
results.add((legalcode_uri, str(lang_results[0])))
else:
results.add((legalcode_uri, None))
return results
def get_version(uri, model=ALL_MODEL):
qstring = """
PREFIX dcq: <http://purl.org/dc/terms/>
SELECT ?version
WHERE {
<%s> dcq:hasVersion ?version .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
solns = [i for i in query.execute(model)]
if len(solns) == 0:
return ''
else:
return solns[0]['version'].literal_value['string']
def get_jurisdiction(uri, model=ALL_MODEL):
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?jurisdiction
WHERE {
<%s> cc:jurisdiction ?jurisdiction .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
solns = [i for i in query.execute(model)]
if len(solns) == 0:
return cc.license.Jurisdiction('') # empty string makes 'Unported'
else:
return cc.license.Jurisdiction(str(solns[0]['jurisdiction'].uri))
def get_jurisdiction_licenses(uri, model=ALL_MODEL):
# FIXME: This function is never hit by any unit tests.
qstring = """
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?license
WHERE {
?license cc:jurisdiction <%s> .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
solns = [i for i in query.execute(model)]
if len(solns) == 0:
return [] # empty makes 'Unported'
else:
return [str(l['license'].uri) for l in solns]
def get_superseded(uri, model=ALL_MODEL):
"""Watch out: returns a tuple and not just a value."""
qstring = """
PREFIX dcq: <http://purl.org/dc/terms/>
SELECT ?replacement
WHERE {
<%s> dcq:isReplacedBy ?replacement .
}
"""
query = RDF.Query(qstring % uri, query_language='sparql')
solns = [i for i in query.execute(model)]
if len(solns) == 0:
return (False, None)
else:
superseded_by = str(solns[0]['replacement'].uri)
return (True, superseded_by)
def getAggregatedIdentifiers(identifier):
"""Retrieves and parses the resource map with the specified identifier.
Returns: List(str)
List of identifiers.
"""
if type(identifier) is not str or len(identifier) < 1:
raise Exception("Bad identifier string passed to method.")
model = RDF.Model()
parser = RDF.Parser(name="rdfxml")
base_url = "https://cn.dataone.org/cn/v1/object/"
query_url = base_url + urllib.quote_plus(identifier)
try:
parser.parse_into_model(model, query_url)
except RDF.RedlandError as e:
print "Exception: Failed to parse RDF/XML at `%s`: %s" % (query_url, e)
query = """
SELECT ?s ?o
WHERE {
?s <http://www.openarchives.org/ore/terms/aggregates> ?o
}
"""
q = RDF.Query(query)
identifiers = []
for result in q.execute(model):
if 'o' not in result:
continue
object_node = result['o']
if object_node.is_resource():
object_node_str = str(object_node)
identifier = extractIdentifierFromFullURL(object_node_str)
if identifier is not None:
identifiers.append(identifier)
return identifiers
def query_sparql(self, query_string=None, results_format="json"):
if results_format not in ('json', 'n3', 'xml'):
raise ParamError('invalid SPARQL result format: {0}'.format(results_format))
query = RDF.Query(querystring=query_string, query_language="sparql")
query_results = query.execute(self._model)
if query.get_limit() < 0:
query.set_limit(50)
if results_format == "json":
format_uri = "http://www.mindswap.org/%7Ekendall/sparql-results-json/"
elif results_format == "n3":
format_uri = "http://www.w3.org/TeamSubmission/turtle/"
elif results_format == "html":
format_uri = "http://www.w3.org/1999/xhtml/"
else:
format_uri = "http://www.w3.org/TR/2008/REC-rdf-sparql-XMLres-20080115/"
return query_results.to_string(format_uri=format_uri)
def get_jurisdiction_default_language(juris_uri):
qstring = """
PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX cc: <http://creativecommons.org/ns#>
SELECT ?default_language
WHERE {
<%s> cc:defaultLanguage ?default_language
}
"""
query = RDF.Query(qstring % juris_uri, query_language='sparql')
results = [
str(result['default_language']) for result in query.execute(JURI_MODEL)
]
if results:
return results[0]
else:
return None
def get_valid_jurisdictions(license_class='standard'):
if _VALID_JURISDICTIONS_CACHE.has_key(license_class):
return _VALID_JURISDICTIONS_CACHE[license_class]
# TODO: use license_class here
query = RDF.Query(
str('PREFIX cc: <http://creativecommons.org/ns#> '
'SELECT ?jurisdiction WHERE '
'{ ?license cc:licenseClass <http://creativecommons.org/license/> .'
' ?license cc:jurisdiction ?jurisdiction }'),
query_language="sparql")
jurisdictions = set(
[unicode(result['jurisdiction'].uri)
for result in query.execute(rdf_helper.ALL_MODEL)])
_VALID_JURISDICTIONS_CACHE[license_class] = jurisdictions
return jurisdictions
def locales():
"""Returns a sequence of all locales possible.
A locale is a string that represents the language of a jurisdiction.
Note that locales are not the same as jurisdiction codes."""
query_string = """
PREFIX cc: <http://creativecommons.org/ns#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?lang
WHERE
{
?x cc:defaultLanguage ?lang .
?x rdf:type cc:Jurisdiction .
}
"""
query = RDF.Query(query_string, query_language='sparql')
return [s['lang'].literal_value['string']
for s in query.execute(rdf_helper.JURI_MODEL)]
def get_titles(uri, model=ALL_MODEL):
"""Given a URI for an RDF resource, return a dictionary of
corresponding to its dc:title properties. The indices will
be locale codes, and the values will be titles."""
qstring = """
PREFIX dc: <http://purl.org/dc/elements/1.1/>
SELECT ?title
WHERE
{
<%s> dc:title ?title .
}
"""
# get the data back
query = RDF.Query(qstring % uri, query_language='sparql')
# parse the data
_titles = {}
for s in query.execute(model):
tmp = s['title'].literal_value
_titles[tmp['language']] = tmp['string']
return _titles
def get_selector_jurisdictions(selector_name='standard'):
"""
Get all of the launched jurisdictions that licenses in this
selector are part of
"""
if _SELECTOR_JURISDICTIONS_CACHE.has_key(selector_name):
return _SELECTOR_JURISDICTIONS_CACHE[selector_name]
selector = cc.license.selectors.choose(selector_name)
qstring = "\n".join([
"SELECT ?license",
"WHERE (?license cc:licenseClass <%s>)" % str(selector.uri),
"USING cc FOR <http://creativecommons.org/ns#>"
])
query = RDF.Query(qstring, query_language="rdql")
# This is so stupid, but if we add a WHERE clause for
# jurisdictions in the query string it takes approximately 5
# million years.
licenses = [
cc.license.by_uri(str(result['license'].uri))
for result in query.execute(rdf_helper.ALL_MODEL)
]
# We need to make sure jurisdictions are unique. The easiest way
# to do that is have a second set that keeps track of all the
# codes added so far.
code_check = set()
jurisdictions = set()
for license in licenses:
jurisdiction = license.jurisdiction
if jurisdiction.launched and not jurisdiction.code in code_check:
jurisdictions.add(jurisdiction)
code_check.add(jurisdiction.code)
_SELECTOR_JURISDICTIONS_CACHE[selector_name] = jurisdictions
return jurisdictions
