def toElement(self):
to_ret = Element("skiros:Parameter", self._key)
to_ret.setProperty("rdfs:comment", self._description)
to_ret.setProperty("skiros:ParameterType", self._param_type.value - 1)
if (not self.dataTypeIs(Element)):
to_ret.setProperty("skiros:DataType", self._data_type)
if self.hasSpecifiedDefault():
to_ret.setProperty("skiros:Default", self._default)
if self.isSpecified():
to_ret.setProperty("skiros:Value", self._values)
else:
to_ret.setProperty("skiros:DataType", self._default[0]._type)
if self.isSpecified():
for v in self._values:
if v._id != "":
to_ret.addRelation("-1", "skiros:hasValue", v._id)
return to_ret
def get_individual(self, name, context_id=""):
"""
@brief Builds an element from an individual
@param context_id if defined look for the individual only in the context
"""
subject = self.lightstring2uri(name)
if not self.uri_exists(subject, context_id):
raise Exception(
"Element {} doesn't exist in ontology. Uri: {}. Context: {}.".
format(name, subject, context_id))
e = Element()
for predicate, obj in self.ontology(context_id).predicate_objects(
subject):
if OWL.DatatypeProperty in self.ontology().objects(
predicate, RDF.type) or predicate == RDFS.comment:
e.setProperty(self.uri2lightstring(predicate),
obj.value,
self.uri2lightstring(obj.datatype),
force_convertion=True)
elif OWL.ObjectProperty in self.ontology().objects(
predicate, RDF.type):
e.addRelation("-1", self.uri2lightstring(predicate),
self.uri2lightstring(obj))
elif predicate == RDF.type and obj != OWL.NamedIndividual:
e._type = self.uri2lightstring(str(obj))
elif obj == OWL.NamedIndividual:
pass
elif predicate == RDFS.label:
e._label = obj.value
else:
log.error(
"[get_individual]",
"Ignoring {}-{}-{}. Predicate is not defined in the ontology."
.format(name, self.uri2lightstring(predicate),
self.uri2lightstring(obj)))
for subj, predicate in self.ontology(context_id).subject_predicates(
subject):
if (self.uri2lightstring(predicate) != "skiros:hasTemplate"):
e.addRelation(self.uri2lightstring(subj),
self.uri2lightstring(predicate), "-1")
self._add_reasoners_prop(e)
return e
def toElement(self):
to_ret = Element(self._type)
to_ret._label = self._label
for _, p in self.params.items():
if p.dataTypeIs(Element):
to_ret.addRelation(self, "skiros:hasParam", p.toElement())
for c in self._pre_conditions:
to_ret.addRelation(self, "skiros:hasPreCondition", c.toElement())
for c in self._hold_conditions:
to_ret.addRelation(self, "skiros:hasHoldCondition", c.toElement())
for c in self._post_conditions:
to_ret.addRelation(self, "skiros:hasPostCondition", c.toElement())
return to_ret
class TestWorldElement(unittest.TestCase):
def setUp(self):
self.e = Element()
def test_element(self):
e = Element()
e.setProperty("Hello", float)
e.setProperty("Hello", 0.0)
self.assertEqual(e.getProperty("Hello").value, 0.0)
e.getProperty("Hello").values = 1.0
self.assertEqual(e.getProperty("Hello").values, [1.0])
e.getProperty("Hello").value = 2.0
self.assertEqual(e.getProperty("Hello").values, [2.0])
def test_getIdNumber(self):
msg = """
getIdNumber should return -1 if element has no specified id"""
self.assertEqual(-1, self.e.getIdNumber(), msg)
msg = """
getIdNumber should return the elements specified id"""
self.e.setUri(4)
self.assertEqual(4, self.e.getIdNumber(), msg)
def test_getRelations(self):
relations_list = [["1", "pred1", "2"], ["-1", "pred2", "3"]]
self.e.addRelation(*relations_list[0])
self.e.addRelation(*relations_list[1])
msg = """
getRelations with no argument should return all relations"""
expected = self._relationsDefault(relations_list)
self.assertEqual(expected, self.e.getRelations(), msg)
msg = """
getRelations should return a list of relations matching subj
pred and obj"""
expected = self._relationsDefault(relations_list[:1])
result = self.e.getRelations(*relations_list[0])
self.assertEqual(expected, result, msg)
def test_setRelation(self):
relations_list = [["-1", "pred", "2"], ["1", "pred", "2"],
["-1", "pred", "3"]]
self.e.addRelation(*relations_list[0])
self.e.addRelation(*relations_list[1])
self.e.setRelation(*relations_list[2])
msg = """
When subj or obj are -1 setRelation should only overwrite
previous relations which also have subj or obj as -1 and
the same predicate"""
expected = self._relationsDefault(relations_list[1:])
self.assertEqual(expected, self.e.getRelations(), msg)
msg = """
setRelation should overwrite previous relations with same
predicate when subj or obj are not -1"""
self.e.setRelation("1", "pred", "2")
expected = [self._relationDefault("1", "pred", "2")]
self.assertEqual(expected, self.e.getRelations(), msg)
def test_addRelation(self):
msg = """
addRelation should have no effect if relation is already
added"""
relations_list = [["1", "pred", "2"], [u"2", "pred", u"3"]]
self.e.addRelation(*relations_list[0])
self.e.addRelation(*relations_list[0])
expected = self._relationsDefault(relations_list[:1])
self.assertEqual(expected, self.e.getRelations(), msg)
# test pyhton 2 compatibility
msg = """
addRelation should add the relation if subj and obj are unicode
strings"""
self.e.addRelation(*relations_list[1])
expected = self._relationsDefault(relations_list)
self.assertEqual(expected, self.e.getRelations())
def test_hasProperty(self):
e = Element()
e.setProperty("Integer", "2", "xsd:int")
self.assertEqual(False, e.hasProperty("NonExistingKey"))
self.assertEqual(False, e.hasProperty("Integer", 1))
self.assertEqual(True, e.hasProperty("Integer", 2))
self.assertEqual(True, e.hasProperty("Integer"))
e.setProperty("Type", int)
self.assertEqual(False, e.hasProperty("Type", not_none=True))
def test_setProperty(self):
e = Element()
e.setProperty("Integer", 1)
self.assertEqual([1], e.getProperty("Integer").values)
msg = """
setProperty should convert when setting the property if
force_convertion is true"""
e.setProperty("Integer", "2", force_convertion=True)
self.assertEqual([2], e.getProperty("Integer").values, msg)
msg = """
setProperty should convert when setting the property if
value is a list and if force_convertion is true"""
e.setProperty("Integer", ["1", "2"], force_convertion=True)
self.assertEqual([1, 2], e.getProperty("Integer").values, msg)
msg = """
setProperty should convert unicode values to str before
creating new property"""
e.setProperty("strKey", u"a")
self.assertEqual(str, type(e.getProperty("strKey").value), msg)
msg = """
setProperty should convert unicode values to str when setting
the property"""
e.setProperty("strKey", u"b")
self.assertEqual(["b"], e.getProperty("strKey").values, msg)
def test_appendProperty(self):
e = Element()
e.setProperty("Integer", 2, "xsd:int")
self.assertEqual(2, e.getProperty("Integer").value)
e.appendProperty("Integer", 3)
self.assertEqual([2, 3], e.getProperty("Integer").values)
def _hasRelations(self, element, relation_arg_list):
for r in relation_arg_list:
if not element.hasRelation(*r):
return False
return True
# return a relation with state and abstract set to their default values
def _relationDefault(self, subj, pred, obj):
return {
'src': subj,
'dst': obj,
'type': pred,
'state': True,
'abstract': False
}
# return a list of relations with state and abstract set to their
# default values
def _relationsDefault(self, relation_arg_list):
return [self._relationDefault(*r) for r in relation_arg_list]
