Source code for owlapy.has
-from typing import Protocol, ClassVar, TypeVar, Generic, Iterable
-from abc import ABCMeta, abstractmethod
-_T = TypeVar('_T') #:
-
+from typing import Protocol, ClassVar
[docs]
class HasIndex(Protocol):
@@ -92,97 +89,6 @@ Source code for owlapy.has
-
-
-[docs]
-class HasIRI(metaclass=ABCMeta):
- """Simple class to access the IRI."""
- __slots__ = ()
-
-
-[docs]
- @abstractmethod
- def get_iri(self) -> 'IRI':
- """Gets the IRI of this object.
-
- Returns:
- The IRI of this object.
- """
- pass
-
-
-
-
-
-[docs]
-class HasOperands(Generic[_T], metaclass=ABCMeta):
- """An interface to objects that have a collection of operands.
-
- Args:
- _T: Operand type.
- """
- __slots__ = ()
-
-
-[docs]
- @abstractmethod
- def operands(self) -> Iterable[_T]:
- """Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
-
- Returns:
- The operands.
- """
- pass
-
-
-
-
-
-
-[docs]
-class HasFiller(Generic[_T], metaclass=ABCMeta):
- """An interface to objects that have a filler.
-
- Args:
- _T: Filler type.
- """
- __slots__ = ()
-
-
-[docs]
- @abstractmethod
- def get_filler(self) -> _T:
- """Gets the filler for this restriction. In the case of an object restriction this will be an individual, in
- the case of a data restriction this will be a constant (data value). For quantified restriction this will be
- a class expression or a data range.
-
- Returns:
- the value
- """
- pass
-
-
-
-
-
-[docs]
-class HasCardinality(metaclass=ABCMeta):
- """An interface to objects that have a cardinality."""
- __slots__ = ()
-
-
-[docs]
- @abstractmethod
- def get_cardinality(self) -> int:
- """Gets the cardinality of a restriction.
-
- Returns:
- The cardinality. A non-negative integer.
- """
- pass
-
-
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/_modules/owlapy/model.html b/_modules/owlapy/model.html
index bf134c0..50cc9cd 100644
--- a/_modules/owlapy/model.html
+++ b/_modules/owlapy/model.html
@@ -77,7 +77,6 @@
+
+
+
+
+
+
+
+
+
+
+
+
+ Source code for owlapy.meta_classes
+# https://docs.python.org/3/reference/datamodel.html#metaclasses
+from typing import TypeVar, Generic, Iterable
+from abc import ABCMeta, abstractmethod
+
+_T = TypeVar('_T') #:
+
+
+
+[docs]
+class HasIRI(metaclass=ABCMeta):
+ """Simple class to access the IRI."""
+ __slots__ = ()
+
+
+[docs]
+ @abstractmethod
+ def get_iri(self) -> 'IRI':
+ """Gets the IRI of this object.
+
+ Returns:
+ The IRI of this object.
+ """
+ pass
+
+
+
+
+
+[docs]
+class HasOperands(Generic[_T], metaclass=ABCMeta):
+ """An interface to objects that have a collection of operands.
+
+ Args:
+ _T: Operand type.
+ """
+ __slots__ = ()
+
+
+[docs]
+ @abstractmethod
+ def operands(self) -> Iterable[_T]:
+ """Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ Returns:
+ The operands.
+ """
+ pass
+
+
+
+
+
+[docs]
+class HasFiller(Generic[_T], metaclass=ABCMeta):
+ """An interface to objects that have a filler.
+
+ Args:
+ _T: Filler type.
+ """
+ __slots__ = ()
+
+
+[docs]
+ @abstractmethod
+ def get_filler(self) -> _T:
+ """Gets the filler for this restriction. In the case of an object restriction this will be an individual, in
+ the case of a data restriction this will be a constant (data value). For quantified restriction this will be
+ a class expression or a data range.
+
+ Returns:
+ the value
+ """
+ pass
+
+
+
+
+
+[docs]
+class HasCardinality(metaclass=ABCMeta):
+ """An interface to objects that have a cardinality."""
+ __slots__ = ()
+
+
+[docs]
+ @abstractmethod
+ def get_cardinality(self) -> int:
+ """Gets the cardinality of a restriction.
+
+ Returns:
+ The cardinality. A non-negative integer.
+ """
+ pass
+
+
+Source code for owlapy.model
from abc import ABCMeta, abstractmethod
-from itertools import combinations
from typing import Generic, Iterable, Sequence, Set, TypeVar, Union, Final, Optional, Protocol, ClassVar, List
from datetime import datetime, date
from pandas import Timedelta
@@ -86,25 +85,25 @@ Source code for owlapy.model
from owlapy.owlobject import OWLObject, OWLEntity
from owlapy.owl_annotation import OWLAnnotationObject, OWLAnnotationSubject, OWLAnnotationValue
from owlapy.iri import IRI
-from owlapy.has import HasIndex, HasIRI, HasOperands, HasFiller, HasCardinality
+from owlapy.has import HasIndex
+from owlapy.meta_classes import HasIRI, HasOperands, HasFiller, HasCardinality
from owlapy.owl_class_expression import OWLNaryBooleanClassExpression, OWLClassExpression, OWLObjectComplementOf, \
OWLAnonymousClassExpression, OWLBooleanClassExpression, OWLPropertyRange, OWLDataRange, OWLClass, OWLObjectUnionOf, \
- OWLObjectIntersectionOf
+ OWLObjectIntersectionOf, OWLThing, OWLNothing
from owlapy.owl_property import OWLObjectPropertyExpression, OWLProperty, OWLPropertyExpression, \
OWLDataPropertyExpression, OWLDataProperty, OWLObjectProperty
from owlapy.owl_restriction import (OWLRestriction, OWLObjectAllValuesFrom, OWLObjectSomeValuesFrom,
OWLQuantifiedRestriction, OWLQuantifiedObjectRestriction,
OWLObjectRestriction, OWLHasValueRestriction, OWLDataRestriction,
OWLCardinalityRestriction, OWLObjectMinCardinality, OWLObjectCardinalityRestriction,OWLDataAllValuesFrom,
- OWLObjectHasSelf, OWLObjectMaxCardinality, OWLObjectExactCardinality,OWLDataExactCardinality)
+ OWLObjectHasSelf, OWLObjectMaxCardinality, OWLObjectExactCardinality,OWLDataExactCardinality,OWLDataMinCardinality,
+ OWLDataMaxCardinality,OWLDataSomeValuesFrom,OWLDataHasValue,OWLDataOneOf,OWLQuantifiedDataRestriction,OWLDataCardinalityRestriction)
from owlapy.owl_individual import OWLNamedIndividual, OWLIndividual
from owlapy.owl_axiom import (OWLEquivalentClassesAxiom, OWLClassAxiom,
OWLDataPropertyDomainAxiom, OWLAxiom, OWLDataPropertyRangeAxiom,
OWLObjectPropertyDomainAxiom, OWLObjectPropertyRangeAxiom)
from owlapy.types import OWLDatatype
-from owlapy.owl_data import OWLDataMinCardinality, OWLDataMaxCardinality,OWLDataComplementOf, OWLDataIntersectionOf, OWLDataHasValue, OWLDataOneOf, OWLDataSomeValuesFrom,OWLDataUnionOf
-from owlapy.owl_data import OWLNaryDataRange, OWLQuantifiedDataRestriction, OWLDataCardinalityRestriction
from owlapy.owl_literal import OWLLiteral
@@ -118,122 +117,6 @@ Source code for owlapy.model
_M = TypeVar('_M', bound='OWLOntologyManager') #:
-
-[docs]
-class OWLObjectHasValue(OWLHasValueRestriction[OWLIndividual], OWLObjectRestriction):
- """Represents an ObjectHasValue class expression in the OWL 2 Specification."""
- __slots__ = '_property', '_v'
- type_index: Final = 3007
-
- _property: OWLObjectPropertyExpression
- _v: OWLIndividual
-
- def __init__(self, property: OWLObjectPropertyExpression, individual: OWLIndividual):
- """
- Args:
- property: The property that the restriction acts along.
- individual: Individual for restriction.
-
- Returns:
- A HasValue restriction with specified property and value
- """
- super().__init__(individual)
- self._property = property
-
-
-[docs]
- def get_property(self) -> OWLObjectPropertyExpression:
- # documented in parent
- return self._property
-
-
-
-[docs]
- def as_some_values_from(self) -> OWLClassExpression:
- """A convenience method that obtains this restriction as an existential restriction with a nominal filler.
-
- Returns:
- The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
- """
- return OWLObjectSomeValuesFrom(self.get_property(), OWLObjectOneOf(self.get_filler()))
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLObjectHasValue(property={self.get_property()}, individual={self._v})'
-
-
-
-
-
-[docs]
-class OWLObjectOneOf(OWLAnonymousClassExpression, HasOperands[OWLIndividual]):
- """Represents an ObjectOneOf class expression in the OWL 2 Specification."""
- __slots__ = '_values'
- type_index: Final = 3004
-
- def __init__(self, values: Union[OWLIndividual, Iterable[OWLIndividual]]):
- if isinstance(values, OWLIndividual):
- self._values = values,
- else:
- for _ in values:
- assert isinstance(_, OWLIndividual)
- self._values = tuple(values)
-
-
-[docs]
- def individuals(self) -> Iterable[OWLIndividual]:
- """Gets the individuals that are in the oneOf. These individuals represent the exact instances (extension)
- of this class expression.
-
- Returns:
- The individuals that are the values of this {@code ObjectOneOf} class expression.
- """
- yield from self._values
-
-
-
-[docs]
- def operands(self) -> Iterable[OWLIndividual]:
- # documented in parent
- yield from self.individuals()
-
-
-
-[docs]
- def as_object_union_of(self) -> OWLClassExpression:
- """Simplifies this enumeration to a union of singleton nominals.
-
- Returns:
- This enumeration in a more standard DL form.
- simp({a}) = {a} simp({a0, ... , {an}) = unionOf({a0}, ... , {an})
- """
- if len(self._values) == 1:
- return self
- return OWLObjectUnionOf(map(lambda _: OWLObjectOneOf(_), self.individuals()))
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) == type(self):
- return self._values == other._values
- return NotImplemented
-
-
-
-
-
@@ -320,111 +203,6 @@ Source code for owlapy.model
-
-[docs]
-class OWLDatatypeRestriction(OWLDataRange):
- """Represents a DatatypeRestriction data range in the OWL 2 Specification."""
- __slots__ = '_type', '_facet_restrictions'
-
- type_index: Final = 4006
-
- _type: OWLDatatype
- _facet_restrictions: Sequence['OWLFacetRestriction']
-
- def __init__(self, type_: OWLDatatype, facet_restrictions: Union['OWLFacetRestriction',
- Iterable['OWLFacetRestriction']]):
- self._type = type_
- if isinstance(facet_restrictions, OWLFacetRestriction):
- facet_restrictions = facet_restrictions,
- self._facet_restrictions = tuple(facet_restrictions)
-
-
-
-
-
-[docs]
- def get_facet_restrictions(self) -> Sequence['OWLFacetRestriction']:
- return self._facet_restrictions
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._type == other._type \
- and self._facet_restrictions == other._facet_restrictions
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLDatatypeRestriction({repr(self._type)}, {repr(self._facet_restrictions)})'
-
-
-
-
-
-[docs]
-class OWLFacetRestriction(OWLObject):
- """A facet restriction is used to restrict a particular datatype."""
-
- __slots__ = '_facet', '_literal'
-
- type_index: Final = 4007
-
- _facet: OWLFacet
- _literal: 'OWLLiteral'
-
- def __init__(self, facet: OWLFacet, literal: Literals):
- self._facet = facet
- if isinstance(literal, OWLLiteral):
- self._literal = literal
- else:
- self._literal = OWLLiteral(literal)
-
-
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._facet == other._facet and self._literal == other._literal
- return NotImplemented
-
-
-
-
-
-
-
-
-
[docs]
@@ -1252,8 +1030,7 @@ Source code for owlapy.model
"""Important constant objects section"""
# @TODO: Some of them must be removed from here as they are defined under owl literal
-OWLThing: Final = OWLClass(OWLRDFVocabulary.OWL_THING.get_iri()) #: : :The OWL Class corresponding to owl:Thing
-OWLNothing: Final = OWLClass(OWLRDFVocabulary.OWL_NOTHING.get_iri()) #: : :The OWL Class corresponding to owl:Nothing
+
#: the built in top object property
OWLTopObjectProperty: Final = OWLObjectProperty(OWLRDFVocabulary.OWL_TOP_OBJECT_PROPERTY.get_iri())
#: the built in bottom object property
diff --git a/_modules/owlapy/model/providers.html b/_modules/owlapy/model/providers.html
index b9a486e..bc72192 100644
--- a/_modules/owlapy/model/providers.html
+++ b/_modules/owlapy/model/providers.html
@@ -80,7 +80,8 @@ Source code for owlapy.model.providers
"""OWL Datatype restriction constructors."""
from typing import Union
from datetime import datetime, date
-from owlapy.model import OWLDatatypeRestriction, OWLFacet, OWLFacetRestriction, OWLLiteral
+from owlapy.owl_literal import OWLLiteral
+from owlapy.owl_restriction import OWLDatatypeRestriction, OWLFacet, OWLFacetRestriction
from pandas import Timedelta
Restriction_Literals = Union[OWLLiteral, int, float, Timedelta, datetime, date]
diff --git a/_modules/owlapy/owl2sparql/converter.html b/_modules/owlapy/owl2sparql/converter.html
deleted file mode 100644
index f263d94..0000000
--- a/_modules/owlapy/owl2sparql/converter.html
+++ /dev/null
@@ -1,765 +0,0 @@
-
-
-
-
-
- owlapy.owl2sparql.converter — OWLAPY 0.1.2 documentation
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Source code for owlapy.owl2sparql.converter
-"""Format converter."""
-from collections import defaultdict
-from contextlib import contextmanager
-from functools import singledispatchmethod
-from types import MappingProxyType
-from typing import Set, List, Dict, Optional, Iterable
-
-from rdflib.plugins.sparql.parser import parseQuery
-
-from owlapy.model import OWLClassExpression, OWLClass, OWLEntity, OWLObjectProperty, \
- OWLObjectUnionOf, OWLObjectComplementOf, OWLObjectSomeValuesFrom, OWLObjectAllValuesFrom, OWLObjectHasValue, \
- OWLNamedIndividual, OWLObjectCardinalityRestriction, OWLObjectMinCardinality, OWLObjectExactCardinality, \
- OWLObjectMaxCardinality, OWLDataCardinalityRestriction, OWLDataProperty, OWLObjectHasSelf, OWLObjectOneOf, \
- OWLDataSomeValuesFrom, OWLDataAllValuesFrom, OWLDataHasValue, OWLDatatype, TopOWLDatatype, OWLDataOneOf, \
- OWLLiteral, OWLDatatypeRestriction, OWLObjectIntersectionOf
-from owlapy.vocab import OWLFacet, OWLRDFVocabulary
-
-_Variable_facet_comp = MappingProxyType({
- OWLFacet.MIN_INCLUSIVE: ">=",
- OWLFacet.MIN_EXCLUSIVE: ">",
- OWLFacet.MAX_INCLUSIVE: "<=",
- OWLFacet.MAX_EXCLUSIVE: "<"
-})
-
-
-
-[docs]
-def peek(x):
- """Peek the last element of an array.
-
- Returns:
- The last element arr[-1].
-
- """
- return x[-1]
-
-
-
-
-[docs]
-class VariablesMapping:
- """Helper class for owl-to-sparql conversion."""
- __slots__ = 'class_cnt', 'prop_cnt', 'ind_cnt', 'dict'
-
- def __init__(self):
- self.class_cnt = 0
- self.prop_cnt = 0
- self.ind_cnt = 0
- self.dict = dict()
-
-
-[docs]
- def get_variable(self, e: OWLEntity) -> str:
- if e in self.dict:
- return self.dict[e]
-
- if isinstance(e, OWLClass):
- self.class_cnt += 1
- var = f"?cls_{self.class_cnt}"
- elif isinstance(e, OWLObjectProperty) or isinstance(e, OWLDataProperty):
- self.prop_cnt += 1
- var = f"?p_{self.prop_cnt}"
- elif isinstance(e, OWLNamedIndividual):
- self.ind_cnt += 1
- var = f"?ind_{self.ind_cnt}"
- else:
- raise ValueError(e)
-
- self.dict[e] = var
- return var
-
-
-
-[docs]
- def new_individual_variable(self) -> str:
- self.ind_cnt += 1
- return f"?s_{self.ind_cnt}"
-
-
-
-[docs]
- def new_property_variable(self) -> str:
- self.prop_cnt += 1
- return f"?p_{self.prop_cnt}"
-
-
-
-
-
-
-
-
-
-
-
-[docs]
-class Owl2SparqlConverter:
- """Convert owl (owlapy model class expressions) to SPARQL."""
- __slots__ = 'ce', 'sparql', 'variables', 'parent', 'parent_var', 'properties', 'variable_entities', 'cnt', \
- 'mapping', 'grouping_vars', 'having_conditions', '_intersection'
- # @TODO:CD: We need to document this class. The computation behind the mapping is not clear.
-
- ce: OWLClassExpression
- sparql: List[str]
- variables: List[str]
- parent: List[OWLClassExpression]
- parent_var: List[str]
- variable_entities: Set[OWLEntity]
- properties: Dict[int, List[OWLEntity]]
- _intersection: Dict[int, bool]
- mapping: VariablesMapping
- grouping_vars: Dict[OWLClassExpression, Set[str]]
- having_conditions: Dict[OWLClassExpression, Set[str]]
- cnt: int
-
-
-[docs]
- def convert(self, root_variable: str, ce: OWLClassExpression, named_individuals: bool = False):
- """Used to convert owl class expression to SPARQL syntax.
-
- Args:
- root_variable (str): Root variable name that will be used in SPARQL query.
- ce (OWLClassExpression): The owl class expression to convert.
- named_individuals (bool): If 'True' return only entities that are instances of owl:NamedIndividual.
-
- Returns:
- list[str]: The SPARQL query.
- """
- self.ce = ce
- self.sparql = []
- self.variables = []
- self.parent = []
- self.parent_var = []
- self.properties = defaultdict(list)
- self.variable_entities = set()
- self._intersection = defaultdict(bool)
- self.cnt = 0
- self.mapping = VariablesMapping()
- self.grouping_vars = defaultdict(set)
- self.having_conditions = defaultdict(set)
- # if named_individuals is True, we return only entities that are instances of owl:NamedIndividual
- if named_individuals:
- self.append_triple(root_variable, 'a', f"<{OWLRDFVocabulary.OWL_NAMED_INDIVIDUAL.as_str()}>")
- with self.stack_variable(root_variable):
- with self.stack_parent(ce):
- self.process(ce)
- return self.sparql
-
-
- @property
- def modal_depth(self):
- return len(self.variables)
-
-
-
-
- @render.register
- def _(self, lit: OWLLiteral):
- return f'"{lit.get_literal()}"^^<{lit.get_datatype().to_string_id()}>'
-
- @render.register
- def _(self, e: OWLEntity):
- if e in self.variable_entities:
- s = self.mapping.get_variable(e)
- else:
- s = f"<{e.to_string_id()}>"
- if isinstance(e, OWLObjectProperty):
- self.properties[self.modal_depth].append(e)
- return s
-
- def _maybe_quote(self, e):
- assert isinstance(e, str)
- if e.startswith("?"):
- return e
- else:
- return f"<{e}>"
-
- def _maybe_quote_p(self, p):
- if isinstance(p, str):
- if p.startswith("?") or p == "a" or p.startswith("<"):
- return p
- else:
- return f"<{p}>"
- else:
- return self.render(p)
-
- def _maybe_render(self, o):
- if isinstance(o, str):
- return o
- else:
- return self.render(o)
-
-
-
-[docs]
- @contextmanager
- def stack_variable(self, var):
- self.variables.append(var)
- try:
- yield
- finally:
- self.variables.pop()
-
-
-
-[docs]
- @contextmanager
- def stack_parent(self, parent: OWLClassExpression):
- self.parent.append(parent)
- self.parent_var.append(self.current_variable)
- try:
- yield
- finally:
- self.parent.pop()
- self.parent_var.pop()
-
-
- @property
- def current_variable(self):
- return peek(self.variables)
-
- # this method is responsible for translating class expressions to SPARQL queries
- # the decorator "@singledispatchmethod" denotes that the method is overload
- # each overload of the method is responsible for processing a different type of class expressions (e.g., ⊔ or ⊓)
-
-[docs]
- @singledispatchmethod
- def process(self, ce: OWLClassExpression):
- raise NotImplementedError(ce)
-
-
- # an overload of process function
- # this overload is responsible for handling single concepts (e.g., Brother)
- # general case: C
- # this is the final step of the recursion
- @process.register
- def _(self, ce: OWLClass):
- if self.ce == ce or not ce.is_owl_thing():
- self.append_triple(self.current_variable, "a", self.render(ce))
- # old_var = self.current_variable
- # new_var = self.mapping.new_individual_variable()
- # with self.stack_variable(new_var):
- # self.append_triple(old_var, "a", new_var)
- # self.append_triple(new_var, "<http://www.w3.org/2000/01/rdf-schema#subClassOf>*", self.render(ce))
- elif ce.is_owl_thing():
- self.append_triple(self.current_variable, "a", "<http://www.w3.org/2002/07/owl#Thing>")
-
- # an overload of process function
- # this overload is responsible for handling intersections of concepts (e.g., Brother ⊓ Father)
- # general case: C1 ⊓ ... ⊓ Cn
- @process.register
- def _(self, ce: OWLObjectIntersectionOf):
- # we iterate over the concepts that appear in the intersection
- for op in ce.operands():
- self.process(op)
-
- # an overload of process function
- # this overload is responsible for handling unions of concepts (e.g., Brother ⊔ Sister)
- # general case: C1 ⊔ ... ⊔ Cn
- @process.register
- def _(self, ce: OWLObjectUnionOf):
- first = True
- # we iterate over the concepts that appear in the union
- for op in ce.operands():
- # SPARQL's UNION comes after the first concept
- if first:
- first = False
- else:
- self.append(" UNION ")
- self.append("{ ")
- with self.stack_parent(op):
- self.process(op)
- self.append(" }")
-
- # an overload of process function
- # this overload is responsible for handling complements of concepts (e.g., ¬Brother)
- # general case: ¬C
- @process.register
- def _(self, ce: OWLObjectComplementOf):
- subject = self.current_variable
- self.append_triple(subject, self.mapping.new_individual_variable(), self.mapping.new_individual_variable())
-
- self.append("FILTER NOT EXISTS { ")
- # process the concept after the ¬
- self.process(ce.get_operand())
- self.append(" }")
-
- # an overload of process function
- # this overload is responsible for handling the exists operator (e.g., ∃hasChild.Male)
- # general case: ∃r.C
- @process.register
- def _(self, ce: OWLObjectSomeValuesFrom):
- object_variable = self.mapping.new_individual_variable()
- # property expression holds the role of the class expression (hasChild in our example)
- property_expression = ce.get_property()
- if property_expression.is_anonymous():
- # property expression is inverse of a property
- self.append_triple(object_variable, property_expression.get_named_property(), self.current_variable)
- else:
- self.append_triple(self.current_variable, property_expression.get_named_property(), object_variable)
- # filler holds the concept of the expression (Male in our example) and is processed recursively
- filler = ce.get_filler()
- with self.stack_variable(object_variable):
- self.process(filler)
-
- # an overload of process function
- # this overload is responsible for handling the forAll operator (e.g., ∀hasChild.Male)
- # general case: ∀r.C
- @process.register
- def _(self, ce: OWLObjectAllValuesFrom):
- subject = self.current_variable
- object_variable = self.mapping.new_individual_variable()
- # property expression holds the role of the class expression (hasChild in our example)
- property_expression = ce.get_property()
- predicate = property_expression.get_named_property()
- # filler holds the concept of the expression (Male in our example) and is processed recursively
- filler = ce.get_filler()
-
-
- self.append("{")
-
- if property_expression.is_anonymous():
- # property expression is inverse of a property
- self.append_triple(object_variable, predicate, self.current_variable)
- else:
- self.append_triple(self.current_variable, predicate, object_variable)
-
- # restrict filler
- var = self.mapping.new_individual_variable()
- cnt_var1 = self.new_count_var()
- # the count needs to use distinct
- self.append(f"{{ SELECT {subject} ( COUNT( DISTINCT {var} ) AS {cnt_var1} ) WHERE {{ ")
- self.append_triple(subject, predicate, var)
- # here, we recursively process the filler (Male in our example)
- with self.stack_variable(var):
- self.process(filler)
- self.append(f" }} GROUP BY {subject} }}")
-
- var = self.mapping.new_individual_variable()
- cnt_var2 = self.new_count_var()
- # the count needs to use distinct
- self.append(f"{{ SELECT {subject} ( COUNT( DISTINCT {var} ) AS {cnt_var2} ) WHERE {{ ")
- self.append_triple(subject, predicate, var)
- self.append(f" }} GROUP BY {subject} }}")
-
- self.append(f" FILTER( {cnt_var1} = {cnt_var2} )")
- self.append("} UNION { ")
-
- # here, the second group graph pattern starts
- # the second group graph pattern returns all those entities that do not appear in a triple with the property
- self.append_triple(subject, self.mapping.new_individual_variable(), self.mapping.new_individual_variable())
- self.append("FILTER NOT EXISTS { ")
- if property_expression.is_anonymous():
- # property expression is inverse of a property
- self.append_triple(self.mapping.new_individual_variable(), predicate, self.current_variable)
- else:
- self.append_triple(self.current_variable, predicate, self.mapping.new_individual_variable())
- self.append(" } }")
-
- # an overload of process function
- # this overload is responsible for handling the exists operator combined with an individual (e.g., ∃hasChild.{john})
- # general case: ∃r.{a}
- @process.register
- def _(self, ce: OWLObjectHasValue):
- property_expression = ce.get_property()
- value = ce.get_filler()
- # we ensure that the value is an individual
- assert isinstance(value, OWLNamedIndividual)
- if property_expression.is_anonymous():
- self.append_triple(value.to_string_id(), property_expression.get_named_property(), self.current_variable)
- else:
- self.append_triple(self.current_variable, property_expression.get_named_property(), value)
-
- # an overload of process function
- # this overload is responsible for handling the exists operator combined with an individual(e.g., >=3 hasChild.Male)
- # general case: \theta n r.C
- @process.register
- def _(self, ce: OWLObjectCardinalityRestriction):
- subject_variable = self.current_variable
- object_variable = self.mapping.new_individual_variable()
- property_expression = ce.get_property()
- cardinality = ce.get_cardinality()
-
- if isinstance(ce, OWLObjectMinCardinality):
- comparator = ">="
- elif isinstance(ce, OWLObjectMaxCardinality):
- comparator = "<="
- elif isinstance(ce, OWLObjectExactCardinality):
- comparator = "="
- else:
- raise ValueError(ce)
-
- # if the comparator is ≤ or the cardinality is 0, we need an additional group graph pattern
- # the additional group graph pattern will take care the cases where an individual is not associated with the
- # property expression
- if comparator == "<=" or cardinality == 0:
- self.append("{")
-
- self.append(f"{{ SELECT {subject_variable} WHERE {{ ")
- if property_expression.is_anonymous():
- # property expression is inverse of a property
- self.append_triple(object_variable, property_expression.get_named_property(), subject_variable)
- else:
- self.append_triple(subject_variable, property_expression.get_named_property(), object_variable)
-
- filler = ce.get_filler()
- with self.stack_variable(object_variable):
- self.process(filler)
-
- self.append(f" }} GROUP BY {subject_variable}"
- f" HAVING ( COUNT ( {object_variable} ) {comparator} {cardinality} ) }}")
-
- # here, the second group graph pattern starts
- if comparator == "<=" or cardinality == 0:
- self.append("} UNION {")
- self.append_triple(subject_variable, self.mapping.new_individual_variable(),
- self.mapping.new_individual_variable())
- self.append("FILTER NOT EXISTS { ")
- object_variable = self.mapping.new_individual_variable()
- if property_expression.is_anonymous():
- # property expression is inverse of a property
- self.append_triple(object_variable, property_expression.get_named_property(), self.current_variable)
- else:
- self.append_triple(self.current_variable, property_expression.get_named_property(), object_variable)
- with self.stack_variable(object_variable):
- self.process(filler)
- self.append(" } }")
-
- @process.register
- def _(self, ce: OWLDataCardinalityRestriction):
- subject_variable = self.current_variable
- object_variable = self.mapping.new_individual_variable()
- property_expression = ce.get_property()
- assert isinstance(property_expression, OWLDataProperty)
- cardinality = ce.get_cardinality()
-
- if isinstance(ce, OWLObjectMinCardinality):
- comparator = ">="
- elif isinstance(ce, OWLObjectMaxCardinality):
- comparator = "<="
- elif isinstance(ce, OWLObjectExactCardinality):
- comparator = "="
- else:
- raise ValueError(ce)
-
- self.append(f"{{ SELECT {subject_variable} WHERE {{ ")
- self.append_triple(subject_variable, property_expression, object_variable)
-
- filler = ce.get_filler()
- with self.stack_variable(object_variable):
- self.process(filler)
-
- self.append(f" }} GROUP BY {subject_variable}"
- f" HAVING ( COUNT ( {object_variable} ) {comparator} {cardinality} ) }}")
-
- # an overload of process function
- # this overload is responsible for handling the exists operator combined with SELF
- # general case: ∃r.SELF
- @process.register
- def _(self, ce: OWLObjectHasSelf):
- subject = self.current_variable
- property = ce.get_property()
- self.append_triple(subject, property.get_named_property(), subject)
-
- # an overload of process function
- # this overload is responsible for handling the one of case (e.g., { john, jane }
- # general case: { a1, ..., an }
- @process.register
- def _(self, ce: OWLObjectOneOf):
- subject = self.current_variable
- if self.modal_depth == 1:
- self.append_triple(subject, "?p", "?o")
-
- self.append(f" FILTER ( {subject} IN ( ")
- first = True
- for ind in ce.individuals():
- if first:
- first = False
- else:
- self.append(",")
- assert isinstance(ind, OWLNamedIndividual)
- self.append(f"<{ind.to_string_id()}>")
- self.append(f" ) )")
-
- @process.register
- def _(self, ce: OWLDataSomeValuesFrom):
- object_variable = self.mapping.new_individual_variable()
- property_expression = ce.get_property()
- assert isinstance(property_expression, OWLDataProperty)
- self.append_triple(self.current_variable, property_expression, object_variable)
- filler = ce.get_filler()
- with self.stack_variable(object_variable):
- self.process(filler)
-
- @process.register
- def _(self, ce: OWLDataAllValuesFrom):
- subject = self.current_variable
- object_variable = self.mapping.new_individual_variable()
- property_expression = ce.get_property()
- assert isinstance(property_expression, OWLDataProperty)
- predicate = property_expression.to_string_id()
- filler = ce.get_filler()
-
- self.append_triple(self.current_variable, predicate, object_variable)
-
- var = self.mapping.new_individual_variable()
- cnt_var1 = self.new_count_var()
- self.append(f"{{ SELECT {subject} ( COUNT( {var} ) AS {cnt_var1} ) WHERE {{ ")
- self.append_triple(subject, predicate, var)
- with self.stack_variable(var):
- self.process(filler)
- self.append(f" }} GROUP BY {subject} }}")
-
- var = self.mapping.new_individual_variable()
- cnt_var2 = self.new_count_var()
- self.append(f"{{ SELECT {subject} ( COUNT( {var} ) AS {cnt_var2} ) WHERE {{ ")
- self.append_triple(subject, predicate, var)
- self.append(f" }} GROUP BY {subject} }}")
-
- self.append(f" FILTER( {cnt_var1} = {cnt_var2} )")
-
- @process.register
- def _(self, ce: OWLDataHasValue):
- property_expression = ce.get_property()
- value = ce.get_filler()
- assert isinstance(value, OWLDataProperty)
- self.append_triple(self.current_variable, property_expression, value)
-
- @process.register
- def _(self, node: OWLDatatype):
- if node != TopOWLDatatype:
- self.append(f" FILTER ( DATATYPE ( {self.current_variable} = <{node.to_string_id()}> ) ) ")
-
- @process.register
- def _(self, node: OWLDataOneOf):
- subject = self.current_variable
- if self.modal_depth == 1:
- self.append_triple(subject, "?p", "?o")
- self.append(f" FILTER ( {subject} IN ( ")
- first = True
- for value in node.values():
- if first:
- first = False
- else:
- self.append(",")
- if value:
- self.append(self.render(value))
- self.append(f" ) ) ")
-
- @process.register
- def _(self, node: OWLDatatypeRestriction):
- frs = node.get_facet_restrictions()
-
- for fr in frs:
- facet = fr.get_facet()
- value = fr.get_facet_value()
-
- if facet in _Variable_facet_comp:
- self.append(f' FILTER ( {self.current_variable} {_Variable_facet_comp[facet]}'
- f' "{value.get_literal()}"^^<{value.get_datatype().to_string_id()}> ) ')
-
-
-
-
-
-[docs]
- def append_triple(self, subject, predicate, object_):
- self.append(self.triple(subject, predicate, object_))
-
-
-
-
-
-
-[docs]
- def triple(self, subject, predicate, object_):
- return f"{self._maybe_quote(subject)} {self._maybe_quote_p(predicate)} {self._maybe_render(object_)} . "
-
-
-
-[docs]
- def as_query(self,
- root_variable: str,
- ce: OWLClassExpression,
- count: bool = False,
- values: Optional[Iterable[OWLNamedIndividual]] = None,
- named_individuals: bool = False)->str:
- """
- root variable: the variable that will be projected
- ce: the class expression to be transformed to a SPARQL query
- count: True, counts the results ; False, projects the individuals
- values: positive or negative examples from a class expression problem
- named_individuals: if set to True, the generated SPARQL query will return only entities that are instances
- of owl:NamedIndividual
-
- """
-
- qs = ["SELECT"]
- tp = self.convert(root_variable, ce, named_individuals)
- if count:
- qs.append(f" ( COUNT ( DISTINCT {root_variable} ) AS ?cnt ) WHERE {{ ")
- else:
- qs.append(f" DISTINCT {root_variable} WHERE {{ ")
- if values is not None and root_variable.startswith("?"):
- q = [f"VALUES {root_variable} {{ "]
- for x in values:
- q.append(f"<{x.to_string_id()}>")
- q.append(f"}} . ")
- qs.extend(q)
- qs.extend(tp)
- qs.append(f" }}")
-
-
- query = "\n".join(qs)
- parseQuery(query)
- return query
-
-
-
-
-converter = Owl2SparqlConverter()
-
-
-
-[docs]
-def owl_expression_to_sparql(root_variable: str = "?x",
- expression: OWLClassExpression = None,
- values: Optional[Iterable[OWLNamedIndividual]] = None,
- named_individuals: bool = False)->str:
- """Convert an OWL Class Expression (https://www.w3.org/TR/owl2-syntax/#Class_Expressions) into a SPARQL query
- root variable: the variable that will be projected
- expression: the class expression to be transformed to a SPARQL query
-
- values: positive or negative examples from a class expression problem. Unclear
- named_individuals: if set to True, the generated SPARQL query will return only entities
- that are instances of owl:NamedIndividual
- """
- assert expression is not None, "expression cannot be None"
- return converter.as_query(root_variable, expression, False, values, named_individuals)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/_modules/owlapy/owl_axiom.html b/_modules/owlapy/owl_axiom.html
index da294d7..be05a0b 100644
--- a/_modules/owlapy/owl_axiom.html
+++ b/_modules/owlapy/owl_axiom.html
@@ -82,7 +82,7 @@ Source code for owlapy.owl_axiom
from .owl_property import OWLDataPropertyExpression, OWLObjectPropertyExpression
from .owlobject import OWLObject, OWLEntity
from .types import OWLDatatype, OWLDataRange
-from .has import HasOperands
+from .meta_classes import HasOperands
from .owl_property import OWLPropertyExpression, OWLProperty
from .owl_class_expression import OWLClassExpression, OWLClass
from .owl_individual import OWLIndividual
diff --git a/_modules/owlapy/owl_class_expression.html b/_modules/owlapy/owl_class_expression.html
index 69d0b05..0836858 100644
--- a/_modules/owlapy/owl_class_expression.html
+++ b/_modules/owlapy/owl_class_expression.html
@@ -78,9 +78,14 @@
Source code for owlapy.owl_class_expression
from abc import abstractmethod, ABCMeta
from .owlobject import OWLObject, OWLEntity
-from .has import HasOperands
+from .meta_classes import HasOperands
from typing import Final, Iterable, Sequence
from .ranges import OWLPropertyRange, OWLDataRange
+from .owl_literal import OWLLiteral
+from typing import Final, Sequence, Union, Iterable
+from .owl_property import OWLDataPropertyExpression, OWLObjectProperty, OWLDataProperty
+
+from owlapy.vocab import OWLRDFVocabulary, XSDVocabulary
@@ -367,6 +372,118 @@ Source code for owlapy.owl_class_expression
_operands: Sequence[OWLClassExpression]
+
+
+
+[docs]
+class OWLDataComplementOf(OWLDataRange):
+ """Represents DataComplementOf in the OWL 2 Specification."""
+ type_index: Final = 4002
+
+ _data_range: OWLDataRange
+
+ def __init__(self, data_range: OWLDataRange):
+ """
+ Args:
+ data_range: Data range to complement.
+ """
+ self._data_range = data_range
+
+
+[docs]
+ def get_data_range(self) -> OWLDataRange:
+ """
+ Returns:
+ The wrapped data range.
+ """
+ return self._data_range
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._data_range == other._data_range
+ return NotImplemented
+
+
+
+
+
+
+
+[docs]
+class OWLNaryDataRange(OWLDataRange, HasOperands[OWLDataRange]):
+ """OWLNaryDataRange."""
+ __slots__ = ()
+
+ _operands: Sequence[OWLDataRange]
+
+ def __init__(self, operands: Iterable[OWLDataRange]):
+ """
+ Args:
+ operands: Data ranges.
+ """
+ self._operands = tuple(operands)
+
+
+[docs]
+ def operands(self) -> Iterable[OWLDataRange]:
+ # documented in parent
+ yield from self._operands
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) == type(self):
+ return self._operands == other._operands
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+class OWLDataUnionOf(OWLNaryDataRange):
+ """Represents a DataUnionOf data range in the OWL 2 Specification."""
+ __slots__ = '_operands'
+ type_index: Final = 4005
+
+ _operands: Sequence[OWLDataRange]
+
+
+[docs]
+class OWLDataIntersectionOf(OWLNaryDataRange):
+ """Represents DataIntersectionOf in the OWL 2 Specification."""
+ __slots__ = '_operands'
+ type_index: Final = 4004
+
+ _operands: Sequence[OWLDataRange]
+
+
+
+OWLThing: Final = OWLClass(OWLRDFVocabulary.OWL_THING.get_iri()) #: : :The OWL Class corresponding to owl:Thing
+OWLNothing: Final = OWLClass(OWLRDFVocabulary.OWL_NOTHING.get_iri()) #: : :The OWL Class corresponding to owl:Nothing
diff --git a/_modules/owlapy/owl_data.html b/_modules/owlapy/owl_data.html
deleted file mode 100644
index d959e54..0000000
--- a/_modules/owlapy/owl_data.html
+++ /dev/null
@@ -1,428 +0,0 @@
-
-
-
-
-
- owlapy.owl_data — OWLAPY 0.1.2 documentation
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Source code for owlapy.owl_data
-from .ranges import OWLDataRange
-
-from .owl_restriction import OWLHasValueRestriction, OWLDataRestriction, OWLDataCardinalityRestriction, OWLQuantifiedDataRestriction
-from .owl_literal import OWLLiteral
-from .has import HasOperands
-from typing import Final, Sequence, Union, Iterable
-from .owl_property import OWLDataPropertyExpression
-from .owl_class_expression import OWLClassExpression
-
-
-[docs]
-class OWLDataComplementOf(OWLDataRange):
- """Represents DataComplementOf in the OWL 2 Specification."""
- type_index: Final = 4002
-
- _data_range: OWLDataRange
-
- def __init__(self, data_range: OWLDataRange):
- """
- Args:
- data_range: Data range to complement.
- """
- self._data_range = data_range
-
-
-[docs]
- def get_data_range(self) -> OWLDataRange:
- """
- Returns:
- The wrapped data range.
- """
- return self._data_range
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._data_range == other._data_range
- return NotImplemented
-
-
-
-
-
-
-[docs]
-class OWLDataHasValue(OWLHasValueRestriction[OWLLiteral], OWLDataRestriction):
- """Represents DataHasValue restrictions in the OWL 2 Specification."""
- __slots__ = '_property'
-
- type_index: Final = 3014
-
- _property: OWLDataPropertyExpression
-
- def __init__(self, property: OWLDataPropertyExpression, value: OWLLiteral):
- """Gets an OWLDataHasValue restriction.
-
- Args:
- property: The data property that the restriction acts along.
- filler: The literal value.
-
- Returns:
- An OWLDataHasValue restriction along the specified property with the specified literal.
- """
- super().__init__(value)
- self._property = property
-
-
-[docs]
- def __repr__(self):
- return f"OWLDataHasValue(property={repr(self._property)},value={repr(self._v)})"
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._v == other._v and self._property == other._property
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def as_some_values_from(self) -> OWLClassExpression:
- """A convenience method that obtains this restriction as an existential restriction with a nominal filler.
-
- Returns:
- The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
- """
- return OWLDataSomeValuesFrom(self.get_property(), OWLDataOneOf(self.get_filler()))
-
-
-
-[docs]
- def get_property(self) -> OWLDataPropertyExpression:
- # documented in parent
- return self._property
-
-
-
-
-[docs]
-class OWLDataMaxCardinality(OWLDataCardinalityRestriction):
- """Represents DataMaxCardinality restrictions in the OWL 2 Specification."""
- __slots__ = '_cardinality', '_filler', '_property'
-
- type_index: Final = 3017
-
- def __init__(self, cardinality: int, property: OWLDataPropertyExpression, filler: OWLDataRange):
- """
- Args:
- cardinality: Cannot be negative.
- property: The property that the restriction acts along.
- filler: Data range for restriction.
-
- Returns:
- A DataMaxCardinality on the specified property.
- """
- super().__init__(cardinality, property, filler)
-
-
-[docs]
-class OWLDataMinCardinality(OWLDataCardinalityRestriction):
- """Represents DataMinCardinality restrictions in the OWL 2 Specification."""
- __slots__ = '_cardinality', '_filler', '_property'
-
- type_index: Final = 3015
-
- def __init__(self, cardinality: int, property: OWLDataPropertyExpression, filler: OWLDataRange):
- """
- Args:
- cardinality: Cannot be negative.
- property: The property that the restriction acts along.
- filler: Data range for restriction.
-
- Returns:
- A DataMinCardinality on the specified property.
- """
- super().__init__(cardinality, property, filler)
-
-
-[docs]
-class OWLDataOneOf(OWLDataRange, HasOperands[OWLLiteral]):
- """Represents DataOneOf in the OWL 2 Specification."""
- type_index: Final = 4003
-
- _values: Sequence[OWLLiteral]
-
- def __init__(self, values: Union[OWLLiteral, Iterable[OWLLiteral]]):
- if isinstance(values, OWLLiteral):
- self._values = values,
- else:
- for _ in values:
- assert isinstance(_, OWLLiteral)
- self._values = tuple(values)
-
-
-[docs]
- def values(self) -> Iterable[OWLLiteral]:
- """Gets the values that are in the oneOf.
-
- Returns:
- The values of this {@code DataOneOf} class expression.
- """
- yield from self._values
-
-
-
-[docs]
- def operands(self) -> Iterable[OWLLiteral]:
- # documented in parent
- yield from self.values()
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) == type(self):
- return self._values == other._values
- return NotImplemented
-
-
-
-
-
-
-[docs]
-class OWLDataSomeValuesFrom(OWLQuantifiedDataRestriction):
- """Represents a DataSomeValuesFrom restriction in the OWL 2 Specification."""
- __slots__ = '_property'
-
- type_index: Final = 3012
-
- _property: OWLDataPropertyExpression
-
- def __init__(self, property: OWLDataPropertyExpression, filler: OWLDataRange):
- """Gets an OWLDataSomeValuesFrom restriction.
-
- Args:
- property: The data property that the restriction acts along.
- filler: The data range that is the filler.
-
- Returns:
- An OWLDataSomeValuesFrom restriction along the specified property with the specified filler.
- """
- super().__init__(filler)
- self._property = property
-
-
-[docs]
- def __repr__(self):
- return f"OWLDataSomeValuesFrom(property={repr(self._property)},filler={repr(self._filler)})"
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._filler == other._filler and self._property == other._property
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def get_property(self) -> OWLDataPropertyExpression:
- # documented in parent
- return self._property
-
-
-
-[docs]
-class OWLNaryDataRange(OWLDataRange, HasOperands[OWLDataRange]):
- """OWLNaryDataRange."""
- __slots__ = ()
-
- _operands: Sequence[OWLDataRange]
-
- def __init__(self, operands: Iterable[OWLDataRange]):
- """
- Args:
- operands: Data ranges.
- """
- self._operands = tuple(operands)
-
-
-[docs]
- def operands(self) -> Iterable[OWLDataRange]:
- # documented in parent
- yield from self._operands
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) == type(self):
- return self._operands == other._operands
- return NotImplemented
-
-
-
-
-
-
-[docs]
-class OWLDataUnionOf(OWLNaryDataRange):
- """Represents a DataUnionOf data range in the OWL 2 Specification."""
- __slots__ = '_operands'
- type_index: Final = 4005
-
- _operands: Sequence[OWLDataRange]
-
-
-[docs]
-class OWLDataIntersectionOf(OWLNaryDataRange):
- """Represents DataIntersectionOf in the OWL 2 Specification."""
- __slots__ = '_operands'
- type_index: Final = 4004
-
- _operands: Sequence[OWLDataRange]
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/_modules/owlapy/owl_literal.html b/_modules/owlapy/owl_literal.html
index 25c32be..77c658f 100644
--- a/_modules/owlapy/owl_literal.html
+++ b/_modules/owlapy/owl_literal.html
@@ -83,7 +83,6 @@ Source code for owlapy.owl_literal
from .types import OWLDatatype
from datetime import datetime, date
from pandas import Timedelta
-from .owl_class_expression import OWLClass
from owlapy.vocab import OWLRDFVocabulary, XSDVocabulary
from .owl_property import OWLObjectProperty, OWLDataProperty
@@ -619,8 +618,6 @@ Source code for owlapy.owl_literal
def __repr__(self):
return f'OWLLiteral({repr(self._v)}, {self._datatype})'
-OWLThing: Final = OWLClass(OWLRDFVocabulary.OWL_THING.get_iri()) #: : :The OWL Class corresponding to owl:Thing
-OWLNothing: Final = OWLClass(OWLRDFVocabulary.OWL_NOTHING.get_iri()) #: : :The OWL Class corresponding to owl:Nothing
#: the built in top object property
OWLTopObjectProperty: Final = OWLObjectProperty(OWLRDFVocabulary.OWL_TOP_OBJECT_PROPERTY.get_iri())
#: the built in bottom object property
diff --git a/_modules/owlapy/owl_restriction.html b/_modules/owlapy/owl_restriction.html
index 017c2a1..8b4bbc7 100644
--- a/_modules/owlapy/owl_restriction.html
+++ b/_modules/owlapy/owl_restriction.html
@@ -77,14 +77,24 @@
Source code for owlapy.owl_restriction
from abc import ABCMeta, abstractmethod
-from .has import HasFiller, HasCardinality
-from typing import TypeVar, Generic, Final
+from .meta_classes import HasFiller, HasCardinality, HasOperands
+from typing import TypeVar, Generic, Final, Sequence, Union, Iterable
from .owl_class_expression import OWLAnonymousClassExpression, OWLClassExpression, OWLObjectIntersectionOf
from .owl_property import OWLPropertyExpression, OWLObjectPropertyExpression, OWLDataPropertyExpression
from .ranges import OWLPropertyRange, OWLDataRange
+from .owl_literal import OWLLiteral
+from .owl_individual import OWLIndividual
+from .types import OWLDatatype
+from .owlobject import OWLObject
+from owlapy.vocab import OWLRDFVocabulary, XSDVocabulary, OWLFacet
+from datetime import datetime, date
+from pandas import Timedelta
_T = TypeVar('_T') #:
_F = TypeVar('_F', bound=OWLPropertyRange) #:
+
+Literals = Union['OWLLiteral', int, float, bool, Timedelta, datetime, date, str] #:
+
[docs]
class OWLRestriction(OWLAnonymousClassExpression):
@@ -507,6 +517,7 @@ Source code for owlapy.owl_restriction
+
[docs]
class OWLQuantifiedDataRestriction(OWLQuantifiedRestriction[OWLDataRange],
@@ -576,6 +587,9 @@ Source code for owlapy.owl_restriction
return self._property
+
+
+
[docs]
class OWLDataCardinalityRestriction(OWLCardinalityRestriction[OWLDataRange],
@@ -622,6 +636,8 @@ Source code for owlapy.owl_restriction
+
+
[docs]
class OWLDataExactCardinality(OWLDataCardinalityRestriction):
@@ -654,6 +670,439 @@ Source code for owlapy.owl_restriction
return OWLObjectIntersectionOf((OWLDataMinCardinality(*args), OWLDataMaxCardinality(*args)))
+
+
+[docs]
+class OWLDataMaxCardinality(OWLDataCardinalityRestriction):
+ """Represents DataMaxCardinality restrictions in the OWL 2 Specification."""
+ __slots__ = '_cardinality', '_filler', '_property'
+
+ type_index: Final = 3017
+
+ def __init__(self, cardinality: int, property: OWLDataPropertyExpression, filler: OWLDataRange):
+ """
+ Args:
+ cardinality: Cannot be negative.
+ property: The property that the restriction acts along.
+ filler: Data range for restriction.
+
+ Returns:
+ A DataMaxCardinality on the specified property.
+ """
+ super().__init__(cardinality, property, filler)
+
+
+[docs]
+class OWLDataMinCardinality(OWLDataCardinalityRestriction):
+ """Represents DataMinCardinality restrictions in the OWL 2 Specification."""
+ __slots__ = '_cardinality', '_filler', '_property'
+
+ type_index: Final = 3015
+
+ def __init__(self, cardinality: int, property: OWLDataPropertyExpression, filler: OWLDataRange):
+ """
+ Args:
+ cardinality: Cannot be negative.
+ property: The property that the restriction acts along.
+ filler: Data range for restriction.
+
+ Returns:
+ A DataMinCardinality on the specified property.
+ """
+ super().__init__(cardinality, property, filler)
+
+
+
+
+[docs]
+class OWLDataSomeValuesFrom(OWLQuantifiedDataRestriction):
+ """Represents a DataSomeValuesFrom restriction in the OWL 2 Specification."""
+ __slots__ = '_property'
+
+ type_index: Final = 3012
+
+ _property: OWLDataPropertyExpression
+
+ def __init__(self, property: OWLDataPropertyExpression, filler: OWLDataRange):
+ """Gets an OWLDataSomeValuesFrom restriction.
+
+ Args:
+ property: The data property that the restriction acts along.
+ filler: The data range that is the filler.
+
+ Returns:
+ An OWLDataSomeValuesFrom restriction along the specified property with the specified filler.
+ """
+ super().__init__(filler)
+ self._property = property
+
+
+[docs]
+ def __repr__(self):
+ return f"OWLDataSomeValuesFrom(property={repr(self._property)},filler={repr(self._filler)})"
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._filler == other._filler and self._property == other._property
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def get_property(self) -> OWLDataPropertyExpression:
+ # documented in parent
+ return self._property
+
+
+
+
+[docs]
+class OWLDataHasValue(OWLHasValueRestriction[OWLLiteral], OWLDataRestriction):
+ """Represents DataHasValue restrictions in the OWL 2 Specification."""
+ __slots__ = '_property'
+
+ type_index: Final = 3014
+
+ _property: OWLDataPropertyExpression
+
+ def __init__(self, property: OWLDataPropertyExpression, value: OWLLiteral):
+ """Gets an OWLDataHasValue restriction.
+
+ Args:
+ property: The data property that the restriction acts along.
+ filler: The literal value.
+
+ Returns:
+ An OWLDataHasValue restriction along the specified property with the specified literal.
+ """
+ super().__init__(value)
+ self._property = property
+
+
+[docs]
+ def __repr__(self):
+ return f"OWLDataHasValue(property={repr(self._property)},value={repr(self._v)})"
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._v == other._v and self._property == other._property
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def as_some_values_from(self) -> OWLClassExpression:
+ """A convenience method that obtains this restriction as an existential restriction with a nominal filler.
+
+ Returns:
+ The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+ """
+ return OWLDataSomeValuesFrom(self.get_property(), OWLDataOneOf(self.get_filler()))
+
+
+
+[docs]
+ def get_property(self) -> OWLDataPropertyExpression:
+ # documented in parent
+ return self._property
+
+
+
+
+
+
+[docs]
+class OWLObjectOneOf(OWLAnonymousClassExpression, HasOperands[OWLIndividual]):
+ """Represents an ObjectOneOf class expression in the OWL 2 Specification."""
+ __slots__ = '_values'
+ type_index: Final = 3004
+
+ def __init__(self, values: Union[OWLIndividual, Iterable[OWLIndividual]]):
+ if isinstance(values, OWLIndividual):
+ self._values = values,
+ else:
+ for _ in values:
+ assert isinstance(_, OWLIndividual)
+ self._values = tuple(values)
+
+
+[docs]
+ def individuals(self) -> Iterable[OWLIndividual]:
+ """Gets the individuals that are in the oneOf. These individuals represent the exact instances (extension)
+ of this class expression.
+
+ Returns:
+ The individuals that are the values of this {@code ObjectOneOf} class expression.
+ """
+ yield from self._values
+
+
+
+[docs]
+ def operands(self) -> Iterable[OWLIndividual]:
+ # documented in parent
+ yield from self.individuals()
+
+
+
+[docs]
+ def as_object_union_of(self) -> OWLClassExpression:
+ """Simplifies this enumeration to a union of singleton nominals.
+
+ Returns:
+ This enumeration in a more standard DL form.
+ simp({a}) = {a} simp({a0, ... , {an}) = unionOf({a0}, ... , {an})
+ """
+ if len(self._values) == 1:
+ return self
+ return OWLObjectUnionOf(map(lambda _: OWLObjectOneOf(_), self.individuals()))
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) == type(self):
+ return self._values == other._values
+ return NotImplemented
+
+
+
+
+
+
+
+
+[docs]
+class OWLDataOneOf(OWLDataRange, HasOperands[OWLLiteral]):
+ """Represents DataOneOf in the OWL 2 Specification."""
+ type_index: Final = 4003
+
+ _values: Sequence[OWLLiteral]
+
+ def __init__(self, values: Union[OWLLiteral, Iterable[OWLLiteral]]):
+ if isinstance(values, OWLLiteral):
+ self._values = values,
+ else:
+ for _ in values:
+ assert isinstance(_, OWLLiteral)
+ self._values = tuple(values)
+
+
+[docs]
+ def values(self) -> Iterable[OWLLiteral]:
+ """Gets the values that are in the oneOf.
+
+ Returns:
+ The values of this {@code DataOneOf} class expression.
+ """
+ yield from self._values
+
+
+
+[docs]
+ def operands(self) -> Iterable[OWLLiteral]:
+ # documented in parent
+ yield from self.values()
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) == type(self):
+ return self._values == other._values
+ return NotImplemented
+
+
+
+
+
+
+
+
+[docs]
+class OWLObjectHasValue(OWLHasValueRestriction[OWLIndividual], OWLObjectRestriction):
+ """Represents an ObjectHasValue class expression in the OWL 2 Specification."""
+ __slots__ = '_property', '_v'
+ type_index: Final = 3007
+
+ _property: OWLObjectPropertyExpression
+ _v: OWLIndividual
+
+ def __init__(self, property: OWLObjectPropertyExpression, individual: OWLIndividual):
+ """
+ Args:
+ property: The property that the restriction acts along.
+ individual: Individual for restriction.
+
+ Returns:
+ A HasValue restriction with specified property and value
+ """
+ super().__init__(individual)
+ self._property = property
+
+
+[docs]
+ def get_property(self) -> OWLObjectPropertyExpression:
+ # documented in parent
+ return self._property
+
+
+
+[docs]
+ def as_some_values_from(self) -> OWLClassExpression:
+ """A convenience method that obtains this restriction as an existential restriction with a nominal filler.
+
+ Returns:
+ The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+ """
+ return OWLObjectSomeValuesFrom(self.get_property(), OWLObjectOneOf(self.get_filler()))
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLObjectHasValue(property={self.get_property()}, individual={self._v})'
+
+
+
+[docs]
+class OWLDatatypeRestriction(OWLDataRange):
+ """Represents a DatatypeRestriction data range in the OWL 2 Specification."""
+ __slots__ = '_type', '_facet_restrictions'
+
+ type_index: Final = 4006
+
+ _type: OWLDatatype
+ _facet_restrictions: Sequence['OWLFacetRestriction']
+
+ def __init__(self, type_: OWLDatatype, facet_restrictions: Union['OWLFacetRestriction',
+ Iterable['OWLFacetRestriction']]):
+ self._type = type_
+ if isinstance(facet_restrictions, OWLFacetRestriction):
+ facet_restrictions = facet_restrictions,
+ self._facet_restrictions = tuple(facet_restrictions)
+
+
+
+
+
+[docs]
+ def get_facet_restrictions(self) -> Sequence['OWLFacetRestriction']:
+ return self._facet_restrictions
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._type == other._type \
+ and self._facet_restrictions == other._facet_restrictions
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLDatatypeRestriction({repr(self._type)}, {repr(self._facet_restrictions)})'
+
+
+
+[docs]
+class OWLFacetRestriction(OWLObject):
+ """A facet restriction is used to restrict a particular datatype."""
+
+ __slots__ = '_facet', '_literal'
+
+ type_index: Final = 4007
+
+ _facet: OWLFacet
+ _literal: 'OWLLiteral'
+
+ def __init__(self, facet: OWLFacet, literal: Literals):
+ self._facet = facet
+ if isinstance(literal, OWLLiteral):
+ self._literal = literal
+ else:
+ self._literal = OWLLiteral(literal)
+
+
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._facet == other._facet and self._literal == other._literal
+ return NotImplemented
+
+
+
+
+
+
+
+
+
diff --git a/_modules/owlapy/owlobject.html b/_modules/owlapy/owlobject.html
index 46a6dc3..31f2af0 100644
--- a/_modules/owlapy/owlobject.html
+++ b/_modules/owlapy/owlobject.html
@@ -78,8 +78,7 @@
Source code for owlapy.owlobject
from abc import abstractmethod, ABCMeta
from typing import Optional
-from .has import HasIRI
-# from .iri import IRI
+from .meta_classes import HasIRI
class OWLObject(metaclass=ABCMeta):
"""Base interface for OWL objects"""
diff --git a/_modules/owlapy/parser.html b/_modules/owlapy/parser.html
index b45dadf..07725dd 100644
--- a/_modules/owlapy/parser.html
+++ b/_modules/owlapy/parser.html
@@ -88,17 +88,17 @@ Source code for owlapy.parser
from .vocab import OWLFacet, OWLRDFVocabulary
-from owlapy.model import OWLObjectHasSelf, OWLObjectIntersectionOf, OWLObjectMinCardinality, OWLObjectOneOf, \
- OWLObjectProperty, OWLObjectPropertyExpression, OWLObjectSomeValuesFrom, OWLObjectUnionOf, OWLClass, IRI, \
+from owlapy.model import OWLObjectHasSelf, OWLObjectIntersectionOf, OWLObjectMinCardinality, OWLObjectProperty, OWLObjectPropertyExpression, OWLObjectSomeValuesFrom, OWLObjectUnionOf, OWLClass, IRI, \
OWLClassExpression, OWLDataProperty, OWLNamedIndividual, OWLObjectComplementOf, OWLObjectExactCardinality, \
- OWLObjectHasValue, OWLQuantifiedDataRestriction, OWLQuantifiedObjectRestriction, StringOWLDatatype, \
+ OWLQuantifiedDataRestriction, OWLQuantifiedObjectRestriction, StringOWLDatatype, \
DateOWLDatatype, DateTimeOWLDatatype, DoubleOWLDatatype, DurationOWLDatatype, IntegerOWLDatatype, \
- OWLDataSomeValuesFrom, OWLDatatypeRestriction, OWLFacetRestriction, OWLDataExactCardinality, \
- OWLDataMaxCardinality, OWLObjectMaxCardinality, OWLDataIntersectionOf, OWLDataMinCardinality, OWLDataHasValue, \
- OWLLiteral, OWLDataRange, OWLDataUnionOf, OWLDataOneOf, OWLDatatype, OWLObjectCardinalityRestriction, \
- OWLDataCardinalityRestriction, OWLObjectAllValuesFrom, OWLDataAllValuesFrom, OWLDataComplementOf, BooleanOWLDatatype
-
+ OWLDataSomeValuesFrom, OWLDataExactCardinality, \
+ OWLDataMaxCardinality, OWLObjectMaxCardinality, OWLDataMinCardinality, OWLDataHasValue, \
+ OWLLiteral, OWLDataRange, OWLDataOneOf, OWLDatatype, OWLObjectCardinalityRestriction, \
+ OWLDataCardinalityRestriction, OWLObjectAllValuesFrom, OWLDataAllValuesFrom, BooleanOWLDatatype
+from owlapy.owl_class_expression import OWLDataIntersectionOf, OWLDataUnionOf, OWLDataComplementOf
+from owlapy.owl_restriction import OWLObjectHasValue, OWLDatatypeRestriction, OWLFacetRestriction, OWLObjectOneOf
MANCHESTER_GRAMMAR = Grammar(r"""
diff --git a/_modules/owlapy/render.html b/_modules/owlapy/render.html
index a7bb14d..f7edc64 100644
--- a/_modules/owlapy/render.html
+++ b/_modules/owlapy/render.html
@@ -89,16 +89,17 @@ Source code for owlapy.render
from .owl_class_expression import OWLClassExpression
# from owlapy.io import OWLObjectRenderer
-from owlapy.model import OWLLiteral, OWLNaryDataRange, OWLObject, OWLClass, OWLObjectSomeValuesFrom, \
+from owlapy.model import (OWLLiteral, OWLObject, OWLClass, OWLObjectSomeValuesFrom, \
OWLObjectAllValuesFrom, OWLObjectUnionOf, OWLBooleanClassExpression, OWLNaryBooleanClassExpression, \
OWLObjectIntersectionOf, OWLObjectComplementOf, OWLRestriction, \
- OWLObjectMinCardinality, OWLObjectExactCardinality, OWLObjectMaxCardinality, OWLObjectHasSelf, OWLObjectHasValue, \
- OWLObjectOneOf, OWLNamedIndividual, OWLEntity, IRI, OWLPropertyExpression, OWLDataSomeValuesFrom, \
- OWLFacetRestriction, OWLDatatypeRestriction, OWLDatatype, OWLDataAllValuesFrom, OWLDataComplementOf, \
- OWLDataUnionOf, OWLDataIntersectionOf, OWLDataHasValue, OWLDataOneOf, OWLDataMaxCardinality, \
- OWLDataMinCardinality, OWLDataExactCardinality
+ OWLObjectMinCardinality, OWLObjectExactCardinality, OWLObjectMaxCardinality, OWLObjectHasSelf,
+ OWLNamedIndividual, OWLEntity, IRI, OWLPropertyExpression, OWLDataSomeValuesFrom, \
+ OWLDatatype, OWLDataAllValuesFrom, \
+ OWLDataHasValue, OWLDataOneOf, OWLDataMaxCardinality, \
+ OWLDataMinCardinality, OWLDataExactCardinality)
from owlapy.vocab import OWLFacet
-
+from .owl_class_expression import OWLNaryDataRange, OWLDataComplementOf, OWLDataUnionOf, OWLDataIntersectionOf
+from .owl_restriction import OWLObjectHasValue, OWLFacetRestriction, OWLDatatypeRestriction, OWLObjectOneOf
_DL_SYNTAX = types.SimpleNamespace(
SUBCLASS="⊑",
diff --git a/_modules/owlapy/types.html b/_modules/owlapy/types.html
index 6726f4e..39278ca 100644
--- a/_modules/owlapy/types.html
+++ b/_modules/owlapy/types.html
@@ -79,7 +79,7 @@ Source code for owlapy.types
from .owlobject import OWLObject, OWLEntity
from .ranges import OWLDataRange
from .iri import IRI
-from .has import HasIRI
+from .meta_classes import HasIRI
from typing import Final, Union
diff --git a/_modules/owlapy/util.html b/_modules/owlapy/util.html
index fffccf4..b7caa68 100644
--- a/_modules/owlapy/util.html
+++ b/_modules/owlapy/util.html
@@ -83,14 +83,14 @@ Source code for owlapy.util
from .owl_property import OWLObjectInverseOf
from owlapy.model import HasIRI, OWLClassExpression, OWLClass, OWLObjectCardinalityRestriction, \
OWLObjectComplementOf, OWLNothing, OWLPropertyRange, OWLRestriction, OWLThing, OWLObjectSomeValuesFrom, \
- OWLObjectHasValue, OWLObjectMinCardinality, OWLObjectMaxCardinality, OWLObjectExactCardinality, OWLObjectHasSelf, \
- OWLObjectOneOf, OWLDataMaxCardinality, OWLDataMinCardinality, OWLDataExactCardinality, OWLDataHasValue, \
+ OWLObjectMinCardinality, OWLObjectMaxCardinality, OWLObjectExactCardinality, OWLObjectHasSelf, \
+ OWLDataMaxCardinality, OWLDataMinCardinality, OWLDataExactCardinality, OWLDataHasValue, \
OWLDataAllValuesFrom, OWLDataSomeValuesFrom, OWLObjectAllValuesFrom, HasFiller, HasCardinality, HasOperands, \
- OWLDatatypeRestriction, OWLDataComplementOf, OWLDatatype, OWLDataUnionOf, \
- OWLDataIntersectionOf, OWLDataOneOf, OWLFacetRestriction, OWLLiteral, OWLObjectIntersectionOf, \
- OWLDataCardinalityRestriction, OWLNaryBooleanClassExpression, OWLNaryDataRange, OWLObjectUnionOf, \
+ OWLDatatype,OWLDataOneOf, OWLLiteral, OWLObjectIntersectionOf, \
+ OWLDataCardinalityRestriction, OWLNaryBooleanClassExpression, OWLObjectUnionOf, \
OWLDataRange, OWLObject
-
+from .owl_class_expression import OWLDataComplementOf, OWLDataUnionOf, OWLDataIntersectionOf, OWLNaryDataRange
+from .owl_restriction import OWLObjectHasValue, OWLDatatypeRestriction, OWLFacetRestriction, OWLObjectOneOf
_HasIRI = TypeVar('_HasIRI', bound=HasIRI) #:
_HasIndex = TypeVar('_HasIndex', bound=HasIndex) #:
diff --git a/_modules/owlapy/vocab.html b/_modules/owlapy/vocab.html
index b1d7d88..3875e26 100644
--- a/_modules/owlapy/vocab.html
+++ b/_modules/owlapy/vocab.html
@@ -84,7 +84,7 @@ Source code for owlapy.vocab
from re import match
from owlapy import namespaces
-from .has import HasIRI
+from .meta_classes import HasIRI
from .iri import IRI
from owlapy.namespaces import Namespaces
diff --git a/_sources/autoapi/owlapy/has/index.rst.txt b/_sources/autoapi/owlapy/has/index.rst.txt
index 7eca705..dd74c6f 100644
--- a/_sources/autoapi/owlapy/has/index.rst.txt
+++ b/_sources/autoapi/owlapy/has/index.rst.txt
@@ -13,10 +13,6 @@ Classes
.. autoapisummary::
owlapy.has.HasIndex
- owlapy.has.HasIRI
- owlapy.has.HasOperands
- owlapy.has.HasFiller
- owlapy.has.HasCardinality
@@ -39,90 +35,3 @@ Classes
-.. py:class:: HasIRI
-
-
- Simple class to access the IRI.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: get_iri() -> IRI
- :abstractmethod:
-
- Gets the IRI of this object.
-
- :returns: The IRI of this object.
-
-
-
-.. py:class:: HasOperands
-
-
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ]
-
- An interface to objects that have a collection of operands.
-
- :param _T: Operand type.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: operands() -> Iterable[_T]
- :abstractmethod:
-
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
-
- :returns: The operands.
-
-
-
-.. py:class:: HasFiller
-
-
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ]
-
- An interface to objects that have a filler.
-
- :param _T: Filler type.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: get_filler() -> _T
- :abstractmethod:
-
- Gets the filler for this restriction. In the case of an object restriction this will be an individual, in
- the case of a data restriction this will be a constant (data value). For quantified restriction this will be
- a class expression or a data range.
-
- :returns: the value
-
-
-
-.. py:class:: HasCardinality
-
-
- An interface to objects that have a cardinality.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: get_cardinality() -> int
- :abstractmethod:
-
- Gets the cardinality of a restriction.
-
- :returns: The cardinality. A non-negative integer.
-
-
-
diff --git a/_sources/autoapi/owlapy/index.rst.txt b/_sources/autoapi/owlapy/index.rst.txt
index 4d8dc4f..da3e788 100644
--- a/_sources/autoapi/owlapy/index.rst.txt
+++ b/_sources/autoapi/owlapy/index.rst.txt
@@ -22,11 +22,11 @@ Submodules
has/index.rst
iri/index.rst
+ meta_classes/index.rst
namespaces/index.rst
owl_annotation/index.rst
owl_axiom/index.rst
owl_class_expression/index.rst
- owl_data/index.rst
owl_individual/index.rst
owl_literal/index.rst
owl_property/index.rst
diff --git a/_sources/autoapi/owlapy/meta_classes/index.rst.txt b/_sources/autoapi/owlapy/meta_classes/index.rst.txt
new file mode 100644
index 0000000..53e9d66
--- /dev/null
+++ b/_sources/autoapi/owlapy/meta_classes/index.rst.txt
@@ -0,0 +1,109 @@
+:py:mod:`owlapy.meta_classes`
+=============================
+
+.. py:module:: owlapy.meta_classes
+
+
+Module Contents
+---------------
+
+Classes
+~~~~~~~
+
+.. autoapisummary::
+
+ owlapy.meta_classes.HasIRI
+ owlapy.meta_classes.HasOperands
+ owlapy.meta_classes.HasFiller
+ owlapy.meta_classes.HasCardinality
+
+
+
+
+.. py:class:: HasIRI
+
+
+ Simple class to access the IRI.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: get_iri() -> IRI
+ :abstractmethod:
+
+ Gets the IRI of this object.
+
+ :returns: The IRI of this object.
+
+
+
+.. py:class:: HasOperands
+
+
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ]
+
+ An interface to objects that have a collection of operands.
+
+ :param _T: Operand type.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: operands() -> Iterable[_T]
+ :abstractmethod:
+
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ :returns: The operands.
+
+
+
+.. py:class:: HasFiller
+
+
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ]
+
+ An interface to objects that have a filler.
+
+ :param _T: Filler type.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: get_filler() -> _T
+ :abstractmethod:
+
+ Gets the filler for this restriction. In the case of an object restriction this will be an individual, in
+ the case of a data restriction this will be a constant (data value). For quantified restriction this will be
+ a class expression or a data range.
+
+ :returns: the value
+
+
+
+.. py:class:: HasCardinality
+
+
+ An interface to objects that have a cardinality.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: get_cardinality() -> int
+ :abstractmethod:
+
+ Gets the cardinality of a restriction.
+
+ :returns: The cardinality. A non-negative integer.
+
+
+
diff --git a/_sources/autoapi/owlapy/model/index.rst.txt b/_sources/autoapi/owlapy/model/index.rst.txt
index 2013ed0..ce77a09 100644
--- a/_sources/autoapi/owlapy/model/index.rst.txt
+++ b/_sources/autoapi/owlapy/model/index.rst.txt
@@ -67,6 +67,13 @@ Classes
owlapy.model.OWLObjectMaxCardinality
owlapy.model.OWLObjectExactCardinality
owlapy.model.OWLDataExactCardinality
+ owlapy.model.OWLDataMinCardinality
+ owlapy.model.OWLDataMaxCardinality
+ owlapy.model.OWLDataSomeValuesFrom
+ owlapy.model.OWLDataHasValue
+ owlapy.model.OWLDataOneOf
+ owlapy.model.OWLQuantifiedDataRestriction
+ owlapy.model.OWLDataCardinalityRestriction
owlapy.model.OWLNamedIndividual
owlapy.model.OWLIndividual
owlapy.model.OWLEquivalentClassesAxiom
@@ -77,23 +84,8 @@ Classes
owlapy.model.OWLObjectPropertyDomainAxiom
owlapy.model.OWLObjectPropertyRangeAxiom
owlapy.model.OWLDatatype
- owlapy.model.OWLDataMinCardinality
- owlapy.model.OWLDataMaxCardinality
- owlapy.model.OWLDataComplementOf
- owlapy.model.OWLDataIntersectionOf
- owlapy.model.OWLDataHasValue
- owlapy.model.OWLDataOneOf
- owlapy.model.OWLDataSomeValuesFrom
- owlapy.model.OWLDataUnionOf
- owlapy.model.OWLNaryDataRange
- owlapy.model.OWLQuantifiedDataRestriction
- owlapy.model.OWLDataCardinalityRestriction
owlapy.model.OWLLiteral
- owlapy.model.OWLObjectHasValue
- owlapy.model.OWLObjectOneOf
owlapy.model.OWLOntologyID
- owlapy.model.OWLDatatypeRestriction
- owlapy.model.OWLFacetRestriction
owlapy.model.OWLImportsDeclaration
owlapy.model.OWLOntology
owlapy.model.OWLOntologyChange
@@ -117,9 +109,9 @@ Attributes
.. autoapisummary::
- owlapy.model.Literals
owlapy.model.OWLThing
owlapy.model.OWLNothing
+ owlapy.model.Literals
owlapy.model.OWLTopObjectProperty
owlapy.model.OWLBottomObjectProperty
owlapy.model.OWLTopDataProperty
@@ -671,7 +663,7 @@ Attributes
.. py:class:: OWLNaryBooleanClassExpression(operands: Iterable[OWLClassExpression])
- Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
+ Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
OWLNaryBooleanClassExpression.
@@ -753,7 +745,7 @@ Attributes
.. py:class:: OWLObjectComplementOf(op: OWLClassExpression)
- Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
+ Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
Represents an ObjectComplementOf class expression in the OWL 2 Specification.
@@ -964,6 +956,16 @@ Attributes
+.. py:data:: OWLThing
+ :type: Final
+
+
+
+.. py:data:: OWLNothing
+ :type: Final
+
+
+
.. py:class:: OWLObjectPropertyExpression
@@ -1273,7 +1275,7 @@ Attributes
.. py:class:: OWLQuantifiedRestriction
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.has.HasFiller`\ [\ :py:obj:`_T`\ ]
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.meta_classes.HasFiller`\ [\ :py:obj:`_T`\ ]
Represents a quantified restriction.
@@ -1336,7 +1338,7 @@ Attributes
.. py:class:: OWLHasValueRestriction(value: _T)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.has.HasFiller`\ [\ :py:obj:`_T`\ ]
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.meta_classes.HasFiller`\ [\ :py:obj:`_T`\ ]
OWLHasValueRestriction.
@@ -1390,7 +1392,7 @@ Attributes
.. py:class:: OWLCardinalityRestriction(cardinality: int, filler: _F)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_F`\ ], :py:obj:`OWLQuantifiedRestriction`\ [\ :py:obj:`_F`\ ], :py:obj:`owlapy.has.HasCardinality`
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_F`\ ], :py:obj:`OWLQuantifiedRestriction`\ [\ :py:obj:`_F`\ ], :py:obj:`owlapy.meta_classes.HasCardinality`
Base interface for owl min and max cardinality restriction.
@@ -1619,6 +1621,228 @@ Attributes
+.. py:class:: OWLDataMinCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLDataCardinalityRestriction`
+
+ Represents DataMinCardinality restrictions in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_cardinality', '_filler', '_property')
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3015
+
+
+
+
+.. py:class:: OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLDataCardinalityRestriction`
+
+ Represents DataMaxCardinality restrictions in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_cardinality', '_filler', '_property')
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3017
+
+
+
+
+.. py:class:: OWLDataSomeValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLQuantifiedDataRestriction`
+
+ Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_property'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3012
+
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+
+ :returns: Property being restricted.
+
+
+
+.. py:class:: OWLDataHasValue(property: owlapy.owl_property.OWLDataPropertyExpression, value: owlapy.owl_literal.OWLLiteral)
+
+
+ Bases: :py:obj:`OWLHasValueRestriction`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ], :py:obj:`OWLDataRestriction`
+
+ Represents DataHasValue restrictions in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_property'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3014
+
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: as_some_values_from() -> owlapy.owl_class_expression.OWLClassExpression
+
+ A convenience method that obtains this restriction as an existential restriction with a nominal filler.
+
+ :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+
+
+ .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+
+ :returns: Property being restricted.
+
+
+
+.. py:class:: OWLDataOneOf(values: Union[owlapy.owl_literal.OWLLiteral, Iterable[owlapy.owl_literal.OWLLiteral]])
+
+
+ Bases: :py:obj:`owlapy.ranges.OWLDataRange`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ]
+
+ Represents DataOneOf in the OWL 2 Specification.
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4003
+
+
+
+ .. py:method:: values() -> Iterable[owlapy.owl_literal.OWLLiteral]
+
+ Gets the values that are in the oneOf.
+
+ :returns: The values of this {@code DataOneOf} class expression.
+
+
+ .. py:method:: operands() -> Iterable[owlapy.owl_literal.OWLLiteral]
+
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ :returns: The operands.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLQuantifiedDataRestriction(filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLQuantifiedRestriction`\ [\ :py:obj:`owlapy.ranges.OWLDataRange`\ ], :py:obj:`OWLDataRestriction`
+
+ Represents a quantified data restriction.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: get_filler() -> owlapy.ranges.OWLDataRange
+
+ Gets the filler for this restriction. In the case of an object restriction this will be an individual, in
+ the case of a data restriction this will be a constant (data value). For quantified restriction this will be
+ a class expression or a data range.
+
+ :returns: the value
+
+
+
+.. py:class:: OWLDataCardinalityRestriction(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLCardinalityRestriction`\ [\ :py:obj:`owlapy.ranges.OWLDataRange`\ ], :py:obj:`OWLQuantifiedDataRestriction`, :py:obj:`OWLDataRestriction`
+
+ Represents Data Property Cardinality Restrictions in the OWL 2 specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+
+ :returns: Property being restricted.
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+
.. py:class:: OWLNamedIndividual(iri: Union[owlapy.iri.IRI, str])
@@ -1782,7 +2006,7 @@ Attributes
-.. py:class:: OWLDatatype(iri: Union[owlapy.iri.IRI, owlapy.has.HasIRI])
+.. py:class:: OWLDatatype(iri: Union[owlapy.iri.IRI, owlapy.meta_classes.HasIRI])
Bases: :py:obj:`owlapy.owlobject.OWLEntity`, :py:obj:`owlapy.ranges.OWLDataRange`
@@ -1808,355 +2032,25 @@ Attributes
-.. py:class:: OWLDataMinCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+.. py:class:: OWLLiteral
- Bases: :py:obj:`owlapy.owl_restriction.OWLDataCardinalityRestriction`
+ Bases: :py:obj:`owlapy.owl_annotation.OWLAnnotationValue`
- Represents DataMinCardinality restrictions in the OWL 2 Specification.
+ Represents a Literal in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ('_cardinality', '_filler', '_property')
+ :value: ()
.. py:attribute:: type_index
:type: Final
- :value: 3015
+ :value: 4008
-
-.. py:class:: OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLDataCardinalityRestriction`
-
- Represents DataMaxCardinality restrictions in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: ('_cardinality', '_filler', '_property')
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3017
-
-
-
-
-.. py:class:: OWLDataComplementOf(data_range: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`owlapy.ranges.OWLDataRange`
-
- Represents DataComplementOf in the OWL 2 Specification.
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4002
-
-
-
- .. py:method:: get_data_range() -> owlapy.ranges.OWLDataRange
-
- :returns: The wrapped data range.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
-
-.. py:class:: OWLDataIntersectionOf(operands: Iterable[owlapy.ranges.OWLDataRange])
-
-
- Bases: :py:obj:`OWLNaryDataRange`
-
- Represents DataIntersectionOf in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_operands'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4004
-
-
-
-
-.. py:class:: OWLDataHasValue(property: owlapy.owl_property.OWLDataPropertyExpression, value: owlapy.owl_literal.OWLLiteral)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLHasValueRestriction`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ], :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
-
- Represents DataHasValue restrictions in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_property'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3014
-
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: as_some_values_from() -> owlapy.owl_class_expression.OWLClassExpression
-
- A convenience method that obtains this restriction as an existential restriction with a nominal filler.
-
- :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
-
-
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
-
- :returns: Property being restricted.
-
-
-
-.. py:class:: OWLDataOneOf(values: Union[owlapy.owl_literal.OWLLiteral, Iterable[owlapy.owl_literal.OWLLiteral]])
-
-
- Bases: :py:obj:`owlapy.ranges.OWLDataRange`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ]
-
- Represents DataOneOf in the OWL 2 Specification.
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4003
-
-
-
- .. py:method:: values() -> Iterable[owlapy.owl_literal.OWLLiteral]
-
- Gets the values that are in the oneOf.
-
- :returns: The values of this {@code DataOneOf} class expression.
-
-
- .. py:method:: operands() -> Iterable[owlapy.owl_literal.OWLLiteral]
-
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
-
- :returns: The operands.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-
-.. py:class:: OWLDataSomeValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLQuantifiedDataRestriction`
-
- Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_property'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3012
-
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
-
- :returns: Property being restricted.
-
-
-
-.. py:class:: OWLDataUnionOf(operands: Iterable[owlapy.ranges.OWLDataRange])
-
-
- Bases: :py:obj:`OWLNaryDataRange`
-
- Represents a DataUnionOf data range in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_operands'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4005
-
-
-
-
-.. py:class:: OWLNaryDataRange(operands: Iterable[owlapy.ranges.OWLDataRange])
-
-
- Bases: :py:obj:`owlapy.ranges.OWLDataRange`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.ranges.OWLDataRange`\ ]
-
- OWLNaryDataRange.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: operands() -> Iterable[owlapy.ranges.OWLDataRange]
-
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
-
- :returns: The operands.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
-
-.. py:class:: OWLQuantifiedDataRestriction(filler: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`OWLQuantifiedRestriction`\ [\ :py:obj:`owlapy.ranges.OWLDataRange`\ ], :py:obj:`OWLDataRestriction`
-
- Represents a quantified data restriction.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: get_filler() -> owlapy.ranges.OWLDataRange
-
- Gets the filler for this restriction. In the case of an object restriction this will be an individual, in
- the case of a data restriction this will be a constant (data value). For quantified restriction this will be
- a class expression or a data range.
-
- :returns: the value
-
-
-
-.. py:class:: OWLDataCardinalityRestriction(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`OWLCardinalityRestriction`\ [\ :py:obj:`owlapy.ranges.OWLDataRange`\ ], :py:obj:`OWLQuantifiedDataRestriction`, :py:obj:`OWLDataRestriction`
-
- Represents Data Property Cardinality Restrictions in the OWL 2 specification.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
-
- :returns: Property being restricted.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
-
-.. py:class:: OWLLiteral
-
-
- Bases: :py:obj:`owlapy.owl_annotation.OWLAnnotationValue`
-
- Represents a Literal in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4008
-
-
-
- .. py:method:: get_literal() -> str
+ .. py:method:: get_literal() -> str
Gets the lexical value of this literal. Note that the language tag is not included.
@@ -2280,100 +2174,6 @@ Attributes
-.. py:class:: OWLObjectHasValue(property: owlapy.owl_property.OWLObjectPropertyExpression, individual: owlapy.owl_individual.OWLIndividual)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLHasValueRestriction`\ [\ :py:obj:`owlapy.owl_individual.OWLIndividual`\ ], :py:obj:`owlapy.owl_restriction.OWLObjectRestriction`
-
- Represents an ObjectHasValue class expression in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: ('_property', '_v')
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3007
-
-
-
- .. py:method:: get_property() -> owlapy.owl_property.OWLObjectPropertyExpression
-
- :returns: Property being restricted.
-
-
- .. py:method:: as_some_values_from() -> owlapy.owl_class_expression.OWLClassExpression
-
- A convenience method that obtains this restriction as an existential restriction with a nominal filler.
-
- :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-
-.. py:class:: OWLObjectOneOf(values: Union[owlapy.owl_individual.OWLIndividual, Iterable[owlapy.owl_individual.OWLIndividual]])
-
-
- Bases: :py:obj:`owlapy.owl_class_expression.OWLAnonymousClassExpression`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.owl_individual.OWLIndividual`\ ]
-
- Represents an ObjectOneOf class expression in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_values'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3004
-
-
-
- .. py:method:: individuals() -> Iterable[owlapy.owl_individual.OWLIndividual]
-
- Gets the individuals that are in the oneOf. These individuals represent the exact instances (extension)
- of this class expression.
-
- :returns: The individuals that are the values of this {@code ObjectOneOf} class expression.
-
-
- .. py:method:: operands() -> Iterable[owlapy.owl_individual.OWLIndividual]
-
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
-
- :returns: The operands.
-
-
- .. py:method:: as_object_union_of() -> owlapy.owl_class_expression.OWLClassExpression
-
- Simplifies this enumeration to a union of singleton nominals.
-
- :returns: This enumeration in a more standard DL form.
- simp({a}) = {a} simp({a0, ... , {an}) = unionOf({a0}, ... , {an})
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-
.. py:class:: OWLOntologyID(ontology_iri: Optional[owlapy.iri.IRI] = None, version_iri: Optional[owlapy.iri.IRI] = None)
@@ -2425,90 +2225,10 @@ Attributes
-.. py:class:: OWLDatatypeRestriction(type_: owlapy.types.OWLDatatype, facet_restrictions: Union[OWLFacetRestriction, Iterable[OWLFacetRestriction]])
-
-
- Bases: :py:obj:`owlapy.owl_class_expression.OWLDataRange`
-
- Represents a DatatypeRestriction data range in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: ('_type', '_facet_restrictions')
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4006
-
-
-
- .. py:method:: get_datatype() -> owlapy.types.OWLDatatype
-
-
- .. py:method:: get_facet_restrictions() -> Sequence[OWLFacetRestriction]
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-
-.. py:class:: OWLFacetRestriction(facet: owlapy.vocab.OWLFacet, literal: Literals)
-
-
- Bases: :py:obj:`owlapy.owlobject.OWLObject`
-
- A facet restriction is used to restrict a particular datatype.
-
- .. py:attribute:: __slots__
- :value: ('_facet', '_literal')
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4007
-
-
-
- .. py:method:: get_facet() -> owlapy.vocab.OWLFacet
-
-
- .. py:method:: get_facet_value() -> owlapy.owl_literal.OWLLiteral
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-
.. py:class:: OWLImportsDeclaration(import_iri: owlapy.iri.IRI)
- Bases: :py:obj:`owlapy.has.HasIRI`
+ Bases: :py:obj:`owlapy.meta_classes.HasIRI`
Represents an import statement in an ontology.
@@ -3115,16 +2835,6 @@ Attributes
-.. py:data:: OWLThing
- :type: Final
-
-
-
-.. py:data:: OWLNothing
- :type: Final
-
-
-
.. py:data:: OWLTopObjectProperty
:type: Final
diff --git a/_sources/autoapi/owlapy/model/providers/index.rst.txt b/_sources/autoapi/owlapy/model/providers/index.rst.txt
index b88c525..6afdf9d 100644
--- a/_sources/autoapi/owlapy/model/providers/index.rst.txt
+++ b/_sources/autoapi/owlapy/model/providers/index.rst.txt
@@ -39,32 +39,32 @@ Attributes
-.. py:function:: OWLDatatypeMaxExclusiveRestriction(max_: Restriction_Literals) -> owlapy.model.OWLDatatypeRestriction
+.. py:function:: OWLDatatypeMaxExclusiveRestriction(max_: Restriction_Literals) -> owlapy.owl_restriction.OWLDatatypeRestriction
Create a max exclusive restriction.
-.. py:function:: OWLDatatypeMinExclusiveRestriction(min_: Restriction_Literals) -> owlapy.model.OWLDatatypeRestriction
+.. py:function:: OWLDatatypeMinExclusiveRestriction(min_: Restriction_Literals) -> owlapy.owl_restriction.OWLDatatypeRestriction
Create a min exclusive restriction.
-.. py:function:: OWLDatatypeMaxInclusiveRestriction(max_: Restriction_Literals) -> owlapy.model.OWLDatatypeRestriction
+.. py:function:: OWLDatatypeMaxInclusiveRestriction(max_: Restriction_Literals) -> owlapy.owl_restriction.OWLDatatypeRestriction
Create a max inclusive restriction.
-.. py:function:: OWLDatatypeMinInclusiveRestriction(min_: Restriction_Literals) -> owlapy.model.OWLDatatypeRestriction
+.. py:function:: OWLDatatypeMinInclusiveRestriction(min_: Restriction_Literals) -> owlapy.owl_restriction.OWLDatatypeRestriction
Create a min inclusive restriction.
-.. py:function:: OWLDatatypeMinMaxExclusiveRestriction(min_: Restriction_Literals, max_: Restriction_Literals) -> owlapy.model.OWLDatatypeRestriction
+.. py:function:: OWLDatatypeMinMaxExclusiveRestriction(min_: Restriction_Literals, max_: Restriction_Literals) -> owlapy.owl_restriction.OWLDatatypeRestriction
Create a min-max exclusive restriction.
-.. py:function:: OWLDatatypeMinMaxInclusiveRestriction(min_: Restriction_Literals, max_: Restriction_Literals) -> owlapy.model.OWLDatatypeRestriction
+.. py:function:: OWLDatatypeMinMaxInclusiveRestriction(min_: Restriction_Literals, max_: Restriction_Literals) -> owlapy.owl_restriction.OWLDatatypeRestriction
Create a min-max inclusive restriction.
diff --git a/_sources/autoapi/owlapy/owl_axiom/index.rst.txt b/_sources/autoapi/owlapy/owl_axiom/index.rst.txt
index 26c536d..1b86560 100644
--- a/_sources/autoapi/owlapy/owl_axiom/index.rst.txt
+++ b/_sources/autoapi/owlapy/owl_axiom/index.rst.txt
@@ -253,7 +253,7 @@ Classes
.. py:class:: OWLHasKeyAxiom(class_expression: owlapy.owl_class_expression.OWLClassExpression, property_expressions: List[owlapy.owl_property.OWLPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLLogicalAxiom`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.owl_property.OWLPropertyExpression`\ ]
+ Bases: :py:obj:`OWLLogicalAxiom`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`owlapy.owl_property.OWLPropertyExpression`\ ]
Represents a HasKey axiom in the OWL 2 Specification.
diff --git a/_sources/autoapi/owlapy/owl_class_expression/index.rst.txt b/_sources/autoapi/owlapy/owl_class_expression/index.rst.txt
index 804de76..166a7f8 100644
--- a/_sources/autoapi/owlapy/owl_class_expression/index.rst.txt
+++ b/_sources/autoapi/owlapy/owl_class_expression/index.rst.txt
@@ -20,10 +20,23 @@ Classes
owlapy.owl_class_expression.OWLNaryBooleanClassExpression
owlapy.owl_class_expression.OWLObjectUnionOf
owlapy.owl_class_expression.OWLObjectIntersectionOf
+ owlapy.owl_class_expression.OWLDataComplementOf
+ owlapy.owl_class_expression.OWLNaryDataRange
+ owlapy.owl_class_expression.OWLDataUnionOf
+ owlapy.owl_class_expression.OWLDataIntersectionOf
+Attributes
+~~~~~~~~~~
+
+.. autoapisummary::
+
+ owlapy.owl_class_expression.OWLThing
+ owlapy.owl_class_expression.OWLNothing
+
+
.. py:class:: OWLClassExpression
@@ -123,7 +136,7 @@ Classes
.. py:class:: OWLObjectComplementOf(op: OWLClassExpression)
- Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
+ Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
Represents an ObjectComplementOf class expression in the OWL 2 Specification.
@@ -233,7 +246,7 @@ Classes
.. py:class:: OWLNaryBooleanClassExpression(operands: Iterable[OWLClassExpression])
- Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
+ Bases: :py:obj:`OWLBooleanClassExpression`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`OWLClassExpression`\ ]
OWLNaryBooleanClassExpression.
@@ -304,3 +317,121 @@ Classes
+.. py:class:: OWLDataComplementOf(data_range: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`owlapy.ranges.OWLDataRange`
+
+ Represents DataComplementOf in the OWL 2 Specification.
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4002
+
+
+
+ .. py:method:: get_data_range() -> owlapy.ranges.OWLDataRange
+
+ :returns: The wrapped data range.
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+
+.. py:class:: OWLNaryDataRange(operands: Iterable[owlapy.ranges.OWLDataRange])
+
+
+ Bases: :py:obj:`owlapy.ranges.OWLDataRange`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`owlapy.ranges.OWLDataRange`\ ]
+
+ OWLNaryDataRange.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: operands() -> Iterable[owlapy.ranges.OWLDataRange]
+
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ :returns: The operands.
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+
+.. py:class:: OWLDataUnionOf(operands: Iterable[owlapy.ranges.OWLDataRange])
+
+
+ Bases: :py:obj:`OWLNaryDataRange`
+
+ Represents a DataUnionOf data range in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_operands'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4005
+
+
+
+
+.. py:class:: OWLDataIntersectionOf(operands: Iterable[owlapy.ranges.OWLDataRange])
+
+
+ Bases: :py:obj:`OWLNaryDataRange`
+
+ Represents DataIntersectionOf in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_operands'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4004
+
+
+
+
+.. py:data:: OWLThing
+ :type: Final
+
+
+
+.. py:data:: OWLNothing
+ :type: Final
+
+
+
diff --git a/_sources/autoapi/owlapy/owl_data/index.rst.txt b/_sources/autoapi/owlapy/owl_data/index.rst.txt
deleted file mode 100644
index d32c62a..0000000
--- a/_sources/autoapi/owlapy/owl_data/index.rst.txt
+++ /dev/null
@@ -1,302 +0,0 @@
-:py:mod:`owlapy.owl_data`
-=========================
-
-.. py:module:: owlapy.owl_data
-
-
-Module Contents
----------------
-
-Classes
-~~~~~~~
-
-.. autoapisummary::
-
- owlapy.owl_data.OWLDataComplementOf
- owlapy.owl_data.OWLDataHasValue
- owlapy.owl_data.OWLDataMaxCardinality
- owlapy.owl_data.OWLDataMinCardinality
- owlapy.owl_data.OWLDataOneOf
- owlapy.owl_data.OWLDataSomeValuesFrom
- owlapy.owl_data.OWLNaryDataRange
- owlapy.owl_data.OWLDataUnionOf
- owlapy.owl_data.OWLDataIntersectionOf
-
-
-
-
-.. py:class:: OWLDataComplementOf(data_range: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`owlapy.ranges.OWLDataRange`
-
- Represents DataComplementOf in the OWL 2 Specification.
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4002
-
-
-
- .. py:method:: get_data_range() -> owlapy.ranges.OWLDataRange
-
- :returns: The wrapped data range.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
-
-.. py:class:: OWLDataHasValue(property: owlapy.owl_property.OWLDataPropertyExpression, value: owlapy.owl_literal.OWLLiteral)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLHasValueRestriction`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ], :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
-
- Represents DataHasValue restrictions in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_property'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3014
-
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: as_some_values_from() -> owlapy.owl_class_expression.OWLClassExpression
-
- A convenience method that obtains this restriction as an existential restriction with a nominal filler.
-
- :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
-
-
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
-
- :returns: Property being restricted.
-
-
-
-.. py:class:: OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLDataCardinalityRestriction`
-
- Represents DataMaxCardinality restrictions in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: ('_cardinality', '_filler', '_property')
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3017
-
-
-
-
-.. py:class:: OWLDataMinCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLDataCardinalityRestriction`
-
- Represents DataMinCardinality restrictions in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: ('_cardinality', '_filler', '_property')
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3015
-
-
-
-
-.. py:class:: OWLDataOneOf(values: Union[owlapy.owl_literal.OWLLiteral, Iterable[owlapy.owl_literal.OWLLiteral]])
-
-
- Bases: :py:obj:`owlapy.ranges.OWLDataRange`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ]
-
- Represents DataOneOf in the OWL 2 Specification.
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4003
-
-
-
- .. py:method:: values() -> Iterable[owlapy.owl_literal.OWLLiteral]
-
- Gets the values that are in the oneOf.
-
- :returns: The values of this {@code DataOneOf} class expression.
-
-
- .. py:method:: operands() -> Iterable[owlapy.owl_literal.OWLLiteral]
-
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
-
- :returns: The operands.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-
-.. py:class:: OWLDataSomeValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
-
-
- Bases: :py:obj:`owlapy.owl_restriction.OWLQuantifiedDataRestriction`
-
- Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_property'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3012
-
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
-
- :returns: Property being restricted.
-
-
-
-.. py:class:: OWLNaryDataRange(operands: Iterable[owlapy.ranges.OWLDataRange])
-
-
- Bases: :py:obj:`owlapy.ranges.OWLDataRange`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.ranges.OWLDataRange`\ ]
-
- OWLNaryDataRange.
-
- .. py:attribute:: __slots__
- :value: ()
-
-
-
- .. py:method:: operands() -> Iterable[owlapy.ranges.OWLDataRange]
-
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
-
- :returns: The operands.
-
-
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
- .. py:method:: __eq__(other)
-
- Return self==value.
-
-
- .. py:method:: __hash__()
-
- Return hash(self).
-
-
-
-.. py:class:: OWLDataUnionOf(operands: Iterable[owlapy.ranges.OWLDataRange])
-
-
- Bases: :py:obj:`OWLNaryDataRange`
-
- Represents a DataUnionOf data range in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_operands'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4005
-
-
-
-
-.. py:class:: OWLDataIntersectionOf(operands: Iterable[owlapy.ranges.OWLDataRange])
-
-
- Bases: :py:obj:`OWLNaryDataRange`
-
- Represents DataIntersectionOf in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: '_operands'
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 4004
-
-
-
-
diff --git a/_sources/autoapi/owlapy/owl_literal/index.rst.txt b/_sources/autoapi/owlapy/owl_literal/index.rst.txt
index e153715..3642431 100644
--- a/_sources/autoapi/owlapy/owl_literal/index.rst.txt
+++ b/_sources/autoapi/owlapy/owl_literal/index.rst.txt
@@ -23,8 +23,6 @@ Attributes
.. autoapisummary::
owlapy.owl_literal.Literals
- owlapy.owl_literal.OWLThing
- owlapy.owl_literal.OWLNothing
owlapy.owl_literal.OWLTopObjectProperty
owlapy.owl_literal.OWLBottomObjectProperty
owlapy.owl_literal.OWLTopDataProperty
@@ -183,16 +181,6 @@ Attributes
-.. py:data:: OWLThing
- :type: Final
-
-
-
-.. py:data:: OWLNothing
- :type: Final
-
-
-
.. py:data:: OWLTopObjectProperty
:type: Final
diff --git a/_sources/autoapi/owlapy/owl_restriction/index.rst.txt b/_sources/autoapi/owlapy/owl_restriction/index.rst.txt
index 552cbb4..a2c46bc 100644
--- a/_sources/autoapi/owlapy/owl_restriction/index.rst.txt
+++ b/_sources/autoapi/owlapy/owl_restriction/index.rst.txt
@@ -30,10 +30,31 @@ Classes
owlapy.owl_restriction.OWLDataAllValuesFrom
owlapy.owl_restriction.OWLDataCardinalityRestriction
owlapy.owl_restriction.OWLDataExactCardinality
+ owlapy.owl_restriction.OWLDataMaxCardinality
+ owlapy.owl_restriction.OWLDataMinCardinality
+ owlapy.owl_restriction.OWLDataSomeValuesFrom
+ owlapy.owl_restriction.OWLDataHasValue
+ owlapy.owl_restriction.OWLObjectOneOf
+ owlapy.owl_restriction.OWLDataOneOf
+ owlapy.owl_restriction.OWLObjectHasValue
+ owlapy.owl_restriction.OWLDatatypeRestriction
+ owlapy.owl_restriction.OWLFacetRestriction
+Attributes
+~~~~~~~~~~
+
+.. autoapisummary::
+
+ owlapy.owl_restriction.Literals
+
+
+.. py:data:: Literals
+
+
+
.. py:class:: OWLRestriction
@@ -116,7 +137,7 @@ Classes
.. py:class:: OWLHasValueRestriction(value: _T)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.has.HasFiller`\ [\ :py:obj:`_T`\ ]
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.meta_classes.HasFiller`\ [\ :py:obj:`_T`\ ]
OWLHasValueRestriction.
@@ -150,7 +171,7 @@ Classes
.. py:class:: OWLQuantifiedRestriction
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.has.HasFiller`\ [\ :py:obj:`_T`\ ]
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ], :py:obj:`OWLRestriction`, :py:obj:`owlapy.meta_classes.HasFiller`\ [\ :py:obj:`_T`\ ]
Represents a quantified restriction.
@@ -265,7 +286,7 @@ Classes
.. py:class:: OWLCardinalityRestriction(cardinality: int, filler: _F)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_F`\ ], :py:obj:`OWLQuantifiedRestriction`\ [\ :py:obj:`_F`\ ], :py:obj:`owlapy.has.HasCardinality`
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_F`\ ], :py:obj:`OWLQuantifiedRestriction`\ [\ :py:obj:`_F`\ ], :py:obj:`owlapy.meta_classes.HasCardinality`
Base interface for owl min and max cardinality restriction.
@@ -549,3 +570,344 @@ Classes
+.. py:class:: OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLDataCardinalityRestriction`
+
+ Represents DataMaxCardinality restrictions in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_cardinality', '_filler', '_property')
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3017
+
+
+
+
+.. py:class:: OWLDataMinCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLDataCardinalityRestriction`
+
+ Represents DataMinCardinality restrictions in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_cardinality', '_filler', '_property')
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3015
+
+
+
+
+.. py:class:: OWLDataSomeValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.ranges.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLQuantifiedDataRestriction`
+
+ Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_property'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3012
+
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+
+ :returns: Property being restricted.
+
+
+
+.. py:class:: OWLDataHasValue(property: owlapy.owl_property.OWLDataPropertyExpression, value: owlapy.owl_literal.OWLLiteral)
+
+
+ Bases: :py:obj:`OWLHasValueRestriction`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ], :py:obj:`OWLDataRestriction`
+
+ Represents DataHasValue restrictions in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_property'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3014
+
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: as_some_values_from() -> owlapy.owl_class_expression.OWLClassExpression
+
+ A convenience method that obtains this restriction as an existential restriction with a nominal filler.
+
+ :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+
+
+ .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+
+ :returns: Property being restricted.
+
+
+
+.. py:class:: OWLObjectOneOf(values: Union[owlapy.owl_individual.OWLIndividual, Iterable[owlapy.owl_individual.OWLIndividual]])
+
+
+ Bases: :py:obj:`owlapy.owl_class_expression.OWLAnonymousClassExpression`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`owlapy.owl_individual.OWLIndividual`\ ]
+
+ Represents an ObjectOneOf class expression in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_values'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3004
+
+
+
+ .. py:method:: individuals() -> Iterable[owlapy.owl_individual.OWLIndividual]
+
+ Gets the individuals that are in the oneOf. These individuals represent the exact instances (extension)
+ of this class expression.
+
+ :returns: The individuals that are the values of this {@code ObjectOneOf} class expression.
+
+
+ .. py:method:: operands() -> Iterable[owlapy.owl_individual.OWLIndividual]
+
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ :returns: The operands.
+
+
+ .. py:method:: as_object_union_of() -> owlapy.owl_class_expression.OWLClassExpression
+
+ Simplifies this enumeration to a union of singleton nominals.
+
+ :returns: This enumeration in a more standard DL form.
+ simp({a}) = {a} simp({a0, ... , {an}) = unionOf({a0}, ... , {an})
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLDataOneOf(values: Union[owlapy.owl_literal.OWLLiteral, Iterable[owlapy.owl_literal.OWLLiteral]])
+
+
+ Bases: :py:obj:`owlapy.ranges.OWLDataRange`, :py:obj:`owlapy.meta_classes.HasOperands`\ [\ :py:obj:`owlapy.owl_literal.OWLLiteral`\ ]
+
+ Represents DataOneOf in the OWL 2 Specification.
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4003
+
+
+
+ .. py:method:: values() -> Iterable[owlapy.owl_literal.OWLLiteral]
+
+ Gets the values that are in the oneOf.
+
+ :returns: The values of this {@code DataOneOf} class expression.
+
+
+ .. py:method:: operands() -> Iterable[owlapy.owl_literal.OWLLiteral]
+
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ :returns: The operands.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLObjectHasValue(property: owlapy.owl_property.OWLObjectPropertyExpression, individual: owlapy.owl_individual.OWLIndividual)
+
+
+ Bases: :py:obj:`OWLHasValueRestriction`\ [\ :py:obj:`owlapy.owl_individual.OWLIndividual`\ ], :py:obj:`OWLObjectRestriction`
+
+ Represents an ObjectHasValue class expression in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_property', '_v')
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3007
+
+
+
+ .. py:method:: get_property() -> owlapy.owl_property.OWLObjectPropertyExpression
+
+ :returns: Property being restricted.
+
+
+ .. py:method:: as_some_values_from() -> owlapy.owl_class_expression.OWLClassExpression
+
+ A convenience method that obtains this restriction as an existential restriction with a nominal filler.
+
+ :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLDatatypeRestriction(type_: owlapy.types.OWLDatatype, facet_restrictions: Union[OWLFacetRestriction, Iterable[OWLFacetRestriction]])
+
+
+ Bases: :py:obj:`owlapy.ranges.OWLDataRange`
+
+ Represents a DatatypeRestriction data range in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_type', '_facet_restrictions')
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4006
+
+
+
+ .. py:method:: get_datatype() -> owlapy.types.OWLDatatype
+
+
+ .. py:method:: get_facet_restrictions() -> Sequence[OWLFacetRestriction]
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLFacetRestriction(facet: owlapy.vocab.OWLFacet, literal: Literals)
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLObject`
+
+ A facet restriction is used to restrict a particular datatype.
+
+ .. py:attribute:: __slots__
+ :value: ('_facet', '_literal')
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4007
+
+
+
+ .. py:method:: get_facet() -> owlapy.vocab.OWLFacet
+
+
+ .. py:method:: get_facet_value() -> owlapy.owl_literal.OWLLiteral
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
diff --git a/_sources/autoapi/owlapy/owlobject/index.rst.txt b/_sources/autoapi/owlapy/owlobject/index.rst.txt
index 4a512e8..1ca1123 100644
--- a/_sources/autoapi/owlapy/owlobject/index.rst.txt
+++ b/_sources/autoapi/owlapy/owlobject/index.rst.txt
@@ -97,7 +97,7 @@ Classes
.. py:class:: OWLNamedObject
- Bases: :py:obj:`OWLObject`, :py:obj:`owlapy.has.HasIRI`
+ Bases: :py:obj:`OWLObject`, :py:obj:`owlapy.meta_classes.HasIRI`
Represents a named object for example, class, property, ontology etc. - i.e. anything that has an
IRI as its name.
diff --git a/_sources/autoapi/owlapy/parser/index.rst.txt b/_sources/autoapi/owlapy/parser/index.rst.txt
index 8827053..87e51ab 100644
--- a/_sources/autoapi/owlapy/parser/index.rst.txt
+++ b/_sources/autoapi/owlapy/parser/index.rst.txt
@@ -90,7 +90,7 @@ Attributes
.. py:method:: visit_cardinality_res(node, children) -> owlapy.model.OWLObjectCardinalityRestriction
- .. py:method:: visit_value_res(node, children) -> owlapy.model.OWLObjectHasValue
+ .. py:method:: visit_value_res(node, children) -> owlapy.owl_restriction.OWLObjectHasValue
.. py:method:: visit_has_self(node, children) -> owlapy.model.OWLObjectHasSelf
@@ -102,7 +102,7 @@ Attributes
.. py:method:: visit_class_expression(node, children) -> owlapy.model.OWLClassExpression
- .. py:method:: visit_individual_list(node, children) -> owlapy.model.OWLObjectOneOf
+ .. py:method:: visit_individual_list(node, children) -> owlapy.owl_restriction.OWLObjectOneOf
.. py:method:: visit_data_primary(node, children) -> owlapy.model.OWLDataRange
@@ -129,13 +129,13 @@ Attributes
.. py:method:: visit_data_parentheses(node, children) -> owlapy.model.OWLDataRange
- .. py:method:: visit_datatype_restriction(node, children) -> owlapy.model.OWLDatatypeRestriction
+ .. py:method:: visit_datatype_restriction(node, children) -> owlapy.owl_restriction.OWLDatatypeRestriction
- .. py:method:: visit_facet_restrictions(node, children) -> List[owlapy.model.OWLFacetRestriction]
+ .. py:method:: visit_facet_restrictions(node, children) -> List[owlapy.owl_restriction.OWLFacetRestriction]
- .. py:method:: visit_facet_restriction(node, children) -> owlapy.model.OWLFacetRestriction
+ .. py:method:: visit_facet_restriction(node, children) -> owlapy.owl_restriction.OWLFacetRestriction
.. py:method:: visit_literal(node, children) -> owlapy.model.OWLLiteral
@@ -276,7 +276,7 @@ Attributes
.. py:method:: visit_cardinality_res(node, children) -> owlapy.model.OWLObjectCardinalityRestriction
- .. py:method:: visit_value_res(node, children) -> owlapy.model.OWLObjectHasValue
+ .. py:method:: visit_value_res(node, children) -> owlapy.owl_restriction.OWLObjectHasValue
.. py:method:: visit_has_self(node, children) -> owlapy.model.OWLObjectHasSelf
@@ -288,7 +288,7 @@ Attributes
.. py:method:: visit_class_expression(node, children) -> owlapy.model.OWLClassExpression
- .. py:method:: visit_individual_list(node, children) -> owlapy.model.OWLObjectOneOf
+ .. py:method:: visit_individual_list(node, children) -> owlapy.owl_restriction.OWLObjectOneOf
.. py:method:: visit_data_primary(node, children) -> owlapy.model.OWLDataRange
@@ -315,13 +315,13 @@ Attributes
.. py:method:: visit_data_parentheses(node, children) -> owlapy.model.OWLDataRange
- .. py:method:: visit_datatype_restriction(node, children) -> owlapy.model.OWLDatatypeRestriction
+ .. py:method:: visit_datatype_restriction(node, children) -> owlapy.owl_restriction.OWLDatatypeRestriction
- .. py:method:: visit_facet_restrictions(node, children) -> List[owlapy.model.OWLFacetRestriction]
+ .. py:method:: visit_facet_restrictions(node, children) -> List[owlapy.owl_restriction.OWLFacetRestriction]
- .. py:method:: visit_facet_restriction(node, children) -> owlapy.model.OWLFacetRestriction
+ .. py:method:: visit_facet_restriction(node, children) -> owlapy.owl_restriction.OWLFacetRestriction
.. py:method:: visit_literal(node, children) -> owlapy.model.OWLLiteral
diff --git a/_sources/autoapi/owlapy/types/index.rst.txt b/_sources/autoapi/owlapy/types/index.rst.txt
index a2b6339..163195d 100644
--- a/_sources/autoapi/owlapy/types/index.rst.txt
+++ b/_sources/autoapi/owlapy/types/index.rst.txt
@@ -17,7 +17,7 @@ Classes
-.. py:class:: OWLDatatype(iri: Union[owlapy.iri.IRI, owlapy.has.HasIRI])
+.. py:class:: OWLDatatype(iri: Union[owlapy.iri.IRI, owlapy.meta_classes.HasIRI])
Bases: :py:obj:`owlapy.owlobject.OWLEntity`, :py:obj:`owlapy.ranges.OWLDataRange`
diff --git a/autoapi/owlapy/has/index.html b/autoapi/owlapy/has/index.html
index 9b615ba..7793247 100644
--- a/autoapi/owlapy/has/index.html
+++ b/autoapi/owlapy/has/index.html
@@ -58,10 +58,6 @@
- Module Contents
@@ -69,11 +65,11 @@
owlapy.iriowlapy.meta_classesowlapy.namespacesowlapy.owl_annotationowlapy.owl_axiomowlapy.owl_class_expressionowlapy.owl_dataowlapy.owl_individualowlapy.owl_literalowlapy.owl_propertyClasses
Interface for types with an index; this is used to group objects by type when sorting.
Simple class to access the IRI.
An interface to objects that have a collection of operands.
An interface to objects that have a filler.
An interface to objects that have a cardinality.
--
-class owlapy.has.HasOperands[source]
-Bases: Generic[_T]
-An interface to objects that have a collection of operands.
-
-- Parameters:
-_T – Operand type.
-
-
--
-__slots__ = ()
-
-
-
-
-
-
-
--
-class owlapy.has.HasFiller[source]
-Bases: Generic[_T]
-An interface to objects that have a filler.
-
-- Parameters:
-_T – Filler type.
-
-
--
-__slots__ = ()
-
-
-
--
-abstract get_filler() _T[source]
-Gets the filler for this restriction. In the case of an object restriction this will be an individual, in
-the case of a data restriction this will be a constant (data value). For quantified restriction this will be
-a class expression or a data range.
-
-- Returns:
-the value
-
-
-
-
-
-
--
-class owlapy.has.HasCardinality[source]
-An interface to objects that have a cardinality.
-
--
-__slots__ = ()
-
-
-
-
-
-
diff --git a/autoapi/owlapy/index.html b/autoapi/owlapy/index.html
index 0b357af..bdcff4c 100644
--- a/autoapi/owlapy/index.html
+++ b/autoapi/owlapy/index.html
@@ -60,11 +60,11 @@
- Submodules
owlapy.iriowlapy.meta_classesowlapy.namespacesowlapy.owl_annotationowlapy.owl_axiomowlapy.owl_class_expressionowlapy.owl_dataowlapy.owl_individualowlapy.owl_literalowlapy.owl_propertyowlapy.meta_classesowlapy.namespacesowlapy.owl_annotationowlapy.owl_axiomowlapy.owl_class_expressionowlapy.owl_dataowlapy.owl_individualowlapy.owl_literalowlapy.owl_propertyClasses