def test_rdfs_inference_subclass():
EX = Namespace("http://example.com/building#")
graph = Graph(load_brick=True).from_triples([(EX["a"], RDF.type,
BRICK.Temperature_Sensor)])
graph.expand(profile="rdfs")
res1 = graph.query(f"""SELECT ?type WHERE {{
<{EX["a"]}> rdf:type ?type
}}""")
expected = [
BRICK.Point,
BRICK.Class,
BRICK.Sensor,
RDFS.Resource,
BRICK.Temperature_Sensor,
]
# filter out BNodes
res = []
for row in res1:
row = tuple(filter(lambda x: not isinstance(x, BNode), row))
res.append(row)
res = list(filter(lambda x: len(x) > 0, res))
assert len(res) == len(expected), f"Results were {res}"
for expected_class in expected:
assert (
expected_class, ) in res, f"{expected_class} not found in {res}"
def __init__(self, folder, dbfile, limit):
if not os.path.exists(dbfile) or dbfile == ':memory:':
ttlfiles = glob.glob(f"{folder}/*.ttl")
csvfiles = glob.glob(f"{folder}/*/*.csv")
conn = sqlite3.connect(dbfile)
conn.row_factory = sqlite3.Row
for stmt in schema.split(';'):
stmt += ';'
conn.execute(stmt)
conn.commit()
# load in ttl
g = Graph()
bind_prefixes(g)
for ttl in ttlfiles:
print(f"Loading TTL file {ttl}")
g.load_file(ttl)
# values = list(map(tuple, g))
# conn.executemany("""INSERT OR IGNORE INTO triples(subject, predicate, object) \
# VALUES(?, ?, ?)""", values)
# conn.commit()
g = BrickInferenceSession().expand(g)
triples = list(g.g)
conn.executemany(
"""INSERT OR IGNORE INTO triples(subject, predicate, object) \
VALUES(?, ?, ?)""", triples)
conn.commit()
# load in data
for csvf in sorted(csvfiles)[:limit]:
print(f"Loading CSV file {csvf}")
rows = csv2rows(csvf)
#with open(csvf) as f:
# rdr = csv.reader(f)
# next(rdr) # consume header
# vals = list(rdr)
conn.executemany(
"""INSERT OR IGNORE INTO data(timestamp, uuid, value) \
VALUES(?, ?, ?)""", rows)
conn.commit()
else:
conn = sqlite3.connect(dbfile)
conn.row_factory = sqlite3.Row
# load in ttl
g = Graph()
bind_prefixes(g)
triples = conn.execute(
"SELECT subject, predicate, object FROM triples")
for t in triples:
t = (
parse_uri(t[0]),
parse_uri(t[1]),
parse_uri(t[2]),
)
g.add(t)
self.g = g
self.conn = conn
def test_haystack_inference():
data = pkgutil.get_data(__name__, "data/carytown.json").decode()
raw_model = json.loads(data)
brick_model = Graph(load_brick=True).from_haystack(
"http://example.org/carytown", raw_model)
points = brick_model.query("""SELECT ?p WHERE {
?p rdf:type/rdfs:subClassOf* brick:Point
}""")
assert len(points) == 17
equips = brick_model.query("""SELECT ?e WHERE {
?e rdf:type/rdfs:subClassOf* brick:Equipment
}""")
assert len(equips) == 4
def test_tagset_inference():
g = Graph(load_brick=False)
data = pkgutil.get_data(__name__, "data/tags.ttl").decode()
g.load_file(source=io.StringIO(data))
g.expand(profile="tag")
afs1 = g.query("SELECT ?x WHERE { ?x rdf:type brick:Air_Flow_Sensor }")
assert len(afs1) == 1
afsp1 = g.query("SELECT ?x WHERE { ?x rdf:type brick:Air_Flow_Setpoint }")
assert len(afsp1) == 1
mafs1 = g.query(
"SELECT ?x WHERE { ?x rdf:type brick:Max_Air_Flow_Setpoint_Limit }")
assert len(mafs1) == 1
def test_brick_inference():
session = BrickInferenceSession()
assert session is not None
g = Graph(load_brick=True)
data = pkgutil.get_data(__name__, "data/brick_inference_test.ttl").decode()
g.load_file(source=io.StringIO(data))
g = session.expand(g)
r = g.query("SELECT ?x WHERE { ?x rdf:type brick:Air_Temperature_Sensor }")
# assert len(r) == 5
urls = set([str(row[0]) for row in r])
real_sensors = set([
"http://example.com/mybuilding#sensor1",
"http://example.com/mybuilding#sensor2",
"http://example.com/mybuilding#sensor3",
"http://example.com/mybuilding#sensor4",
"http://example.com/mybuilding#sensor5",
])
assert urls == real_sensors
def test_brick_to_vbis_inference_with_owlrl():
ALIGN = Namespace("https://brickschema.org/schema/Brick/alignments/vbis#")
# input brick model; instances should have appropriate VBIS tags
g = Graph(load_brick=True)
data = pkgutil.get_data(__name__, "data/vbis_inference_test.ttl").decode()
g.load_file(source=io.StringIO(data))
g.expand(profile="owlrl")
g.expand(profile="vbis")
test_cases = [
("http://bldg#f1", "ME-Fa"),
("http://bldg#rtu1", "ME-ACU"),
]
for (entity, vbistag) in test_cases:
query = f"SELECT ?tag WHERE {{ <{entity}> <{ALIGN.hasVBISTag}> ?tag }}"
res = list(g.query(query))
assert len(res) == 1
assert str(res[0][0]) == vbistag
conforms, _, results = g.validate()
assert conforms, results
def test_brick_inference():
g = Graph(load_brick=True)
g.load_extension("shacl_tag_inference")
data = pkgutil.get_data(__name__, "data/brick_inference_test.ttl").decode()
g.load_file(source=io.StringIO(data))
g.expand(profile="owlrl+shacl+owlrl+shacl")
r = g.query("SELECT ?x WHERE { ?x rdf:type brick:Air_Temperature_Sensor }")
# assert len(r) == 5
urls = set([str(row[0]) for row in r])
real_sensors = set([
"http://example.com/mybuilding#sensor1",
"http://example.com/mybuilding#sensor2",
"http://example.com/mybuilding#sensor3",
"http://example.com/mybuilding#sensor4",
"http://example.com/mybuilding#sensor5",
])
assert urls == real_sensors
def test_orm():
g = Graph(load_brick=True)
data = pkgutil.get_data(__name__, "data/test.ttl").decode()
g.load_file(source=io.StringIO(data))
orm = SQLORM(g, connection_string="sqlite:///:memory:")
equips = orm.session.query(Equipment).all()
assert len(equips) == 5
points = orm.session.query(Point).all()
assert len(points) == 3
locs = orm.session.query(Location).all()
assert len(locs) == 4
hvac_zones = (
orm.session.query(Location).filter(Location.type == BRICK.HVAC_Zone).all()
)
assert len(hvac_zones) == 1
# test relationships
BLDG = Namespace("http://example.com/mybuilding#")
vav2_4 = orm.session.query(Equipment).filter(Equipment.name == BLDG["VAV2-4"]).one()
assert vav2_4.type == str(BRICK.Variable_Air_Volume_Box)
assert len(vav2_4.points) == 2
vav2_4_dpr = (
orm.session.query(Equipment).filter(Equipment.name == BLDG["VAV2-4.DPR"]).one()
)
assert vav2_4_dpr.type == str(BRICK.Damper)
assert len(vav2_4_dpr.points) == 1
tstat = orm.session.query(Equipment).filter(Equipment.name == BLDG["tstat1"]).one()
room_410 = (
orm.session.query(Location).filter(Location.name == BLDG["Room-410"]).one()
)
assert tstat.location == room_410
assert tstat in room_410.equipment
def test_tagset_inference():
session = TagInferenceSession(approximate=False)
assert session is not None
g = Graph(load_brick=False)
data = pkgutil.get_data(__name__, "data/tags.ttl").decode()
g.load_file(source=io.StringIO(data))
g = session.expand(g)
afs1 = g.query("SELECT ?x WHERE { ?x rdf:type brick:Air_Flow_Sensor }")
assert len(afs1) == 1
afsp1 = g.query("SELECT ?x WHERE { ?x rdf:type brick:Air_Flow_Setpoint }")
assert len(afsp1) == 1
mafs1 = g.query(
"SELECT ?x WHERE { ?x rdf:type brick:Max_Air_Flow_Setpoint_Limit }")
assert len(mafs1) == 1
def test_owl_inference_tags():
EX = Namespace("http://example.com/building#")
graph = Graph(load_brick=True).from_triples([(EX["a"], RDF.type,
BRICK.Air_Flow_Setpoint)])
graph.expand(profile="owlrl", backend="owlrl")
res1 = graph.query(f"""SELECT ?type WHERE {{
<{EX["a"]}> rdf:type ?type
}}""")
expected = [
# RDF.Resource,
# RDFS.Resource,
OWL.Thing,
BRICK.Point,
BRICK.Class,
BRICK.Setpoint,
BRICK.Flow_Setpoint,
BRICK.Air_Flow_Setpoint,
]
# filter out BNodes
res1 = filter_bnodes(res1)
assert set(res1) == set(map(lambda x: (x, ), expected))
res2 = graph.query(f"""SELECT ?tag WHERE {{
<{EX["a"]}> brick:hasTag ?tag
}}""")
expected = [
TAG.Point,
TAG.Air,
TAG.Flow,
TAG.Setpoint,
]
res2 = filter_bnodes(res2)
assert set(res2) == set(map(lambda x: (x, ), expected))
def graph_from_triples(triples):
g = Graph(load_brick=True)
# g.load_file("ttl/owl.ttl")
g.add(*triples)
sess = OWLRLAllegroInferenceSession()
return sess.expand(g)
from brickschema.graph import Graph
from brickschema.inference import BrickInferenceSession
from rdflib import Literal, URIRef
from .namespaces import SKOS, OWL, RDFS, BRICK, QUDTQK, QUDTDV, QUDT, UNIT
g = Graph()
g.load_file("support/VOCAB_QUDT-QUANTITY-KINDS-ALL-v2.1.ttl")
g.load_file("support/VOCAB_QUDT-UNITS-ALL-v2.1.ttl")
g.g.bind("qudt", QUDT)
g.g.bind("qudtqk", QUDTQK)
sess = BrickInferenceSession()
g = sess.expand(g)
def get_units(brick_quantity):
"""
Fetches the QUDT unit and symbol (as a Literal) from the QUDT ontology so
in order to avoid having to pull the full QUDT ontology into Brick
"""
res = g.query(
f"""SELECT ?unit ?symbol WHERE {{
<{brick_quantity}> qudt:applicableUnit ?unit .
?unit qudt:symbol ?symbol .
FILTER(isLiteral(?symbol))
}}"""
)
for r in res:
yield r
from brickschema.graph import Graph
from rdflib import Literal, URIRef
from .namespaces import SKOS, OWL, RDFS, BRICK, QUDTQK, QUDTDV, QUDT, UNIT
g = Graph()
g.load_file("support/VOCAB_QUDT-QUANTITY-KINDS-ALL-v2.1.ttl")
g.load_file("support/VOCAB_QUDT-UNITS-ALL-v2.1.ttl")
g.bind("qudt", QUDT)
g.bind("qudtqk", QUDTQK)
g.expand(profile="brick")
def get_units(brick_quantity):
"""
Fetches the QUDT unit and symbol (as a Literal) from the QUDT ontology so
in order to avoid having to pull the full QUDT ontology into Brick
"""
res = g.query(
f"""SELECT ?unit ?symbol WHERE {{
<{brick_quantity}> qudt:applicableUnit ?unit .
?unit qudt:symbol ?symbol .
FILTER(isLiteral(?symbol))
}}"""
)
for r in res:
yield r
"""
Each is a qudt:QuantityKind
def test_simplify():
g = Graph(load_brick=True)
data = pkgutil.get_data(__name__, "data/test.ttl").decode()
g.load_file(source=io.StringIO(data))
g.expand("brick", simplify=False, backend="owlrl")
g.serialize("/tmp/test.ttl", format="ttl")
q = "SELECT ?type WHERE { bldg:VAV2-4.ZN_T a ?type }"
rows = list(g.query(q))
bnodes = [r[0] for r in rows if isinstance(r[0], rdflib.BNode)]
assert len(bnodes) > 0
g.simplify()
rows = list(g.query(q))
bnodes = [r[0] for r in rows if isinstance(r[0], rdflib.BNode)]
assert len(bnodes) == 0
