def __call__(self, source, edge, target):
if edge.type() is Item.EquivalenceEdge:
# Similarily as for the Inclusion edge, here we deny the equivalence in presence
# of an intersection or a complement node, since it express a double inclusion and
# we'll violate the constraint imposed by the rule here below.
if not {Identity.Role, Identity.Attribute, Identity.Unknown} & {
source.identity(), target.identity()
}:
for node in (source, target):
if node.type() is Item.IntersectionNode:
raise ProfileError(
'Equivalence in presence of concepts intersection is forbidden in OWL 2 QL'
)
if node.type() is Item.ComplementNode:
raise ProfileError(
'Equivalence in presence of concept complement is forbidden in OWL 2 QL'
)
if node.type() in {
Item.DomainRestrictionNode,
Item.RangeRestrictionNode
}:
if node.isRestrictionQualified():
raise ProfileError(
'Equivalence in presence of qualified {} is forbidden in OWL 2 QL'
.format(node.shortName))
def __call__(self, source, edge, target):
if edge.type() is Item.InputEdge:
if target.type() in {
Item.DomainRestrictionNode, Item.RangeRestrictionNode
}:
# OWL 2 QL admits only atomic concepts for role qualified restriction.
if source.identity() is Identity.Concept:
if source.type() is not Item.ConceptIRINode:
raise ProfileError(
'OWL 2 QL admits only an atomic concept as filler for a qualified {}'
.format(target.shortName))
# Given the fact that we are connecting an atomic concept in input to this
# restriction node, we need to see if the node is currently being used
# as source for a concept expression inclusion, and if so, deny the connection
# because OWL 2 QL admits concept inclusion sourcing only from unqualified role
# restrictions (we need to skip TOP though, since it won't be qualified then).
if source.iri and not (source.iri.isOwlThing()
or source.iri.isTopObjectProperty()
or source.iri.isTopDataProperty()):
# We found an outgoing inclusion edge and our restriction filler is not TOP.
if target.outgoingNodes(filter_on_edges=lambda x: x.
type() is Item.InclusionEdge):
raise ProfileError(
'Inclusion with a qualified {} as source is forbidden in OWL 2 QL'
.format(target.shortName))
# Similarly we block the input in case of equivalence edges attached to the restriction node.
if target.adjacentNodes(
filter_on_edges=lambda x: x.type(
) is Item.EquivalenceEdge):
raise ProfileError(
'Equivalence in presence of qualified {} is forbidden in OWL 2 QL'
.format(target.shortName))
def __call__(self, source, edge, target):
if edge.type() is Item.InclusionEdge:
# We need to prevent inclusions sourcing from Complement nodes and Intersection nodes.
# Value-Domain inclusions are already forbidden by OWL 2 rules, and Attribute and Role
# inclusions, with a complement node as enpoint, are already handled in an OWL 2 rule.
# So here we just consider the case where we are connecting endpoints that either both
# Neutral, or at least one of the 2 is identified as a Concept expression.
if not {Identity.Role, Identity.Attribute, Identity.Unknown} & {
source.identity(), target.identity()
}:
if source.type() is Item.IntersectionNode:
raise ProfileError(
'Inclusion with an intersection of concept expressions as source is forbidden in OWL 2 QL'
)
if source.type() is Item.ComplementNode:
raise ProfileError(
'Inclusion with a concept complement as source is forbidden in OWL 2 QL'
)
if source.type() in {
Item.DomainRestrictionNode, Item.RangeRestrictionNode
}:
if source.isRestrictionQualified():
raise ProfileError(
'Inclusion with a qualified {} as source is forbidden in OWL 2 QL'
.format(source.shortName))
def __call__(self, node):
if isinstance(node, OntologyEntityNode) or isinstance(
node, OntologyEntityResizableNode):
if node.iri and node.iri.inverseFunctional:
raise ProfileError(
'({}) Functionality of roles is forbidden in OWL 2 QL'.
format(str(node.iri)))
def __call__(self, node):
if (('AttributeNode' in str(type(node)))
or ('RoleNode' in str(type(node)))):
if node.isFunctional():
raise ProfileError(
'Functionality of roles and attributes is forbidden in OWL 2 QL'
)
def __call__(self, node):
if node.type() is Item.ValueDomainIRINode:
if node.iri and not OWL2Datatype.forProfile(OWL2Profiles.OWL2RL):
raise ProfileError(
'Use of datatype {} is forbidden in OWL 2 RL'.format(
str(node.iri)))
'''
def __call__(self, source, edge, target):
if edge.type() is Item.MembershipEdge:
if source.identity() is Identity.AttributeInstance:
if target.type() is Item.ComplementNode:
raise ProfileError(
'Negative attribute assertion is forbidden in OWL 2 QL'
)
def __call__(self, node):
if isinstance(node, OntologyEntityNode) or isinstance(
node, OntologyEntityResizableNode):
if node.iri and node.iri.transitive:
raise ProfileError(
'({}) Transitivity of roles is forbidden in OWL 2 QL'.
format(str(node.iri)))
def __call__(self, source, edge, target):
if edge.type() is Item.InputEdge:
if target.type() is Item.ComplementNode:
if source.identity() is Identity.ValueDomain:
# We found a complement node with a value-domain expression in input so we must deny it.
raise ProfileError(
'Complement of a value-domain expression is forbidden in OWL 2 QL'
)
def __call__(self, source, edge, target):
if edge.type() is Item.InclusionEdge:
# Similarily as for the Inclusion edge, we provide rules for OWL 2 RL concept expressions equivalence.
# Because equivalence express a double inclusion we treat each of the endpoints in the same way.
if not {Identity.Role, Identity.Attribute, Identity.Unknown} & {
source.identity(), target.identity()
}:
for node in (source, target):
# TOP concept cannot be part of concept equivalence in OWL 2 RL.
if node.type() is Item.ConceptNode:
if (Special.valueOf(node.text()) is Special.Top) or \
(Special.valueOf(node.text()) is Special.TopConcept) or \
(Special.valueOf(node.text()) is Special.TopAttribute) or \
(Special.valueOf(node.text()) is Special.TopRole):
raise ProfileError(
'Equivalence in presence of a TOP concept is forbidden in OWL 2 RL'
)
# Complement nodes cannot be part of concept equivalence in OWL 2 RL.
elif node.type() is Item.ComplementNode:
raise ProfileError(
'Equivalence in presence of a concept complement is forbidden in OWL 2 RL'
)
# Enumeration nodes cannot be part of concept equivalence in OWL 2 RL.
elif node.type() is Item.EnumerationNode:
raise ProfileError(
'Equivalence in presence of an enumeration of individuals is forbidden in OWL 2 RL'
)
# Union of concept expressions cannot be part of concept equivalence in OWL 2 RL.
elif node.type() is Item.EnumerationNode:
raise ProfileError(
'Equivalence in presence of a union of concept expressions is forbidden in OWL 2 RL'
)
# Domain/range restriction cannot be part of concept equivalence in OWL 2 RL.
elif node.type() in {
Item.DomainRestrictionNode,
Item.RangeRestrictionNode
}:
f1 = lambda x: x.type() is Item.InputEdge
f2 = lambda x: x.type() is Item.EnumerationNode
if not node.incomingNodes(filter_on_edges=f1,
filter_on_nodes=f2):
raise ProfileError(
'Existential {} must specify an Enumeration as filler when involved '
'in an equivalence between concept expressions in OWL 2 RL'
.format(target.shortName))
def __call__(self, node):
if node.type() in {Item.AttributeIRINode, Item.RoleIRINode}:
if node.iri and (node.iri.isTopObjectProperty()
or node.iri.isBottomObjectProperty()
or node.iri.isTopDataProperty()
or node.iri.isBottomDataProperty()):
raise ProfileError('Use of {} is forbidden in OWL 2 RL'.format(
str(node.iri)))
'''
def __call__(self, node):
if node.type() in {
Item.UnionNode, Item.DisjointUnionNode,
Item.DatatypeRestrictionNode, Item.FacetIRINode,
Item.EnumerationNode, Item.RoleChainNode
}:
raise ProfileError(
'Usage of {} operator is forbidden in OWL 2 QL'.format(
node.shortName))
def __call__(self, source, edge, target):
if edge.type() is Item.InputEdge:
if target.type() in {Item.DisjointUnionNode, Item.UnionNode}:
if Identity.ValueDomain in {
source.identity(),
target.identity()
}:
raise ProfileError(
'Union of of value-domain expressions is forbidden in OWL 2 RL'
)
def __call__(self, source, edge, target):
if edge.type() is Item.InputEdge:
if target.type() is Item.IntersectionNode:
if source.identity() is Identity.ValueDomain:
f1 = lambda x: x.type() in {Item.InputEdge, Item.InclusionEdge, Item.EquivalenceEdge}
f2 = lambda x: Identity.Neutral in x.identities()
for node in bfs(source=target, filter_on_edges=f1, filter_on_nodes=f2):
if node.type() is Item.ComplementNode:
# We found a complement node along the path, so any input to this intersection node,
# would cause the complement node to identify itself as a value-domain, but in OWL 2 QL
# it is not possible to construct complement of value domain expressions.
raise ProfileError('Complement of a value-domain expression is forbidden in OWL 2 QL')
def __call__(self, node):
'''
if (('AttributeIRINode' in str(type(node))) or ('RoleIRINode' in str(type(node)))):
if node.isFunctional():
raise ProfileError('Functionality of roles and attributes is forbidden in OWL 2 QL')
'''
if isinstance(node, OntologyEntityNode) or isinstance(
node, OntologyEntityResizableNode):
if node.iri and node.iri.functional:
raise ProfileError(
'({}) Functionality of roles and attributes is forbidden in OWL 2 QL'
.format(str(node.iri)))
def __call__(self, node):
'''
if ('RoleIRINode' in str(type(node))):
if node.isReflexive():
raise ProfileError('Reflexivity of roles is forbidden in OWL 2 RL')
'''
if isinstance(node, OntologyEntityNode) or isinstance(
node, OntologyEntityResizableNode):
if node.iri:
if node.iri.reflexive:
raise ProfileError(
'({}) Reflexivity of roles is forbidden in OWL 2 RL'.
format(str(node.iri)))
def __call__(self, node):
if ('RoleNode' in str(type(node))):
if node.isInverseFunctional():
raise ProfileError(
'Inverse Functionality of roles is forbidden in OWL 2 QL')
def __call__(self, source, edge, target):
if edge.type() is Item.InclusionEdge:
# We need to provide rules for OWL 2 RL concept inclusion. Value-Domain inclusions
# are already forbidden by OWL 2 rules, so here we just consider the case where we
# are connecting endpoints that either both Neutral, or at least one of the 2 is
# identified as a Concept expression.
if not {Identity.Role, Identity.Attribute, Identity.Unknown} & {
source.identity(), target.identity()
}:
#############################################
# EVALUATE INCLUSION SOURCE
#################################
# TOP concept cannot be source of concept inclusion in OWL 2 RL.
if source.type() is Item.ConceptIRINode:
if source.iri and (source.iri.isOwlThing()
or source.iri.isTopObjectProperty()
or source.iri.isTopDataProperty()):
raise ProfileError(
'Inclusion axioms involving a TOP predicate is forbidden in OWL 2 RL'
)
# Complement nodes cannot be source of concept inclusion in OWL 2 RL.
elif source.type() is Item.ComplementNode:
raise ProfileError(
'Inclusion with a concept complement as source is forbidden in OWL 2 RL'
)
# OWL 2 RL admits only existential restriction as source for inclusion.
elif source.type() in {
Item.DomainRestrictionNode, Item.RangeRestrictionNode
}:
if source.restriction() is not Restriction.Exists:
r = source.restriction()
raise ProfileError(
'Inclusion with a {} {} as source is forbidden in OWL 2 RL'
.format(r.shortName, source.shortName))
#############################################
# EVALUATE INCLUSION TARGET
#################################
# TOP concept cannot be target of concept inclusion in OWL 2 RL.
if target.type() is Item.ConceptIRINode:
if target.iri and (target.iri.isOwlThing()
or target.iri.isTopObjectProperty()
or target.iri.isTopDataProperty()):
raise ProfileError(
'Use of inclusion axioms involving a TOP predicate is forbidden in OWL 2 RL'
)
# Enumeration nodes cannot be target of concept inclusion in OWL 2 RL.
elif target.type() is Item.EnumerationNode:
raise ProfileError(
'Inclusion with an enumeration of individuals as target is forbidden in OWL 2 RL'
)
# Union of concept expressions cannot be target of concept inclusion in OWL 2 RL.
elif target.type() is Item.EnumerationNode:
raise ProfileError(
'Inclusion with a union of concept expressions as target is forbidden in OWL 2 RL'
)
# Existential domain/range restriction and cardinality check.
elif target.type() in {
Item.DomainRestrictionNode, Item.RangeRestrictionNode
}:
if target.restriction() is Restriction.Exists:
# We need to check for the restriction to have a an Enumeration as filler.
f1 = lambda x: x.type() is Item.InputEdge
f2 = lambda x: x.type() is Item.EnumerationNode
if not target.incomingNodes(filter_on_edges=f1,
filter_on_nodes=f2):
raise ProfileError(
'Existential {} must specify an Enumeration as filler when acting as '
'target for a concept expression inclusion in OWL 2 RL'
.format(target.shortName))
elif target.restriction() is Restriction.Cardinality:
if target.cardinality('max') not in (0, 1):
raise ProfileError(
'Cardinality {} must specify a max cardinality of 0 or 1 when acting as '
'target for a concept expression inclusion in OWL 2 RL'
.format(target.shortName))
def __call__(self, source, edge, target):
if edge.type() is Item.InputEdge:
if target.type() is Item.EnumerationNode:
if source.identity() is Identity.Value:
raise ProfileError(
'Enumeration of values is forbidden in OWL 2 RL')
def __call__(self, node):
if node.type() in {Item.AttributeNode, Item.RoleNode}:
if Special.valueOf(node.text()) is not None:
raise ProfileError(
'Usage of {} {} is forbidden in OWL 2 RL'.format(
node.text(), node.shortName))
def __call__(self, node):
if node.type() is Item.ValueDomainNode:
if node.datatype not in Datatype.forProfile(OWLProfile.OWL2QL):
raise ProfileError(
'Datatype {} is forbidden in OWL 2 QL'.format(
node.datatype.value))
def __call__(self, source, edge, target):
if edge.type() is Item.SameEdge:
raise ProfileError(
'Usage of SameIndividual axiom is forbidden in OWL 2 QL')
def __call__(self, node):
if ('RoleNode' in str(type(node))):
if node.isTransitive():
raise ProfileError(
'Transitivity of roles is forbidden in OWL 2 QL')
def __call__(self, node):
if node.type() in {Item.DatatypeRestrictionNode, Item.FacetNode}:
raise ProfileError(
'Usage of {} operator is forbidden in OWL 2 RL'.format(
node.shortName))
