import time, logging, math, os, sys, socket
from influxdb import InfluxDBClient
from rdflib import Namespace
from twisted.internet import task
from greplin import scales
log = logging.getLogger()
ROOM = Namespace('http://projects.bigasterisk.com/room/')
stats = scales.collection(
'/export_to_influxdb',
scales.PmfStat('exportToInflux'),
)
class RetentionPolicies(object):
def __init__(self, influx):
self.influx = influx
self.createdPolicies = set() # days
def getCreatedPolicy(self, days):
name = 'ret_%d_day' % days
if days not in self.createdPolicies:
self.influx.create_retention_policy(name,
duration='%dd' % days,
replication='1')
self.createdPolicies.add(days)
return name
class InfluxExporter(object):
def __init__(self, configGraph, influxHost='bang5'):
def __init__(self, config, counter):
self.config = config
self.counter = counter
self.SKOS = Namespace("http://www.w3.org/2004/02/skos/core#")
self.nsdict = dict(skos=self.SKOS)
import uuid, re
from django.db import transaction
from django.db.models import Q
from django.utils.http import urlencode
from rdflib import Literal, Namespace, RDF, URIRef
from rdflib.namespace import SKOS, DCTERMS
from rdflib.graph import Graph
from time import time
from arches.app.models import models
from arches.app.models.concept import Concept
from arches.app.models.system_settings import settings
from arches.app.utils.betterJSONSerializer import JSONSerializer, JSONDeserializer
# define the ARCHES namespace
ARCHES = Namespace('http://www.archesproject.org/')
class SKOSReader(object):
def __init__(self):
self.nodes = []
self.relations = []
def read_file(self, path_to_file, format='xml'):
"""
parse the skos file and extract all available data
"""
rdf_graph = Graph()
#bind the namespaces
from datetime import datetime
import random
from .config import CONFIG, DATA_DIR, PROJECT_NAME, DATASET_FILEPATH, MATCHES_FILEPATH, EXPORT_DIR, PROV_AGENT, NS
from .csv import read_csv, write_csv
from .utils import source_files
from pit.prov import Provenance
from .rdf_dataset import RdfDataset
PROCESS_COUNT = 8
# KIRBY NAMESPACES
KIRBY_ENTRY = "http://kirby.diggr.link/entry"
KIRBY_DATASET = "http://kirby.diggr.link/dataset"
KIRBY_PROP = Namespace("http://kirby.diggr.link/property/")
KIRBY_MATCH_NS = Namespace("http://kirby.diggr.link/match/")
# KIRBY ENTITY TYPES
KIRBY_CORE = Namespace("http://kirby.diggr.link/")
SOURCE_DATASET = KIRBY_CORE.Dataset
SOURCE_DATASET_ROW = KIRBY_CORE.DatasetRow
KIRBY_MATCH = KIRBY_CORE.Match
# JSON-LD CONTEXT
CONTEXT = {
"rdf": str(RDF),
"kirby": str(KIRBY_CORE),
"kirby_ds": KIRBY_DATASET,
"kirby_prop": str(KIRBY_PROP)
}
class Chilled_Water_Differential_Pressure(Chilled_Water):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#'
).Chilled_Water_Differential_Pressure
This filters a graph by changing every subject with a
``foaf:mbox_sha1sum`` into a new subject whose URI is based on the
``sha1sum``. This new graph might be easier to do some operations on.
An advantage of this approach over other methods for collapsing BNodes
is that I can incrementally process new FOAF documents as they come in
without having to access my ever-growing archive. Even if another
``65b983bb397fb71849da910996741752ace8369b`` document comes in next
year, I would still give it the same stable subject URI that merges
with my existing data.
"""
from rdflib import Graph, Namespace
from rdflib.namespace import FOAF
STABLE = Namespace("http://example.com/person/mbox_sha1sum/")
if __name__ == "__main__":
g = Graph()
g.parse("smushingdemo.n3", format="n3")
newURI = {} # old subject : stable uri
for s, p, o in g.triples((None, FOAF["mbox_sha1sum"], None)):
newURI[s] = STABLE[o]
out = Graph()
out.bind("foaf", FOAF)
for s, p, o in g:
s = newURI.get(s, s)
o = newURI.get(o, o) # might be linked to another person
SBUILDING = NSUtil.get_namespase_domain_smart_building()
g1.bind('rdf', RDF)
g1.bind('rdfs', RDFS)
g1.bind('owl', OWL)
g1.bind('xsd', XSD)
# custom namespace
g1.bind('privvuln', PRIVVULN)
g1.bind('privvulnv2', PRIVVULNV2)
g1.bind('sbuilding', SBUILDING)
# model namespace
M = Namespace(
'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
g1.bind('m', M)
floor3_room1 = M['Teaching_Room_1']
g1.add((floor3_room1, RDF.type, SBUILDING.Teaching_Room))
scheduleActivities = M['ScheduleActivities']
g1.add((scheduleActivities, RDF.type, SBUILDING.ScheduleActivities))
g1.add((scheduleActivities, RDF.type, PRIVVULN.External))
g1.add((floor3_room1, PRIVVULNV2.has, scheduleActivities))
roomCountingLinesStream = M['CountingLinesStream']
g1.add((roomCountingLinesStream, RDF.type, SBUILDING.CountingLine))
g1.add((roomCountingLinesStream, RDF.type, PRIVVULN.TimeSeries))
g1.add((roomCountingLinesStream, PRIVVULNV2.TemporalResolution,
Literal("60", datatype=XSD.double)))
class CWS_Chilled_Water_Differential_Pressure_Setpoint(Chilled_Water_Differential_Pressure_Setpoint):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#').CWS_Chilled_Water_Differential_Pressure_Setpoint
class Medium_Temperature_Hot_Water_Differential_Pressure_Sensor(
Differential_Temperature_Sensor,
Hot_Water_Differential_Pressure_Sensor, Medium_Temperature_Hot_Water):
rdf_type = Namespace(
'https://brickschema.org/schema/1.0.2/Brick#'
).Medium_Temperature_Hot_Water_Differential_Pressure_Sensor
def __init__(self):
self.MODELS = Namespace(
'https://ontology.hviidnet.com/2020/01/03/privacyvunl-model.ttl#')
super().__init__(self.__DOMAINNAMESPACE__)
import random
from collections import OrderedDict
import pdb
from operator import itemgetter
import rdflib
from rdflib import Graph, URIRef, Literal, Namespace
from rdflib import RDF, RDFS
BASE = Namespace("http://brickschema.org/example#")
BRICK = Namespace("http://brickschema.org/schema/brick#")
BF= Namespace("http://brickschema.org/schema/brickframe#")
def gen_index(ref):
if ref:
return ref
else:
return str(random.randint(0,100))
with open("Berkeley_SodaHall_MetadataParseKey", "r") as fp:
building_dict = dict()
for line in fp:
line = line.replace(" ", "").replace("\t", "").replace("\n", "")
srcid, line = line.split("=>")
item_list = line.split(";")
item_dict = dict()
ref_dict = dict()
for item in item_list:
if item=="":
continue
key, val = item.split("->")
class Cooling_Max_Supply_Air_Flow_Setpoint(Supply_Air_Flow_Setpoint,Cooling_Discharge_Air_Flow_Setpoint):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#').Cooling_Max_Supply_Air_Flow_Setpoint
class Discharge_Air_Static_Pressure_Increase_Decrease_Step(
Discharge_Air_Static_Pressure):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#'
).Discharge_Air_Static_Pressure_Increase_Decrease_Step
class Hot_Water_Pump_VFD_Speed(Hot_Water_Pump):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#').Hot_Water_Pump_VFD_Speed
class Weather_Wind_Direction_Sensor(Wind_Direction_Sensor):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#'
).Weather_Wind_Direction_Sensor
'''
Created on 11/04/2011
@author: acalvo
'''
import rdflib
from rdflib import Graph, Namespace
from rdflib import plugin
FOAF = Namespace("http://xmlns.com/foaf/0.1/")
RDFS = Namespace("http://www.w3.org/2000/01/rdf-schema#")
if False:
plugin.register('sparql', rdflib.query.Processor,
'rdfextras.sparql.processor', 'Processor')
plugin.register('sparql', rdflib.query.Result, 'rdfextras.sparql.query',
'SPARQLQueryResult')
my_data = '''
@prefix dc: <http://purl.org/dc/elements/1.1/> .
@prefix : <http://example.org/book/> .
@prefix ns: <http://example.org/ns#> .
:book1 dc:title "SPARQL Tutorial" .
:book1 ns:price 42 .
:book2 dc:title "The Semantic Web" .
:book2 ns:price 23 .
'''
g = Graph()
g.parse(data=my_data, format="n3")
print g.serialize(format='xml')
class Return_Air_Preheat_Valve_Command(Preheat_Valve_Command,Return_Air):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#').Return_Air_Preheat_Valve_Command
# script to convert accessMessages.csv (OPAC messages) to json-ld
# requires libraries/plugins: rdflib, rdflib-jsonld
from rdflib.namespace import RDF, SKOS
from rdflib import Namespace, Graph, plugin
from rdflib.serializer import Serializer
import rdflib
import csv
f = open('../csv/accessMessages.csv')
reader = csv.DictReader(f)
nypl = Namespace('http://data.nypl.org/nypl-core/')
skos = Namespace('http://www.w3.org/2004/02/skos/core#')
# dcterms = Namespace('http://purl.org/dc/terms/')
nyplAccessMessage = rdflib.URIRef('http://data.nypl.org/accessMessages/')
g = Graph()
for r in reader:
id = r['skos:notation']
type = 'nypl:AccessMessage'
preflabel = rdflib.Literal(r['skos:prefLabel'])
altlabel = rdflib.Literal(r['skos:altLabel'])
notation = rdflib.Literal(r['skos:notation'])
# locationType = r['nypl:locationType'].split(';')
accessMessage = nyplAccessMessage + str(id)
g.add((accessMessage, RDF.type, nypl.AccessMessage))
g.add((accessMessage, SKOS.prefLabel, preflabel))
g.add((accessMessage, SKOS.altLabel, altlabel))
class On_Timer_Sensor(Timer_Sensor):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#').On_Timer_Sensor
__author__ = 'chimezieogbuji'
import sys
from FuXi.Syntax.InfixOWL import *
from FuXi.DLP import SkolemizeExistentialClasses, \
SKOLEMIZED_CLASS_NS, \
LloydToporTransformation, \
makeRule
from FuXi.Horn.HornRules import HornFromN3
from FuXi.Rete.RuleStore import SetupRuleStore
from FuXi.SPARQL.BackwardChainingStore import TopDownSPARQLEntailingStore
from rdflib.Graph import Graph
from cStringIO import StringIO
from rdflib import plugin, RDF, RDFS, OWL, URIRef, URIRef, Literal, Variable, BNode, Namespace
from FuXi.Horn.HornRules import HornFromN3
LIST_NS = Namespace('http://www.w3.org/2000/10/swap/list#')
KOR_NS = Namespace('http://korrekt.org/')
EX_NS = Namespace('http://example.com/')
EX_CL = ClassNamespaceFactory(EX_NS)
derivedPredicates = [
LIST_NS['in'], KOR_NS.subPropertyOf, RDFS.subClassOf, OWL.onProperty,
OWL.someValuesFrom
]
hybridPredicates = [RDFS.subClassOf, OWL.onProperty, OWL.someValuesFrom]
CONDITIONAL_THING_RULE=\
"""
@prefix kor: <http://korrekt.org/>.
@prefix owl: <http://www.w3.org/2002/07/owl#>.
parser = argparse.ArgumentParser()
parser.add_argument('-f', '--file')
args = parser.parse_args()
if args.file:
filename = args.file
else:
filename = input('Enter filename (including \'.csv\'): ')
dt = datetime.now().strftime('%Y-%m-%d_%H.%M.%S')
df_1 = pd.read_csv(filename, header=0)
fast_ids = df_1.fast_id.to_list()
skos = Namespace('http://www.w3.org/2004/02/skos/core#')
schema = Namespace('http://schema.org/')
rdfs = Namespace('http://www.w3.org/2000/01/rdf-schema#')
baseURL = 'http://id.worldcat.org/fast/'
ext = '.rdf.xml'
all_items = []
for fast_id in fast_ids:
g = Graph()
id = fast_id[3:].strip()
link = baseURL + id + ext
graph = g.parse(link, format='xml')
objects = graph.objects(subject=None, predicate=schema.sameAs)
tinyDict = {'fast_id': fast_id}
for object in objects:
label = graph.value(subject=object, predicate=rdfs.label)
class Discharge_Air_Temperature_Reset_Differential_Setpoint(Temperature_Differential_Reset_Setpoint,Discharge_Air_Temperature_Setpoint,Supply_Air_Temperature_Setpoint):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#').Discharge_Air_Temperature_Reset_Differential_Setpoint
from django.core.management.base import BaseCommand
from django.db import reset_queries
from rdflib import Namespace, ConjunctiveGraph, URIRef
try:
import simplejson as json
except ImportError:
import json
from core import models
from core.management.commands import configure_logging
configure_logging("openoni_link_places.config", "openoni_link_places.log")
_logger = logging.getLogger(__name__)
geo = Namespace('http://www.w3.org/2003/01/geo/wgs84_pos#')
owl = Namespace('http://www.w3.org/2002/07/owl#')
dbpedia = Namespace('http://dbpedia.org/ontology/')
class Command(BaseCommand):
def handle(self, **options):
_logger.debug("linking places")
for place in models.Place.objects.filter(dbpedia__isnull=True):
if not place.city or not place.state:
continue
# formulate a dbpedia place uri
path = urllib.parse.quote(
'%s,_%s' % (_clean(place.city), _clean(place.state)))
url = URIRef('http://dbpedia.org/resource/%s' % path)
def TripleMaker(file_dir):
'''
function takes a list of directories and for each directory parses the .nxml file and creates a graph
that is populated with specific triples using the parsed information. For each directory, a xml file is
created which contains the triples and has been serialized to turtle format.
:param file_dir: a list of directories
:return: nothing is returned
'''
g = Graph() # create graph to store triples
#add namespaces
ccp_ext = Namespace("http://ccp.ucdenver.edu/obo/ext/")
bibo = Namespace("http://purl.org/ontology/bibo/")
obo = Namespace("http://purl.obolibrary.org/obo/")
edam = Namespace("http://edamontology.org/")
swo = Namespace("http://www.ebi.ac.uk/swo/")
# iterate over folders within the input directory
for subdir, dirs, files in os.walk(file_dir):
for sub_file in files:
item = os.path.join(subdir, sub_file)
if item.endswith('.nxml.gz'):
c_inf = BibParser(item)
#create triples - article class
g.add((URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
RDFS.subClassOf, URIRef(str(obo) + 'IAO_0000311')))
g.add((URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
URIRef(str(bibo) + 'pmid'), Literal(str(c_inf[1]))))
g.add((URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
URIRef(str(ccp_ext) + 'BIBO_EXT_0000001'),
Literal('PMC' + str(c_inf[0]))))
g.add((URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
DCTERMS.title, Literal(str(c_inf[2]))))
g.add((URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
URIRef(str(bibo) + 'doi'), Literal(str(c_inf[3]))))
g.add((URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
DCTERMS.published, Literal(str(c_inf[4]))))
g.add((URIRef(
str(ccp_ext) + 'J_' +
base64.b64encode(hashlib.sha1(str(c_inf[5])).digest())),
DCTERMS.title, Literal(str(c_inf[5]))))
g.add((URIRef(
str(ccp_ext) + 'J_' +
base64.b64encode(hashlib.sha1(str(c_inf[5])).digest())),
RDF.type, URIRef(str(bibo) + 'Journal')))
g.add((
URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
URIRef(str(obo) + 'BFO_0000050'),
URIRef(
str(ccp_ext) + 'J_' +
base64.b64encode(hashlib.sha1(str(c_inf[5])).digest()))
))
for author in c_inf[6]:
a_hash = base64.b64encode(
hashlib.sha1(str(author[1]) + str(author[0])).digest())
g.add((URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0])),
DCTERMS.creator,
URIRef(str(ccp_ext) + 'A_' + str(a_hash))))
g.add((URIRef(str(ccp_ext) + 'A_' + str(a_hash)), RDF.type,
FOAF.person))
g.add((URIRef(str(ccp_ext) + 'A_' + str(a_hash)),
FOAF.familyName, Literal(str(author[0]))))
g.add((URIRef(str(ccp_ext) + 'A_' + str(a_hash)),
FOAF.givenName, Literal(str(author[1]))))
#create triples - article instances
format_conversion_uri = base64.b64encode(
hashlib.sha1(
str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_XML' +
str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) +
'_TXT').digest())
g.add(
(URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_XML'),
RDF.type,
URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]))))
g.add(
(URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_TXT'),
RDF.type,
URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]))))
g.add(
(URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_XML'),
URIRef(str(swo) + 'SWO_0004002'),
URIRef(str(edam) + 'format_2332')))
g.add(
(URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_XML'),
URIRef(str(swo) + 'SWO_0000046'),
Literal(
str('/'.join(item.split('/')[:-1])) + '/PMC' +
str(c_inf[0]) + '.nxml.gz')))
g.add(
(URIRef(str(ccp_ext) + 'FC_' + str(format_conversion_uri)),
URIRef(str(swo) + 'SWO_0000086'),
URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_XML')))
g.add(
(URIRef(str(ccp_ext) + 'FC_' + str(format_conversion_uri)),
RDF.type, URIRef(str(edam) + 'operation_0335')))
g.add(
(URIRef(str(ccp_ext) + 'FC_' + str(format_conversion_uri)),
URIRef(str(swo) + 'SWO_0000087'),
URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_TXT')))
g.add(
(URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_TXT'),
URIRef(str(swo) + 'SWO_0004002'),
URIRef(str(swo) + 'SWO_3000043')))
g.add(
(URIRef(str(ccp_ext) + 'P_PMC_' + str(c_inf[0]) + '_TXT'),
URIRef(str(swo) + 'SWO_0000046'),
Literal(
str('/'.join(item.split('/')[:-1])) + '/PMC' +
str(c_inf[0]) + '.nxml.gz.txt.gz')))
file_name = file_dir.split('/')[-1]
out = str('/'.join(file_dir.split('/')[:-2])) + '/metadata_triples'
g.serialize(destination=str(out) + '/PMC_metadata_' + str(file_name) +
'.ttl',
format='turtle')
print 'Completed ' + str(file_dir)
class FCU_Discharge_Air_Temperature_Sensor(Discharge_Air_Temperature_Sensor,
Supply_Air_Temperature_Sensor):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#'
).FCU_Discharge_Air_Temperature_Sensor
def sparql_search():
street = request.form.get("street")
postalCode = request.form.get("postalCode")
#We have to separate the latitude and the longitude
if street:
latitude = str(street).split(',')[0]
longitude = str(street).split(',')[1]
else:
geolocator = Nominatim(user_agent="Geoparking")
location_user = geolocator.geocode({"postalcode": postalCode})
latitude, longitude = location_user.latitude, location_user.longitude
actual_dist = -1
parking = ''
totalslots = -1
addressid = ''
schedule = ''
province = ''
city = ''
district = ''
neighborhood = ''
wikistreet = ''
wikiprovince = ''
wikicity = ''
wikidistrict = ''
wikineighborhood = ''
image = ''
g = Graph()
github_storage = "https://raw.githubusercontent.com/adrix1341/Curso2020-2021/master/HandsOn/Group02/rdf/output" \
"-with-links.nt "
g.parse(github_storage, format="nt")
findparking = Namespace("http://findyourparking.es/lcc/ontology/Parking#")
owl = Namespace("http://www.w3.org/2002/07/owl#")
wikidata = Namespace("http://www.wikidata.org/prop/direct/")
q1 = prepareQuery('''
SELECT DISTINCT ?x ?parkname ?y ?street ?lat ?lon ?totalslots ?addressid ?schedule ?wikistreet ?province ?city ?district ?neighborhood ?wikiprovince ?wikicity ?wikidistrict ?wikineighborhood
WHERE {
?x rdf:type findparking:Parking.
?x findparking:hasName ?parkname.
?x findparking:hasTotalSlots ?totalslots.
?x findparking:hasSchedule ?schedule.
?y rdf:type findparking:Address.
?x findparking:hasProvince ?p.
?x findparking:hasCity ?c.
?x findparking:hasDistrict ?d.
?x findparking:hasNeighborhood ?n.
?p findparking:hasProvince ?province.
?p owl:sameAs ?wikiprovince.
?c owl:sameAs ?wikicity.
?d owl:sameAs ?wikidistrict.
?n owl:sameAs ?wikineighborhood.
?c findparking:hasCity ?city.
?d findparking:hasDistrict ?district.
?n findparking:hasNeighborhood ?neighborhood.
?x findparking:hasAddress ?y.
?y findparking:hasAddressId ?addressid.
?y findparking:hasStreet ?street.
?y owl:sameAs ?wikistreet.
?x findparking:hasLatitude ?lat.
?x findparking:hasLongitude ?lon
}
ORDER BY ASC(?street)
''',
initNs={
"findparking": findparking,
"rdf": RDF,
"owl": owl,
"wikidata": wikidata
})
for st in g.query(q1):
parkini, streeti, latitudi, longitudi, totalsloti, addressidi, scheduli = st.parkname, st.street, st.lat, st.lon, st.totalslots, st.addressid, st.schedule
wikistreeti, wikiprovinci, wikiciti, wikidistricti, wikineighborhoodi = st.wikistreet, st.wikiprovince, st.wikicity, st.wikidistrict, st.wikineighborhood
provinci, citi, districti, neighborhoodi = st.province, st.city, st.district, st.neighborhood
coordlist = [latitudi, longitudi]
if street:
km = return_distance(latitude, longitude, tuple(coordlist))
else:
auxList = [location_user.latitude, location_user.longitude]
km = geodesic(tuple(auxList), tuple(coordlist)).kilometers
if actual_dist == -1:
actual_dist = km
parking = parkini
park_street = streeti
totalslots = totalsloti
addressid = addressidi
schedule = scheduli
province = provinci
city = citi
district = districti
neighborhood = neighborhoodi
wikistreet = wikistreeti
wikiprovince = wikiprovinci
wikicity = wikiciti
wikidistrict = wikidistricti
wikineighborhood = wikineighborhoodi
pk_lat = latitudi
pk_long = longitudi
elif km < actual_dist:
actual_dist = km
parking = parkini
park_street = streeti
totalslots = totalsloti
addressid = addressidi
schedule = scheduli
province = provinci
city = citi
district = districti
neighborhood = neighborhoodi
wikistreet = wikistreeti
wikiprovince = wikiprovinci
wikicity = wikiciti
wikidistrict = wikidistricti
wikineighborhood = wikineighborhoodi
pk_lat = latitudi
pk_long = longitudi
wd = Namespace("https://www.wikidata.org/wiki#")
wiki1 = wikistreet.split('Q')[1]
wiki1 = 'Q' + wiki1
query2 = str('''
PREFIX wikidata: <http://www.wikidata.org/prop/direct/>
SELECT DISTINCT ?image
WHERE {
wd:''' + wiki1 + ''' wikidata:P18 ?image
}
''')
endpoint_url = "https://query.wikidata.org/sparql"
def get_results(endpoint_url, query2):
user_agent = "WDQS-example Python/%s.%s" % (sys.version_info[0],
sys.version_info[1])
# TODO adjust user agent; see https://w.wiki/CX6
sparql = SPARQLWrapper(endpoint_url, agent=user_agent)
sparql.setQuery(query2)
sparql.setReturnFormat(JSON)
return sparql.query().convert()
results = get_results(endpoint_url, query2)
imaget = ''
for result in results["results"]["bindings"]:
imaget = str(result)
# Splitting the object to obtain only the link
imaget = imaget.split('h')[1] + 'h' + imaget.split('h')[2]
imaget = 'h' + imaget #Inserting the h for http://
imaget = imaget.split("'")[0]
map = folium.Map(location=[pk_lat, pk_long], zoom_start=12)
folium.Marker(
location=[pk_lat, pk_long],
popup=("Your nearest parking is: " + '<b>' + parking + '</b>' +
", at " + str(actual_dist) + " km from your current position." +
'<br>' + '<b>Parking Info:</b>' + '<br>' + " -Address: " +
' <a href=' + wikistreet + '>' + addressid + '</a>' + '<br>' +
" -Province: " + '<a href=' + wikiprovince + '>' + province +
'</a><br>' + " -City: " + ' <a href=' + wikicity + '>' + city +
'</a>' + '<br>' + " -District: " + ' <a href=' + wikidistrict +
'>' + district + '</a>' + '<br>' + " -Neighborhood: " +
' <a href=' + wikineighborhood + '>' + neighborhood + '</a>' +
'<br>' + " -TotalSlots: " + totalslots + '<br>' +
" -Schedule: " + schedule + '<br>' +
'<style>img{width: 100%;height: auto;}</style>' + '<img src=' +
imaget + ' alt="Image of the parking street"' + '></img'),
tooltip="Click here for more info.",
icon=folium.Icon(color='red', icon='star')).add_to(map)
folium.Marker(location=[latitude, longitude],
popup="<b>You are here.</b>",
tooltip="Click Here!").add_to(map)
return map._repr_html_()
import sys
def addANode(graph, subject, object):
subjectURI = URIRef(DBfN[subject])
objectURI = URIRef(DBfN[object])
if (subjectURI, RDFS.subClassOf, objectURI) in graph:
print subject, "already added"
else:
graph.add((subjectURI, RDF.type, OWL.Class))
graph.add((subjectURI, RDFS.subClassOf, objectURI))
graph.add((subjectURI, RDFS.label, Literal(subject)))
graph.add((subjectURI, RDFS.comment, Literal(subject)))
DBfN = Namespace(
"http://maven.renci.org/ontologies/databridgeforneuroscience/")
graph = Graph()
#Clinical = URIRef("Clinical")
graph.add((DBfN.Clinical, RDF.type, OWL.Class))
graph.add((DBfN.Clinical, RDFS.subClassOf, OWL.Thing))
graph.add((DBfN.Clinical, RDFS.label, Literal("Clinical")))
graph.add((DBfN.Clinical, RDFS.comment, Literal("Highest level of ontology")))
workbook = sys.argv[1]
outFile = sys.argv[2]
lastRow = int(sys.argv[3])
sheet = sys.argv[4]
wb = open_workbook(workbook)
for s in wb.sheets():
# if (s.name == 'SCZ Clin Model Groups'):
if (s.name == sheet):
class Power_System_Power_Meter(Power_Meter):
rdf_type = Namespace('https://brickschema.org/schema/1.0.2/Brick#').Power_System_Power_Meter
from jsonpath_ng import jsonpath, parse
import json
from urllib.parse import urlparse
from rdflib import Graph, Literal, RDF, URIRef, Namespace, BNode
from rdflib.namespace import RDF, RDFS, XSD, DC, DCTERMS, FOAF
import dateutil.parser
import hashlib
from requests.utils import requote_uri
from cpe import CPE
CORE = Namespace("http://ontologies.ti-semantics.com/core#")
CTI = Namespace("http://ontologies.ti-semantics.com/cti#")
PLATFORM = Namespace("http://ontologies.ti-semantics.com/platform#")
SCORE = Namespace("http://ontologies.ti-semantics.com/score#")
VULN = Namespace("http://ontologies.ti-semantics.com/vulnerability#")
NVD = Namespace("https://nvd.nist.gov/feeds/json/cve/1.1/nvdcve-1.1-2020/")
REFS = Namespace("https://csrc.nist.gov/publications/references/")
CPEMATCH = Namespace("https://csrc.nist.gov/schema/cpematch/feed/1.0/")
def all(q, o, fn=None):
a = [m.value for m in parse(q).find(o)]
if fn:
for i in a:
fn(i)
else:
return a
def allDateTime(p, q, o):
return [(p, Literal(dt, datatype=XSD.dateTime)) for dt in all(q, o)]
#
# Resources:
#
# - http://spdx.org/about-spdx/faqs
# - http://wiki.spdx.org/view/Technical_Team/Best_Practices
#
import os
import sys
import re
import datetime
import sha
import rdflib
from rdflib import URIRef, BNode, Literal, Namespace
RDF = Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
RDFS = Namespace('http://www.w3.org/2000/01/rdf-schema#')
XSD = Namespace('http://www.w3.org/2001/XMLSchema#')
SPDX = Namespace('http://spdx.org/rdf/terms#')
DOAP = Namespace('http://usefulinc.com/ns/doap#')
DUKTAPE = Namespace('http://duktape.org/rdf/terms#')
def checksumFile(g, filename):
f = open(filename, 'rb')
d = f.read()
f.close()
shasum = sha.sha(d).digest().encode('hex').lower()
csum_node = BNode()
g.add((csum_node, RDF.type, SPDX.Checksum))
g.add((csum_node, SPDX.algorithm, SPDX.checksumAlgorithm_sha1))
