Source code for owlapy.model
-"""@TODO: CD: This is not a python code. We should refactor this model module."""
-
-from abc import ABCMeta, abstractmethod
+from abc import ABCMeta, abstractmethod
from functools import total_ordering
from itertools import combinations
from typing import Generic, Iterable, Sequence, Set, TypeVar, Union, Final, Optional, Protocol, ClassVar, List
@@ -87,14 +85,23 @@ Source code for owlapy.model
from owlapy.vocab import OWLRDFVocabulary, XSDVocabulary, OWLFacet
from owlapy._utils import MOVE
-from owlapy.owlobject import OWLObject,OWLEntity
+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.owl_class_expression import OWLNaryBooleanClassExpression, OWLClassExpression, OWLObjectComplementOf, OWLAnonymousClassExpression, OWLBooleanClassExpression, OWLPropertyRange, OWLDataRange, OWLClass, OWLObjectUnionOf, OWLObjectIntersectionOf
-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,OWLObjectHasSelf,OWLObjectMaxCardinality,OWLObjectExactCardinality)
+from owlapy.owl_class_expression import OWLNaryBooleanClassExpression, OWLClassExpression, OWLObjectComplementOf, \
+ OWLAnonymousClassExpression, OWLBooleanClassExpression, OWLPropertyRange, OWLDataRange, OWLClass, OWLObjectUnionOf, \
+ OWLObjectIntersectionOf
+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,
+ OWLObjectHasSelf, OWLObjectMaxCardinality, OWLObjectExactCardinality)
+
+from owlapy.owl_individual import OWLNamedIndividual, OWLIndividual
+from owlapy.owl_axiom import *
MOVE(OWLObject, OWLAnnotationObject, OWLAnnotationSubject, OWLAnnotationValue, HasIRI, IRI)
@@ -103,15 +110,7 @@ Source code for owlapy.model
_P = TypeVar('_P', bound='OWLPropertyExpression') #:
_R = TypeVar('_R', bound='OWLPropertyRange') #:
Literals = Union['OWLLiteral', int, float, bool, Timedelta, datetime, date, str] #:
-
-
-
-[docs]
-class OWLIndividual(OWLObject, metaclass=ABCMeta):
- """Represents a named or anonymous individual."""
- __slots__ = ()
- pass
-
+_M = TypeVar('_M', bound='OWLOntologyManager') #:
@@ -160,8 +159,6 @@ Source code for owlapy.model
return f'OWLObjectHasValue(property={self.get_property()}, individual={self._v})'
-
-
[docs]
class OWLObjectOneOf(OWLAnonymousClassExpression, HasOperands[OWLIndividual]):
@@ -232,50 +229,6 @@ Source code for owlapy.model
-
-[docs]
-class OWLNamedIndividual(OWLIndividual, OWLEntity):
- """Represents a Named Individual in the OWL 2 Specification."""
- __slots__ = '_iri'
- type_index: Final = 1005
-
- _iri: IRI
-
- def __init__(self, iri: Union[IRI, str]):
- """Gets an instance of OWLNamedIndividual that has the specified IRI.
-
- Args:
- iri: an instance of IRI Class or a string representing the iri
-
- Returns:
- An OWLNamedIndividual that has the specified IRI.
- """
- if isinstance(iri, IRI):
- self._iri = iri
- else:
- self._iri = IRI.create(iri)
-
-
-[docs]
- def get_iri(self) -> IRI:
- # TODO:CD: can be deprecated
- # documented in parent
- return self._iri
-
-
- @property
- def iri(self):
- return self._iri
-
- @property
- def str(self):
- return self._iri.as_str()
-
-
-
-_M = TypeVar('_M', bound='OWLOntologyManager') #:
-
-
[docs]
class OWLOntologyID:
@@ -360,78 +313,6 @@ Source code for owlapy.model
-
-[docs]
-class OWLAxiom(OWLObject, metaclass=ABCMeta):
- """Represents Axioms in the OWL 2 Specification.
-
- An OWL ontology contains a set of axioms. These axioms can be annotation axioms, declaration axioms, imports axioms
- or logical axioms.
- """
- __slots__ = '_annotations'
-
- _annotations: List['OWLAnnotation']
-
- def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._annotations = list(annotations) if annotations is not None else list()
-
-
-
-
-
-[docs]
- def is_annotated(self) -> bool:
- return self._annotations is not None and len(self._annotations) > 0
-
-
-
-
-
-
-
-
- # TODO: XXX
-
-
-
-[docs]
-class OWLDatatype(OWLEntity, OWLDataRange):
- """Represents a Datatype (named data range) in the OWL 2 Specification."""
- __slots__ = '_iri'
-
- type_index: Final = 4001
-
- _iri: IRI
-
- def __init__(self, iri: Union[IRI, HasIRI]):
- """Gets an instance of OWLDatatype that has the specified IRI.
-
- Args:
- iri: The IRI.
- """
- if isinstance(iri, HasIRI):
- self._iri = iri.get_iri()
- else:
- assert isinstance(iri, IRI)
- self._iri = iri
-
-
-
-
-
[docs]
@@ -1592,766 +1473,6 @@ Source code for owlapy.model
-
-[docs]
-class OWLLogicalAxiom(OWLAxiom, metaclass=ABCMeta):
- """A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
- (including imports declarations) and annotation axioms.
- """
- __slots__ = ()
-
- def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(annotations=annotations)
-
-
-
-
-
-
-
-[docs]
-class OWLPropertyAxiom(OWLLogicalAxiom, metaclass=ABCMeta):
- """The base interface for property axioms."""
- __slots__ = ()
-
- def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(annotations=annotations)
-
-
-
-
-[docs]
-class OWLObjectPropertyAxiom(OWLPropertyAxiom, metaclass=ABCMeta):
- """The base interface for object property axioms."""
- __slots__ = ()
-
-
-
-
-[docs]
-class OWLDataPropertyAxiom(OWLPropertyAxiom, metaclass=ABCMeta):
- """The base interface for data property axioms."""
- __slots__ = ()
-
-
-
-
-[docs]
-class OWLIndividualAxiom(OWLLogicalAxiom, metaclass=ABCMeta):
- """The base interface for individual axioms."""
- __slots__ = ()
-
- def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(annotations=annotations)
-
-
-
-
-[docs]
-class OWLClassAxiom(OWLLogicalAxiom, metaclass=ABCMeta):
- """The base interface for class axioms."""
- __slots__ = ()
-
- def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(annotations=annotations)
-
-
-
-
-[docs]
-class OWLDeclarationAxiom(OWLAxiom):
- """Represents a Declaration axiom in the OWL 2 Specification. A declaration axiom declares an entity in an ontology.
- It doesn't affect the logical meaning of the ontology."""
- __slots__ = '_entity'
-
- _entity: OWLEntity
-
- def __init__(self, entity: OWLEntity, annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._entity = entity
- super().__init__(annotations=annotations)
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._entity == other._entity and self._annotations == other._annotations
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLDeclarationAxiom(entity={self._entity},annotations={self._annotations})'
-
-
-
-
-
-[docs]
-class OWLDatatypeDefinitionAxiom(OWLLogicalAxiom):
- """Represents a DatatypeDefinition axiom in the OWL 2 Specification."""
- __slots__ = '_datatype', '_datarange'
-
- _datatype: OWLDatatype
- _datarange: OWLDataRange
-
- def __init__(self, datatype: OWLDatatype, datarange: OWLDataRange,
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._datatype = datatype
- self._datarange = datarange
- super().__init__(annotations=annotations)
-
-
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._datatype == other._datatype and self._datarange == other._datarange \
- and self._annotations == other._annotations
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLDatatypeDefinitionAxiom(datatype={self._datatype},datarange={self._datarange},' \
- f'annotations={self._annotations})'
-
-
-
-
-
-[docs]
-class OWLHasKeyAxiom(OWLLogicalAxiom, HasOperands[OWLPropertyExpression]):
- """Represents a HasKey axiom in the OWL 2 Specification."""
- __slots__ = '_class_expression', '_property_expressions'
-
- _class_expression: OWLClassExpression
- _property_expressions: List[OWLPropertyExpression]
-
- def __init__(self, class_expression: OWLClassExpression, property_expressions: List[OWLPropertyExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._class_expression = class_expression
- self._property_expressions = property_expressions
- super().__init__(annotations=annotations)
-
-
-
-
-
-[docs]
- def get_property_expressions(self) -> List[OWLPropertyExpression]:
- return self._property_expressions
-
-
-
-[docs]
- def operands(self) -> Iterable[OWLPropertyExpression]:
- yield from self._property_expressions
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._class_expression == other._class_expression \
- and self._property_expressions == other._property_expressions \
- and self._annotations == other._annotations
- return NotImplemented
-
-
-
-[docs]
- def __hash__(self):
- return hash((self._class_expression, *self._property_expressions, *self._annotations))
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLHasKeyAxiom(class_expression={self._class_expression},' \
- f'property_expressions={self._property_expressions},annotations={self._annotations})'
-
-
-
-
-
-[docs]
-class OWLNaryAxiom(Generic[_C], OWLAxiom, metaclass=ABCMeta):
- """Represents an axiom that contains two or more operands that could also be represented with multiple pairwise
- axioms.
-
- Args:
- _C: Class of contained objects.
- """
- __slots__ = ()
-
-
-
-
-
-
-# noinspection PyUnresolvedReferences
-# noinspection PyDunderSlots
-
-[docs]
-class OWLNaryClassAxiom(OWLClassAxiom, OWLNaryAxiom[OWLClassExpression], metaclass=ABCMeta):
- """Represents an axiom that contains two or more operands that could also be represented with
- multiple pairwise axioms."""
- __slots__ = '_class_expressions'
- _class_expressions: List[OWLClassExpression]
-
- @abstractmethod
- def __init__(self, class_expressions: List[OWLClassExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._class_expressions = [*class_expressions]
- super().__init__(annotations=annotations)
-
-
-[docs]
- def class_expressions(self) -> Iterable[OWLClassExpression]:
- """Gets all of the top level class expressions that appear in this axiom.
-
- Returns:
- Sorted stream of class expressions that appear in the axiom.
- """
- yield from self._class_expressions
-
-
-
-[docs]
- def as_pairwise_axioms(self) -> Iterable['OWLNaryClassAxiom']:
- """Gets this axiom as a set of pairwise axioms; if the axiom contains only two operands,
- the axiom itself is returned unchanged, including its annotations.
-
- Returns:
- This axiom as a set of pairwise axioms.
- """
- if len(self._class_expressions) < 3:
- yield self
- else:
- yield from map(type(self), combinations(self._class_expressions, 2))
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._class_expressions == other._class_expressions and self._annotations == other._annotations
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def __repr__(self):
- return f'{type(self).__name__}({self._class_expressions},{self._annotations})'
-
-
-
-
-
-[docs]
-class OWLEquivalentClassesAxiom(OWLNaryClassAxiom):
- """Represents an EquivalentClasses axiom in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, class_expressions: List[OWLClassExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(class_expressions=class_expressions, annotations=annotations)
-
-
-[docs]
- def contains_named_equivalent_class(self) -> bool:
- return any(isinstance(ce, OWLClass) for ce in self._class_expressions)
-
-
-
-[docs]
- def contains_owl_nothing(self) -> bool:
- return any(isinstance(ce, OWLNothing) for ce in self._class_expressions)
-
-
-
-[docs]
- def contains_owl_thing(self) -> bool:
- return any(isinstance(ce, OWLThing) for ce in self._class_expressions)
-
-
-
-[docs]
- def named_classes(self) -> Iterable[OWLClass]:
- yield from (ce for ce in self._class_expressions if isinstance(ce, OWLClass))
-
-
-
-
-
-[docs]
-class OWLDisjointClassesAxiom(OWLNaryClassAxiom):
- """Represents a DisjointClasses axiom in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, class_expressions: List[OWLClassExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(class_expressions=class_expressions, annotations=annotations)
-
-
-
-
-[docs]
-class OWLNaryIndividualAxiom(OWLIndividualAxiom, OWLNaryAxiom[OWLIndividual], metaclass=ABCMeta):
- """Represents an axiom that contains two or more operands that could also be represented with
- multiple pairwise individual axioms."""
- __slots__ = '_individuals'
-
- _individuals: List[OWLIndividual]
-
- @abstractmethod
- def __init__(self, individuals: List[OWLIndividual],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._individuals = [*individuals]
- super().__init__(annotations=annotations)
-
-
-[docs]
- def individuals(self) -> Iterable[OWLIndividual]:
- """Get the individuals.
-
- Returns:
- Generator containing the individuals.
- """
- yield from self._individuals
-
-
-
-[docs]
- def as_pairwise_axioms(self) -> Iterable['OWLNaryIndividualAxiom']:
- if len(self._individuals) < 3:
- yield self
- else:
- yield from map(type(self), combinations(self._individuals, 2))
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._individuals == other._individuals and self._annotations == other._annotations
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def __repr__(self):
- return f'{type(self).__name__}({self._individuals},{self._annotations})'
-
-
-
-
-
-[docs]
-class OWLDifferentIndividualsAxiom(OWLNaryIndividualAxiom):
- """Represents a DifferentIndividuals axiom in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, individuals: List[OWLIndividual],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(individuals=individuals, annotations=annotations)
-
-
-
-
-[docs]
-class OWLSameIndividualAxiom(OWLNaryIndividualAxiom):
- """Represents a SameIndividual axiom in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, individuals: List[OWLIndividual],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(individuals=individuals, annotations=annotations)
-
-
-
-
-[docs]
-class OWLNaryPropertyAxiom(Generic[_P], OWLPropertyAxiom, OWLNaryAxiom[_P], metaclass=ABCMeta):
- """Represents an axiom that contains two or more operands that could also be represented with
- multiple pairwise property axioms."""
- __slots__ = '_properties'
-
- _properties: List[_P]
-
- @abstractmethod
- def __init__(self, properties: List[_P], annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._properties = [*properties]
- super().__init__(annotations=annotations)
-
-
-[docs]
- def properties(self) -> Iterable[_P]:
- """Get all the properties that appear in the axiom.
-
- Returns:
- Generator containing the properties.
- """
- yield from self._properties
-
-
-
-[docs]
- def as_pairwise_axioms(self) -> Iterable['OWLNaryPropertyAxiom']:
- if len(self._properties) < 3:
- yield self
- else:
- yield from map(type(self), combinations(self._properties, 2))
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._properties == other._properties and self._annotations == other._annotations
- return NotImplemented
-
-
-
-
-
-
-[docs]
- def __repr__(self):
- return f'{type(self).__name__}({self._properties},{self._annotations})'
-
-
-
-
-
-[docs]
-class OWLEquivalentObjectPropertiesAxiom(OWLNaryPropertyAxiom[OWLObjectPropertyExpression], OWLObjectPropertyAxiom):
- """Represents EquivalentObjectProperties axioms in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, properties: List[OWLObjectPropertyExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(properties=properties, annotations=annotations)
-
-
-
-
-[docs]
-class OWLDisjointObjectPropertiesAxiom(OWLNaryPropertyAxiom[OWLObjectPropertyExpression], OWLObjectPropertyAxiom):
- """Represents DisjointObjectProperties axioms in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, properties: List[OWLObjectPropertyExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(properties=properties, annotations=annotations)
-
-
-
-
-[docs]
-class OWLInverseObjectPropertiesAxiom(OWLNaryPropertyAxiom[OWLObjectPropertyExpression], OWLObjectPropertyAxiom):
- """Represents InverseObjectProperties axioms in the OWL 2 Specification."""
- __slots__ = '_first', '_second'
-
- _first: OWLObjectPropertyExpression
- _second: OWLObjectPropertyExpression
-
- def __init__(self, first: OWLObjectPropertyExpression, second: OWLObjectPropertyExpression,
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._first = first
- self._second = second
- super().__init__(properties=[first, second], annotations=annotations)
-
-
-
-
-
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLInverseObjectPropertiesAxiom(first={self._first},second={self._second},' \
- f'annotations={self._annotations})'
-
-
-
-
-
-[docs]
-class OWLEquivalentDataPropertiesAxiom(OWLNaryPropertyAxiom[OWLDataPropertyExpression], OWLDataPropertyAxiom):
- """Represents EquivalentDataProperties axioms in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, properties: List[OWLDataPropertyExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(properties=properties, annotations=annotations)
-
-
-
-
-[docs]
-class OWLDisjointDataPropertiesAxiom(OWLNaryPropertyAxiom[OWLDataPropertyExpression], OWLDataPropertyAxiom):
- """Represents DisjointDataProperties axioms in the OWL 2 Specification."""
- __slots__ = ()
-
- def __init__(self, properties: List[OWLDataPropertyExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- super().__init__(properties=properties, annotations=annotations)
-
-
-
-
-[docs]
-class OWLSubClassOfAxiom(OWLClassAxiom):
- """Represents an SubClassOf axiom in the OWL 2 Specification."""
- __slots__ = '_sub_class', '_super_class'
-
- _sub_class: OWLClassExpression
- _super_class: OWLClassExpression
-
- def __init__(self, sub_class: OWLClassExpression, super_class: OWLClassExpression,
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- """Get an equivalent classes axiom with specified operands and no annotations.
-
- Args:
- sub_class: The sub-class.
- super_class: The super class.
- annotations: Annotations.
- """
- self._sub_class = sub_class
- self._super_class = super_class
- super().__init__(annotations=annotations)
-
-
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._super_class == other._super_class and self._sub_class == other._sub_class \
- and self._annotations == other._annotations
- return NotImplemented
-
-
-
-[docs]
- def __hash__(self):
- return hash((self._super_class, self._sub_class, *self._annotations))
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLSubClassOfAxiom(sub_class={self._sub_class},super_class={self._super_class},' \
- f'annotations={self._annotations})'
-
-
-
-
-
-[docs]
-class OWLDisjointUnionAxiom(OWLClassAxiom):
- """Represents a DisjointUnion axiom in the OWL 2 Specification."""
- __slots__ = '_cls', '_class_expressions'
-
- _cls: OWLClass
- _class_expressions: List[OWLClassExpression]
-
- def __init__(self, cls_: OWLClass, class_expressions: List[OWLClassExpression],
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- self._cls = cls_
- self._class_expressions = class_expressions
- super().__init__(annotations=annotations)
-
-
-
-
-
-[docs]
- def get_class_expressions(self) -> Iterable[OWLClassExpression]:
- yield from self._class_expressions
-
-
-
-[docs]
- def get_owl_equivalent_classes_axiom(self) -> OWLEquivalentClassesAxiom:
- return OWLEquivalentClassesAxiom(self._cls, OWLObjectUnionOf(self._class_expressions))
-
-
-
-[docs]
- def get_owl_disjoint_classes_axiom(self) -> OWLDisjointClassesAxiom:
- return OWLDisjointClassesAxiom(self._class_expressions)
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._cls == other._cls and self._class_expressions == other._class_expressions \
- and self._annotations == other._annotations
- return NotImplemented
-
-
-
-[docs]
- def __hash__(self):
- return hash((self._cls, *self._class_expressions, *self._annotations))
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLDisjointUnionAxiom(class={self._cls},class_expressions={self._class_expressions},' \
- f'annotations={self._annotations})'
-
-
-
-
-
-[docs]
-class OWLClassAssertionAxiom(OWLIndividualAxiom):
- """Represents ClassAssertion axioms in the OWL 2 Specification."""
- __slots__ = '_individual', '_class_expression'
-
- _individual: OWLIndividual
- _class_expression: OWLClassExpression
-
- def __init__(self, individual: OWLIndividual, class_expression: OWLClassExpression,
- annotations: Optional[Iterable['OWLAnnotation']] = None):
- """Get a ClassAssertion axiom for the specified individual and class expression.
- Args:
- individual: The individual.
- class_expression: The class the individual belongs to.
- annotations: Annotations.
- """
- self._individual = individual
- self._class_expression = class_expression
- super().__init__(annotations=annotations)
-
-
-
-
-
-
-
-
-[docs]
- def __eq__(self, other):
- if type(other) is type(self):
- return self._class_expression == other._class_expression and self._individual == other._individual \
- and self._annotations == other._annotations
- return NotImplemented
-
-
-
-[docs]
- def __hash__(self):
- return hash((self._individual, self._class_expression, *self._annotations))
-
-
-
-[docs]
- def __repr__(self):
- return f'OWLClassAssertionAxiom(individual={self._individual},class_expression={self._class_expression},' \
- f'annotations={self._annotations})'
-
-
-
-
-
-[docs]
-class OWLAnnotationAxiom(OWLAxiom, metaclass=ABCMeta):
- """A super interface for annotation axioms."""
- __slots__ = ()
-
-
-
diff --git a/_modules/owlapy/owl_axiom.html b/_modules/owlapy/owl_axiom.html
new file mode 100644
index 0000000..661446f
--- /dev/null
+++ b/_modules/owlapy/owl_axiom.html
@@ -0,0 +1,926 @@
+
+
+
+
+
+ owlapy.owl_axiom — OWLAPY 0.1.2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Source code for owlapy.owl_axiom
+from abc import ABCMeta, abstractmethod
+
+from typing import TypeVar, List, Optional, Iterable, Generic
+from .owl_property import OWLDataPropertyExpression, OWLObjectPropertyExpression
+from .owlobject import OWLObject, OWLEntity
+from .types import OWLDatatype, OWLDataRange
+from .has import HasOperands
+from .owl_property import OWLPropertyExpression
+from .owl_class_expression import OWLClassExpression, OWLClass
+from .owl_individual import OWLIndividual
+
+_C = TypeVar('_C', bound='OWLObject') #:
+_P = TypeVar('_P', bound='OWLPropertyExpression') #:
+
+
+
+[docs]
+class OWLAxiom(OWLObject, metaclass=ABCMeta):
+ """Represents Axioms in the OWL 2 Specification.
+
+ An OWL ontology contains a set of axioms. These axioms can be annotation axioms, declaration axioms, imports axioms
+ or logical axioms.
+ """
+ __slots__ = '_annotations'
+
+ _annotations: List['OWLAnnotation']
+
+ def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._annotations = list(annotations) if annotations is not None else list()
+
+
+
+
+
+[docs]
+ def is_annotated(self) -> bool:
+ return self._annotations is not None and len(self._annotations) > 0
+
+
+
+
+
+
+
+
+ # TODO: XXX
+
+
+
+[docs]
+class OWLLogicalAxiom(OWLAxiom, metaclass=ABCMeta):
+ """A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
+ (including imports declarations) and annotation axioms.
+ """
+ __slots__ = ()
+
+ def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(annotations=annotations)
+
+
+
+
+
+
+
+[docs]
+class OWLPropertyAxiom(OWLLogicalAxiom, metaclass=ABCMeta):
+ """The base interface for property axioms."""
+ __slots__ = ()
+
+ def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(annotations=annotations)
+
+
+
+
+[docs]
+class OWLObjectPropertyAxiom(OWLPropertyAxiom, metaclass=ABCMeta):
+ """The base interface for object property axioms."""
+ __slots__ = ()
+
+
+
+
+[docs]
+class OWLDataPropertyAxiom(OWLPropertyAxiom, metaclass=ABCMeta):
+ """The base interface for data property axioms."""
+ __slots__ = ()
+
+
+
+
+[docs]
+class OWLIndividualAxiom(OWLLogicalAxiom, metaclass=ABCMeta):
+ """The base interface for individual axioms."""
+ __slots__ = ()
+
+ def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(annotations=annotations)
+
+
+
+
+[docs]
+class OWLClassAxiom(OWLLogicalAxiom, metaclass=ABCMeta):
+ """The base interface for class axioms."""
+ __slots__ = ()
+
+ def __init__(self, annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(annotations=annotations)
+
+
+
+
+[docs]
+class OWLDeclarationAxiom(OWLAxiom):
+ """Represents a Declaration axiom in the OWL 2 Specification. A declaration axiom declares an entity in an ontology.
+ It doesn't affect the logical meaning of the ontology."""
+ __slots__ = '_entity'
+
+ _entity: OWLEntity
+
+ def __init__(self, entity: OWLEntity, annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._entity = entity
+ super().__init__(annotations=annotations)
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._entity == other._entity and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLDeclarationAxiom(entity={self._entity},annotations={self._annotations})'
+
+
+
+
+
+[docs]
+class OWLDatatypeDefinitionAxiom(OWLLogicalAxiom):
+ """Represents a DatatypeDefinition axiom in the OWL 2 Specification."""
+ __slots__ = '_datatype', '_datarange'
+
+ _datatype: OWLDatatype
+ _datarange: OWLDataRange
+
+ def __init__(self, datatype: OWLDatatype, datarange: OWLDataRange,
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._datatype = datatype
+ self._datarange = datarange
+ super().__init__(annotations=annotations)
+
+
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._datatype == other._datatype and self._datarange == other._datarange \
+ and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLDatatypeDefinitionAxiom(datatype={self._datatype},datarange={self._datarange},' \
+ f'annotations={self._annotations})'
+
+
+
+
+
+[docs]
+class OWLHasKeyAxiom(OWLLogicalAxiom, HasOperands[OWLPropertyExpression]):
+ """Represents a HasKey axiom in the OWL 2 Specification."""
+ __slots__ = '_class_expression', '_property_expressions'
+
+ _class_expression: OWLClassExpression
+ _property_expressions: List[OWLPropertyExpression]
+
+ def __init__(self, class_expression: OWLClassExpression, property_expressions: List[OWLPropertyExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._class_expression = class_expression
+ self._property_expressions = property_expressions
+ super().__init__(annotations=annotations)
+
+
+
+
+
+[docs]
+ def get_property_expressions(self) -> List[OWLPropertyExpression]:
+ return self._property_expressions
+
+
+
+[docs]
+ def operands(self) -> Iterable[OWLPropertyExpression]:
+ yield from self._property_expressions
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._class_expression == other._class_expression \
+ and self._property_expressions == other._property_expressions \
+ and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+[docs]
+ def __hash__(self):
+ return hash((self._class_expression, *self._property_expressions, *self._annotations))
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLHasKeyAxiom(class_expression={self._class_expression},' \
+ f'property_expressions={self._property_expressions},annotations={self._annotations})'
+
+
+
+
+
+[docs]
+class OWLNaryAxiom(Generic[_C], OWLAxiom, metaclass=ABCMeta):
+ """Represents an axiom that contains two or more operands that could also be represented with multiple pairwise
+ axioms.
+
+ Args:
+ _C: Class of contained objects.
+ """
+ __slots__ = ()
+
+
+
+
+
+
+# noinspection PyUnresolvedReferences
+# noinspection PyDunderSlots
+
+[docs]
+class OWLNaryClassAxiom(OWLClassAxiom, OWLNaryAxiom[OWLClassExpression], metaclass=ABCMeta):
+ """Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise axioms."""
+ __slots__ = '_class_expressions'
+ _class_expressions: List[OWLClassExpression]
+
+ @abstractmethod
+ def __init__(self, class_expressions: List[OWLClassExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._class_expressions = [*class_expressions]
+ super().__init__(annotations=annotations)
+
+
+[docs]
+ def class_expressions(self) -> Iterable[OWLClassExpression]:
+ """Gets all of the top level class expressions that appear in this axiom.
+
+ Returns:
+ Sorted stream of class expressions that appear in the axiom.
+ """
+ yield from self._class_expressions
+
+
+
+[docs]
+ def as_pairwise_axioms(self) -> Iterable['OWLNaryClassAxiom']:
+ """Gets this axiom as a set of pairwise axioms; if the axiom contains only two operands,
+ the axiom itself is returned unchanged, including its annotations.
+
+ Returns:
+ This axiom as a set of pairwise axioms.
+ """
+ if len(self._class_expressions) < 3:
+ yield self
+ else:
+ yield from map(type(self), combinations(self._class_expressions, 2))
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._class_expressions == other._class_expressions and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def __repr__(self):
+ return f'{type(self).__name__}({self._class_expressions},{self._annotations})'
+
+
+
+
+
+[docs]
+class OWLEquivalentClassesAxiom(OWLNaryClassAxiom):
+ """Represents an EquivalentClasses axiom in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, class_expressions: List[OWLClassExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(class_expressions=class_expressions, annotations=annotations)
+
+
+[docs]
+ def contains_named_equivalent_class(self) -> bool:
+ return any(isinstance(ce, OWLClass) for ce in self._class_expressions)
+
+
+
+[docs]
+ def contains_owl_nothing(self) -> bool:
+ return any(isinstance(ce, OWLNothing) for ce in self._class_expressions)
+
+
+
+[docs]
+ def contains_owl_thing(self) -> bool:
+ return any(isinstance(ce, OWLThing) for ce in self._class_expressions)
+
+
+
+[docs]
+ def named_classes(self) -> Iterable[OWLClass]:
+ yield from (ce for ce in self._class_expressions if isinstance(ce, OWLClass))
+
+
+
+
+
+[docs]
+class OWLDisjointClassesAxiom(OWLNaryClassAxiom):
+ """Represents a DisjointClasses axiom in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, class_expressions: List[OWLClassExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(class_expressions=class_expressions, annotations=annotations)
+
+
+
+
+[docs]
+class OWLNaryIndividualAxiom(OWLIndividualAxiom, OWLNaryAxiom[OWLIndividual], metaclass=ABCMeta):
+ """Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise individual axioms."""
+ __slots__ = '_individuals'
+
+ _individuals: List[OWLIndividual]
+
+ @abstractmethod
+ def __init__(self, individuals: List[OWLIndividual],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._individuals = [*individuals]
+ super().__init__(annotations=annotations)
+
+
+[docs]
+ def individuals(self) -> Iterable[OWLIndividual]:
+ """Get the individuals.
+
+ Returns:
+ Generator containing the individuals.
+ """
+ yield from self._individuals
+
+
+
+[docs]
+ def as_pairwise_axioms(self) -> Iterable['OWLNaryIndividualAxiom']:
+ if len(self._individuals) < 3:
+ yield self
+ else:
+ yield from map(type(self), combinations(self._individuals, 2))
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._individuals == other._individuals and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def __repr__(self):
+ return f'{type(self).__name__}({self._individuals},{self._annotations})'
+
+
+
+
+
+[docs]
+class OWLDifferentIndividualsAxiom(OWLNaryIndividualAxiom):
+ """Represents a DifferentIndividuals axiom in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, individuals: List[OWLIndividual],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(individuals=individuals, annotations=annotations)
+
+
+
+
+[docs]
+class OWLSameIndividualAxiom(OWLNaryIndividualAxiom):
+ """Represents a SameIndividual axiom in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, individuals: List[OWLIndividual],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(individuals=individuals, annotations=annotations)
+
+
+
+
+[docs]
+class OWLNaryPropertyAxiom(Generic[_P], OWLPropertyAxiom, OWLNaryAxiom[_P], metaclass=ABCMeta):
+ """Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise property axioms."""
+ __slots__ = '_properties'
+
+ _properties: List[_P]
+
+ @abstractmethod
+ def __init__(self, properties: List[_P], annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._properties = [*properties]
+ super().__init__(annotations=annotations)
+
+
+[docs]
+ def properties(self) -> Iterable[_P]:
+ """Get all the properties that appear in the axiom.
+
+ Returns:
+ Generator containing the properties.
+ """
+ yield from self._properties
+
+
+
+[docs]
+ def as_pairwise_axioms(self) -> Iterable['OWLNaryPropertyAxiom']:
+ if len(self._properties) < 3:
+ yield self
+ else:
+ yield from map(type(self), combinations(self._properties, 2))
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._properties == other._properties and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+
+
+
+[docs]
+ def __repr__(self):
+ return f'{type(self).__name__}({self._properties},{self._annotations})'
+
+
+
+
+
+[docs]
+class OWLEquivalentObjectPropertiesAxiom(OWLNaryPropertyAxiom[OWLObjectPropertyExpression], OWLObjectPropertyAxiom):
+ """Represents EquivalentObjectProperties axioms in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, properties: List[OWLObjectPropertyExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(properties=properties, annotations=annotations)
+
+
+
+
+[docs]
+class OWLDisjointObjectPropertiesAxiom(OWLNaryPropertyAxiom[OWLObjectPropertyExpression], OWLObjectPropertyAxiom):
+ """Represents DisjointObjectProperties axioms in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, properties: List[OWLObjectPropertyExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(properties=properties, annotations=annotations)
+
+
+
+
+[docs]
+class OWLInverseObjectPropertiesAxiom(OWLNaryPropertyAxiom[OWLObjectPropertyExpression], OWLObjectPropertyAxiom):
+ """Represents InverseObjectProperties axioms in the OWL 2 Specification."""
+ __slots__ = '_first', '_second'
+
+ _first: OWLObjectPropertyExpression
+ _second: OWLObjectPropertyExpression
+
+ def __init__(self, first: OWLObjectPropertyExpression, second: OWLObjectPropertyExpression,
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._first = first
+ self._second = second
+ super().__init__(properties=[first, second], annotations=annotations)
+
+
+
+
+
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLInverseObjectPropertiesAxiom(first={self._first},second={self._second},' \
+ f'annotations={self._annotations})'
+
+
+
+
+
+[docs]
+class OWLEquivalentDataPropertiesAxiom(OWLNaryPropertyAxiom[OWLDataPropertyExpression], OWLDataPropertyAxiom):
+ """Represents EquivalentDataProperties axioms in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, properties: List[OWLDataPropertyExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(properties=properties, annotations=annotations)
+
+
+
+
+[docs]
+class OWLDisjointDataPropertiesAxiom(OWLNaryPropertyAxiom[OWLDataPropertyExpression], OWLDataPropertyAxiom):
+ """Represents DisjointDataProperties axioms in the OWL 2 Specification."""
+ __slots__ = ()
+
+ def __init__(self, properties: List[OWLDataPropertyExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ super().__init__(properties=properties, annotations=annotations)
+
+
+
+
+[docs]
+class OWLSubClassOfAxiom(OWLClassAxiom):
+ """Represents an SubClassOf axiom in the OWL 2 Specification."""
+ __slots__ = '_sub_class', '_super_class'
+
+ _sub_class: OWLClassExpression
+ _super_class: OWLClassExpression
+
+ def __init__(self, sub_class: OWLClassExpression, super_class: OWLClassExpression,
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ """Get an equivalent classes axiom with specified operands and no annotations.
+
+ Args:
+ sub_class: The sub-class.
+ super_class: The super class.
+ annotations: Annotations.
+ """
+ self._sub_class = sub_class
+ self._super_class = super_class
+ super().__init__(annotations=annotations)
+
+
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._super_class == other._super_class and self._sub_class == other._sub_class \
+ and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+[docs]
+ def __hash__(self):
+ return hash((self._super_class, self._sub_class, *self._annotations))
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLSubClassOfAxiom(sub_class={self._sub_class},super_class={self._super_class},' \
+ f'annotations={self._annotations})'
+
+
+
+
+
+[docs]
+class OWLDisjointUnionAxiom(OWLClassAxiom):
+ """Represents a DisjointUnion axiom in the OWL 2 Specification."""
+ __slots__ = '_cls', '_class_expressions'
+
+ _cls: OWLClass
+ _class_expressions: List[OWLClassExpression]
+
+ def __init__(self, cls_: OWLClass, class_expressions: List[OWLClassExpression],
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ self._cls = cls_
+ self._class_expressions = class_expressions
+ super().__init__(annotations=annotations)
+
+
+
+
+
+[docs]
+ def get_class_expressions(self) -> Iterable[OWLClassExpression]:
+ yield from self._class_expressions
+
+
+
+[docs]
+ def get_owl_equivalent_classes_axiom(self) -> OWLEquivalentClassesAxiom:
+ return OWLEquivalentClassesAxiom(self._cls, OWLObjectUnionOf(self._class_expressions))
+
+
+
+[docs]
+ def get_owl_disjoint_classes_axiom(self) -> OWLDisjointClassesAxiom:
+ return OWLDisjointClassesAxiom(self._class_expressions)
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._cls == other._cls and self._class_expressions == other._class_expressions \
+ and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+[docs]
+ def __hash__(self):
+ return hash((self._cls, *self._class_expressions, *self._annotations))
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLDisjointUnionAxiom(class={self._cls},class_expressions={self._class_expressions},' \
+ f'annotations={self._annotations})'
+
+
+
+
+
+[docs]
+class OWLClassAssertionAxiom(OWLIndividualAxiom):
+ """Represents ClassAssertion axioms in the OWL 2 Specification."""
+ __slots__ = '_individual', '_class_expression'
+
+ _individual: OWLIndividual
+ _class_expression: OWLClassExpression
+
+ def __init__(self, individual: OWLIndividual, class_expression: OWLClassExpression,
+ annotations: Optional[Iterable['OWLAnnotation']] = None):
+ """Get a ClassAssertion axiom for the specified individual and class expression.
+ Args:
+ individual: The individual.
+ class_expression: The class the individual belongs to.
+ annotations: Annotations.
+ """
+ self._individual = individual
+ self._class_expression = class_expression
+ super().__init__(annotations=annotations)
+
+
+
+
+
+
+
+
+[docs]
+ def __eq__(self, other):
+ if type(other) is type(self):
+ return self._class_expression == other._class_expression and self._individual == other._individual \
+ and self._annotations == other._annotations
+ return NotImplemented
+
+
+
+[docs]
+ def __hash__(self):
+ return hash((self._individual, self._class_expression, *self._annotations))
+
+
+
+[docs]
+ def __repr__(self):
+ return f'OWLClassAssertionAxiom(individual={self._individual},class_expression={self._class_expression},' \
+ f'annotations={self._annotations})'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/_modules/owlapy/owl_individual.html b/_modules/owlapy/owl_individual.html
new file mode 100644
index 0000000..ccc5511
--- /dev/null
+++ b/_modules/owlapy/owl_individual.html
@@ -0,0 +1,159 @@
+
+
+
+
+
+ owlapy.owl_individual — OWLAPY 0.1.2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Source code for owlapy.owl_individual
+from abc import ABCMeta
+from .owlobject import OWLObject, OWLEntity
+from .iri import IRI
+from typing import Final, Union
+
+[docs]
+class OWLIndividual(OWLObject, metaclass=ABCMeta):
+ """Represents a named or anonymous individual."""
+ __slots__ = ()
+ pass
+
+
+
+[docs]
+class OWLNamedIndividual(OWLIndividual, OWLEntity):
+ """Represents a Named Individual in the OWL 2 Specification."""
+ __slots__ = '_iri'
+ type_index: Final = 1005
+
+ _iri: IRI
+
+ def __init__(self, iri: Union[IRI, str]):
+ """Gets an instance of OWLNamedIndividual that has the specified IRI.
+
+ Args:
+ iri: an instance of IRI Class or a string representing the iri
+
+ Returns:
+ An OWLNamedIndividual that has the specified IRI.
+ """
+ if isinstance(iri, IRI):
+ self._iri = iri
+ else:
+ self._iri = IRI.create(iri)
+
+
+[docs]
+ def get_iri(self) -> IRI:
+ # TODO:CD: can be deprecated
+ # documented in parent
+ return self._iri
+
+
+ @property
+ def iri(self):
+ return self._iri
+
+ @property
+ def str(self):
+ return self._iri.as_str()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/_modules/owlapy/types.html b/_modules/owlapy/types.html
new file mode 100644
index 0000000..6726f4e
--- /dev/null
+++ b/_modules/owlapy/types.html
@@ -0,0 +1,143 @@
+
+
+
+
+
+ owlapy.types — OWLAPY 0.1.2 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Source code for owlapy.types
+from .owlobject import OWLObject, OWLEntity
+from .ranges import OWLDataRange
+from .iri import IRI
+from .has import HasIRI
+from typing import Final, Union
+
+
+[docs]
+class OWLDatatype(OWLEntity, OWLDataRange):
+ """Represents a Datatype (named data range) in the OWL 2 Specification."""
+ __slots__ = '_iri'
+
+ type_index: Final = 4001
+
+ _iri: IRI
+
+ def __init__(self, iri: Union[IRI, HasIRI]):
+ """Gets an instance of OWLDatatype that has the specified IRI.
+
+ Args:
+ iri: The IRI.
+ """
+ if isinstance(iri, HasIRI):
+ self._iri = iri.get_iri()
+ else:
+ assert isinstance(iri, IRI)
+ self._iri = iri
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/_sources/autoapi/owlapy/index.rst.txt b/_sources/autoapi/owlapy/index.rst.txt
index a803a96..f1d8263 100644
--- a/_sources/autoapi/owlapy/index.rst.txt
+++ b/_sources/autoapi/owlapy/index.rst.txt
@@ -24,13 +24,16 @@ Submodules
iri/index.rst
namespaces/index.rst
owl_annotation/index.rst
+ owl_axiom/index.rst
owl_class_expression/index.rst
+ owl_individual/index.rst
owl_property/index.rst
owl_restriction/index.rst
owlobject/index.rst
parser/index.rst
ranges/index.rst
render/index.rst
+ types/index.rst
util/index.rst
vocab/index.rst
diff --git a/_sources/autoapi/owlapy/model/index.rst.txt b/_sources/autoapi/owlapy/model/index.rst.txt
index 92e2a37..330ee6a 100644
--- a/_sources/autoapi/owlapy/model/index.rst.txt
+++ b/_sources/autoapi/owlapy/model/index.rst.txt
@@ -3,11 +3,6 @@
.. py:module:: owlapy.model
-.. autoapi-nested-parse::
-
- @TODO: CD: This is not a python code. We should refactor this model module.
-
-
Submodules
----------
@@ -70,30 +65,20 @@ Classes
owlapy.model.OWLObjectHasSelf
owlapy.model.OWLObjectMaxCardinality
owlapy.model.OWLObjectExactCardinality
- owlapy.model.OWLIndividual
- owlapy.model.OWLObjectHasValue
- owlapy.model.OWLObjectOneOf
owlapy.model.OWLNamedIndividual
- owlapy.model.OWLOntologyID
- owlapy.model.OWLAxiom
+ owlapy.model.OWLIndividual
+ owlapy.model.OWLDataPropertyExpression
+ owlapy.model.OWLObjectPropertyExpression
+ owlapy.model.OWLObject
+ owlapy.model.OWLEntity
owlapy.model.OWLDatatype
- owlapy.model.OWLDatatypeRestriction
- owlapy.model.OWLFacetRestriction
- owlapy.model.OWLLiteral
- owlapy.model.OWLQuantifiedDataRestriction
- owlapy.model.OWLDataCardinalityRestriction
- owlapy.model.OWLDataAllValuesFrom
- owlapy.model.OWLDataComplementOf
- owlapy.model.OWLDataExactCardinality
- owlapy.model.OWLDataHasValue
- owlapy.model.OWLDataMaxCardinality
- owlapy.model.OWLDataMinCardinality
- owlapy.model.OWLDataOneOf
- owlapy.model.OWLDataSomeValuesFrom
- owlapy.model.OWLNaryDataRange
- owlapy.model.OWLDataUnionOf
- owlapy.model.OWLDataIntersectionOf
- owlapy.model.OWLImportsDeclaration
+ owlapy.model.OWLDataRange
+ owlapy.model.HasOperands
+ owlapy.model.OWLPropertyExpression
+ owlapy.model.OWLClassExpression
+ owlapy.model.OWLClass
+ owlapy.model.OWLIndividual
+ owlapy.model.OWLAxiom
owlapy.model.OWLLogicalAxiom
owlapy.model.OWLPropertyAxiom
owlapy.model.OWLObjectPropertyAxiom
@@ -120,6 +105,26 @@ Classes
owlapy.model.OWLDisjointUnionAxiom
owlapy.model.OWLClassAssertionAxiom
owlapy.model.OWLAnnotationAxiom
+ owlapy.model.OWLObjectHasValue
+ owlapy.model.OWLObjectOneOf
+ owlapy.model.OWLOntologyID
+ owlapy.model.OWLDatatypeRestriction
+ owlapy.model.OWLFacetRestriction
+ owlapy.model.OWLLiteral
+ owlapy.model.OWLQuantifiedDataRestriction
+ owlapy.model.OWLDataCardinalityRestriction
+ owlapy.model.OWLDataAllValuesFrom
+ owlapy.model.OWLDataComplementOf
+ owlapy.model.OWLDataExactCardinality
+ owlapy.model.OWLDataHasValue
+ owlapy.model.OWLDataMaxCardinality
+ owlapy.model.OWLDataMinCardinality
+ owlapy.model.OWLDataOneOf
+ owlapy.model.OWLDataSomeValuesFrom
+ owlapy.model.OWLNaryDataRange
+ owlapy.model.OWLDataUnionOf
+ owlapy.model.OWLDataIntersectionOf
+ owlapy.model.OWLImportsDeclaration
owlapy.model.OWLAnnotationProperty
owlapy.model.OWLAnnotation
owlapy.model.OWLAnnotationAssertionAxiom
@@ -1610,129 +1615,160 @@ Attributes
-.. py:data:: Literals
+.. py:class:: OWLNamedIndividual(iri: Union[owlapy.iri.IRI, str])
-
-.. py:class:: OWLIndividual
+ Bases: :py:obj:`OWLIndividual`, :py:obj:`owlapy.owlobject.OWLEntity`
+ Represents a Named Individual in the OWL 2 Specification.
- Bases: :py:obj:`owlapy.owlobject.OWLObject`
+ .. py:property:: iri
+
+
+ .. py:property:: str
- Represents a named or anonymous individual.
.. py:attribute:: __slots__
- :value: ()
+ :value: '_iri'
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 1005
-.. py:class:: OWLObjectHasValue(property: owlapy.owl_property.OWLObjectPropertyExpression, individual: OWLIndividual)
+
+ .. py:method:: get_iri() -> owlapy.iri.IRI
- Bases: :py:obj:`owlapy.owl_restriction.OWLHasValueRestriction`\ [\ :py:obj:`OWLIndividual`\ ], :py:obj:`owlapy.owl_restriction.OWLObjectRestriction`
+ Gets the IRI of this object.
- Represents an ObjectHasValue class expression in the OWL 2 Specification.
+ :returns: The IRI of this object.
- .. py:attribute:: __slots__
- :value: ('_property', '_v')
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3007
+.. py:class:: OWLIndividual
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLObject`
+
+ Represents a named or anonymous individual.
+
+ .. py:attribute:: __slots__
+ :value: ()
- .. py:method:: get_property() -> owlapy.owl_property.OWLObjectPropertyExpression
- :returns: Property being restricted.
+.. py:class:: OWLDataPropertyExpression
- .. py:method:: as_some_values_from() -> owlapy.owl_class_expression.OWLClassExpression
+ Bases: :py:obj:`OWLPropertyExpression`
- A convenience method that obtains this restriction as an existential restriction with a nominal filler.
+ A high level interface to describe different types of data properties.
- :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+ .. py:attribute:: __slots__
+ :value: ()
+
- .. py:method:: __repr__()
+ .. py:method:: is_data_property_expression()
- Return repr(self).
+ :returns: True if this is a data property.
-.. py:class:: OWLObjectOneOf(values: Union[OWLIndividual, Iterable[OWLIndividual]])
+.. py:class:: OWLObjectPropertyExpression
- Bases: :py:obj:`owlapy.owl_class_expression.OWLAnonymousClassExpression`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`OWLIndividual`\ ]
+ Bases: :py:obj:`OWLPropertyExpression`
- Represents an ObjectOneOf class expression in the OWL 2 Specification.
+ A high level interface to describe different types of object properties.
.. py:attribute:: __slots__
- :value: '_values'
+ :value: ()
- .. py:attribute:: type_index
- :type: Final
- :value: 3004
+ .. py:method:: get_inverse_property() -> OWLObjectPropertyExpression
+ :abstractmethod:
-
+ Obtains the property that corresponds to the inverse of this property.
- .. py:method:: individuals() -> Iterable[OWLIndividual]
+ :returns: The inverse of this property. Note that this property will not necessarily be in the simplest form.
- 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:: get_named_property() -> OWLObjectProperty
+ :abstractmethod:
+ Get the named object property used in this property expression.
- .. py:method:: operands() -> Iterable[OWLIndividual]
+ :returns: P if this expression is either inv(P) or P.
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
- :returns: The operands.
+ .. py:method:: is_object_property_expression() -> bool
+ :returns: True if this is an object property.
- .. 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:class:: OWLObject
- .. py:method:: __hash__()
+ Base interface for OWL objects
- Return hash(self).
+ .. py:attribute:: __slots__
+ :value: ()
+
.. py:method:: __eq__(other)
+ :abstractmethod:
Return self==value.
+ .. py:method:: __hash__()
+ :abstractmethod:
+
+ Return hash(self).
+
+
.. py:method:: __repr__()
+ :abstractmethod:
Return repr(self).
+ .. py:method:: is_anonymous() -> bool
-.. py:class:: OWLNamedIndividual(iri: Union[owlapy.iri.IRI, str])
- Bases: :py:obj:`OWLIndividual`, :py:obj:`owlapy.owlobject.OWLEntity`
+.. py:class:: OWLEntity
- Represents a Named Individual in the OWL 2 Specification.
- .. py:property:: iri
+ Bases: :py:obj:`OWLNamedObject`
+
+ Represents Entities in the OWL 2 Specification.
+ .. py:attribute:: __slots__
+ :value: ()
- .. py:property:: str
+
+
+ .. py:method:: to_string_id() -> str
+
+
+ .. py:method:: is_anonymous() -> bool
+
+
+
+.. py:class:: OWLDatatype(iri: Union[owlapy.iri.IRI, owlapy.has.HasIRI])
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLEntity`, :py:obj:`owlapy.ranges.OWLDataRange`
+ Represents a Datatype (named data range) in the OWL 2 Specification.
.. py:attribute:: __slots__
:value: '_iri'
@@ -1741,7 +1777,7 @@ Attributes
.. py:attribute:: type_index
:type: Final
- :value: 1005
+ :value: 4001
@@ -1753,133 +1789,323 @@ Attributes
-.. py:class:: OWLOntologyID(ontology_iri: Optional[owlapy.iri.IRI] = None, version_iri: Optional[owlapy.iri.IRI] = None)
-
-
- An object that identifies an ontology. Since OWL 2, ontologies do not have to have an ontology IRI, or if they
- have an ontology IRI then they can optionally also have a version IRI. Instances of this OWLOntologyID class bundle
- identifying information of an ontology together. If an ontology doesn't have an ontology IRI then we say that it is
- "anonymous".
-
- .. py:attribute:: __slots__
- :value: ('_ontology_iri', '_version_iri')
-
-
+.. py:class:: OWLDataRange
- .. py:method:: get_ontology_iri() -> Optional[owlapy.iri.IRI]
- Gets the ontology IRI.
+ Bases: :py:obj:`OWLPropertyRange`
- :returns: Ontology IRI. If the ontology is anonymous, it will return None.
+ Represents a DataRange in the OWL 2 Specification.
- .. py:method:: get_version_iri() -> Optional[owlapy.iri.IRI]
+.. py:class:: HasOperands
- Gets the version IRI.
- :returns: Version IRI or None.
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_T`\ ]
+ An interface to objects that have a collection of operands.
- .. py:method:: get_default_document_iri() -> Optional[owlapy.iri.IRI]
+ :param _T: Operand type.
- Gets the IRI which is used as a default for the document that contain a representation of an ontology with
- this ID. This will be the version IRI if there is an ontology IRI and version IRI, else it will be the ontology
- IRI if there is an ontology IRI but no version IRI, else it will be None if there is no ontology IRI. See
- Ontology Documents in the OWL 2 Structural Specification.
+ .. py:attribute:: __slots__
+ :value: ()
- :returns: the IRI that can be used as a default for an ontology document, or None.
+
+ .. py:method:: operands() -> Iterable[_T]
+ :abstractmethod:
- .. py:method:: is_anonymous() -> bool
+ 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:class:: OWLPropertyExpression
- .. py:method:: __eq__(other)
- Return self==value.
+ Bases: :py:obj:`owlapy.owlobject.OWLObject`
+ Represents a property or possibly the inverse of a property.
+ .. py:attribute:: __slots__
+ :value: ()
-.. py:class:: OWLAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+ .. py:method:: is_data_property_expression() -> bool
- Bases: :py:obj:`owlapy.owlobject.OWLObject`
+ :returns: True if this is a data property.
- Represents Axioms in the OWL 2 Specification.
- An OWL ontology contains a set of axioms. These axioms can be annotation axioms, declaration axioms, imports axioms
- or logical axioms.
+ .. py:method:: is_object_property_expression() -> bool
- .. py:attribute:: __slots__
- :value: '_annotations'
+ :returns: True if this is an object property.
-
- .. py:method:: annotations() -> Optional[List[OWLAnnotation]]
+ .. py:method:: is_owl_top_object_property() -> bool
+ Determines if this is the owl:topObjectProperty.
- .. py:method:: is_annotated() -> bool
+ :returns: topObjectProperty.
+ :rtype: True if this property is the owl
- .. py:method:: is_logical_axiom() -> bool
+ .. py:method:: is_owl_top_data_property() -> bool
+ Determines if this is the owl:topDataProperty.
- .. py:method:: is_annotation_axiom() -> bool
+ :returns: topDataProperty.
+ :rtype: True if this property is the owl
-.. py:class:: OWLDatatype(iri: Union[owlapy.iri.IRI, owlapy.has.HasIRI])
+.. py:class:: OWLClassExpression
- Bases: :py:obj:`owlapy.owlobject.OWLEntity`, :py:obj:`owlapy.owl_class_expression.OWLDataRange`
+ Bases: :py:obj:`owlapy.ranges.OWLPropertyRange`
- Represents a Datatype (named data range) in the OWL 2 Specification.
+ An OWL 2 Class Expression.
.. py:attribute:: __slots__
- :value: '_iri'
+ :value: ()
+
+
+
+ .. py:method:: is_owl_thing() -> bool
+ :abstractmethod:
+
+ Determines if this expression is the built in class owl:Thing. This method does not determine if the class
+ is equivalent to owl:Thing.
+
+ :returns: Thing.
+ :rtype: True if this expression is owl
+
+
+ .. py:method:: is_owl_nothing() -> bool
+ :abstractmethod:
+
+ Determines if this expression is the built in class owl:Nothing. This method does not determine if the class
+ is equivalent to owl:Nothing.
+
+
+ .. py:method:: get_object_complement_of() -> OWLObjectComplementOf
+ :abstractmethod:
+
+ Gets the object complement of this class expression.
+
+ :returns: A class expression that is the complement of this class expression.
+
+
+ .. py:method:: get_nnf() -> OWLClassExpression
+ :abstractmethod:
+
+ Gets the negation normal form of the complement of this expression.
+
+ :returns: A expression that represents the NNF of the complement of this expression.
+
+
+
+.. py:class:: OWLClass(iri: IRI)
+
+
+ Bases: :py:obj:`OWLClassExpression`, :py:obj:`owlapy.owlobject.OWLEntity`
+
+ An OWL 2 named Class
+
+ .. py:property:: str
+
+
+ .. py:property:: reminder
+ :type: str
+
+ The reminder of the IRI
+
+ .. py:attribute:: __slots__
+ :value: ('_iri', '_is_nothing', '_is_thing')
.. py:attribute:: type_index
:type: Final
- :value: 4001
+ :value: 1001
- .. py:method:: get_iri() -> owlapy.iri.IRI
+ .. py:method:: get_iri() -> IRI
Gets the IRI of this object.
:returns: The IRI of this object.
+ .. py:method:: is_owl_thing() -> bool
-.. py:class:: OWLDatatypeRestriction(type_: OWLDatatype, facet_restrictions: Union[OWLFacetRestriction, Iterable[OWLFacetRestriction]])
+ Determines if this expression is the built in class owl:Thing. This method does not determine if the class
+ is equivalent to owl:Thing.
+ :returns: Thing.
+ :rtype: True if this expression is owl
- Bases: :py:obj:`owlapy.owl_class_expression.OWLDataRange`
- Represents a DatatypeRestriction data range in the OWL 2 Specification.
+ .. py:method:: is_owl_nothing() -> bool
+
+ Determines if this expression is the built in class owl:Nothing. This method does not determine if the class
+ is equivalent to owl:Nothing.
+
+
+ .. py:method:: get_object_complement_of() -> OWLObjectComplementOf
+
+ Gets the object complement of this class expression.
+
+ :returns: A class expression that is the complement of this class expression.
+
+
+ .. py:method:: get_nnf() -> OWLClass
+
+ Gets the negation normal form of the complement of this expression.
+
+ :returns: A expression that represents the NNF of the complement of this expression.
+
+
+
+.. py:class:: OWLIndividual
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLObject`
+
+ Represents a named or anonymous individual.
.. py:attribute:: __slots__
- :value: ('_type', '_facet_restrictions')
+ :value: ()
- .. py:attribute:: type_index
- :type: Final
- :value: 4006
+
+.. py:class:: OWLAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLObject`
+
+ Represents Axioms in the OWL 2 Specification.
+
+ An OWL ontology contains a set of axioms. These axioms can be annotation axioms, declaration axioms, imports axioms
+ or logical axioms.
+
+ .. py:attribute:: __slots__
+ :value: '_annotations'
- .. py:method:: get_datatype() -> OWLDatatype
+ .. py:method:: annotations() -> Optional[List[OWLAnnotation]]
- .. py:method:: get_facet_restrictions() -> Sequence[OWLFacetRestriction]
+ .. py:method:: is_annotated() -> bool
+
+
+ .. py:method:: is_logical_axiom() -> bool
+
+
+ .. py:method:: is_annotation_axiom() -> bool
+
+
+
+.. py:class:: OWLLogicalAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLAxiom`
+
+ A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
+ (including imports declarations) and annotation axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: is_logical_axiom() -> bool
+
+
+
+.. py:class:: OWLPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLLogicalAxiom`
+
+ The base interface for property axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLObjectPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLPropertyAxiom`
+
+ The base interface for object property axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLDataPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLPropertyAxiom`
+
+ The base interface for data property axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLIndividualAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLLogicalAxiom`
+
+ The base interface for individual axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLClassAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLLogicalAxiom`
+
+ The base interface for class axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLDeclarationAxiom(entity: owlapy.owlobject.OWLEntity, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLAxiom`
+
+ Represents a Declaration axiom in the OWL 2 Specification. A declaration axiom declares an entity in an ontology.
+ It doesn't affect the logical meaning of the ontology.
+
+ .. py:attribute:: __slots__
+ :value: '_entity'
+
+
+
+ .. py:method:: get_entity() -> owlapy.owlobject.OWLEntity
.. py:method:: __eq__(other)
@@ -1898,28 +2124,64 @@ Attributes
-.. py:class:: OWLFacetRestriction(facet: owlapy.vocab.OWLFacet, literal: Literals)
+.. py:class:: OWLDatatypeDefinitionAxiom(datatype: owlapy.types.OWLDatatype, datarange: owlapy.types.OWLDataRange, annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`owlapy.owlobject.OWLObject`
+ Bases: :py:obj:`OWLLogicalAxiom`
- A facet restriction is used to restrict a particular datatype.
+ Represents a DatatypeDefinition axiom in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ('_facet', '_literal')
+ :value: ('_datatype', '_datarange')
- .. py:attribute:: type_index
- :type: Final
- :value: 4007
+ .. py:method:: get_datatype() -> owlapy.types.OWLDatatype
+
+
+ .. py:method:: get_datarange() -> owlapy.types.OWLDataRange
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. 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`\ ]
+
+ Represents a HasKey axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_class_expression', '_property_expressions')
- .. py:method:: get_facet() -> owlapy.vocab.OWLFacet
+ .. py:method:: get_class_expression() -> owlapy.owl_class_expression.OWLClassExpression
- .. py:method:: get_facet_value() -> OWLLiteral
+ .. py:method:: get_property_expressions() -> List[owlapy.owl_property.OWLPropertyExpression]
+
+
+ .. py:method:: operands() -> Iterable[owlapy.owl_property.OWLPropertyExpression]
+
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ :returns: The operands.
.. py:method:: __eq__(other)
@@ -1938,181 +2200,254 @@ Attributes
-.. py:class:: OWLLiteral
+.. py:class:: OWLNaryAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`owlapy.owl_annotation.OWLAnnotationValue`
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_C`\ ], :py:obj:`OWLAxiom`
- Represents a Literal in the OWL 2 Specification.
+ Represents an axiom that contains two or more operands that could also be represented with multiple pairwise
+ axioms.
+
+ :param _C: Class of contained objects.
.. py:attribute:: __slots__
:value: ()
- .. py:attribute:: type_index
- :type: Final
- :value: 4008
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryAxiom[_C]]
+ :abstractmethod:
+
+
+
+.. py:class:: OWLNaryClassAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLClassAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`owlapy.owl_class_expression.OWLClassExpression`\ ]
+
+ Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise axioms.
+
+ .. py:attribute:: __slots__
+ :value: '_class_expressions'
- .. py:method:: get_literal() -> str
+ .. py:method:: class_expressions() -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
- Gets the lexical value of this literal. Note that the language tag is not included.
+ Gets all of the top level class expressions that appear in this axiom.
- :returns: The lexical value of this literal.
+ :returns: Sorted stream of class expressions that appear in the axiom.
- .. py:method:: is_boolean() -> bool
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryClassAxiom]
- Whether this literal is typed as boolean.
+ Gets this axiom as a set of pairwise axioms; if the axiom contains only two operands,
+ the axiom itself is returned unchanged, including its annotations.
+
+ :returns: This axiom as a set of pairwise axioms.
- .. py:method:: parse_boolean() -> bool
+ .. py:method:: __eq__(other)
- Parses the lexical value of this literal into a bool. The lexical value of this literal should be in the
- lexical space of the boolean datatype ("http://www.w3.org/2001/XMLSchema#boolean").
+ Return self==value.
- :returns: A bool value that is represented by this literal.
+ .. py:method:: __hash__()
- .. py:method:: is_double() -> bool
+ Return hash(self).
- Whether this literal is typed as double.
+ .. py:method:: __repr__()
- .. py:method:: parse_double() -> float
+ Return repr(self).
- Parses the lexical value of this literal into a double. The lexical value of this literal should be in the
- lexical space of the double datatype ("http://www.w3.org/2001/XMLSchema#double").
- :returns: A double value that is represented by this literal.
+.. py:class:: OWLEquivalentClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- .. py:method:: is_integer() -> bool
- Whether this literal is typed as integer.
+ Bases: :py:obj:`OWLNaryClassAxiom`
+ Represents an EquivalentClasses axiom in the OWL 2 Specification.
- .. py:method:: parse_integer() -> int
+ .. py:attribute:: __slots__
+ :value: ()
- Parses the lexical value of this literal into an integer. The lexical value of this literal should be in the
- lexical space of the integer datatype ("http://www.w3.org/2001/XMLSchema#integer").
+
- :returns: An integer value that is represented by this literal.
+ .. py:method:: contains_named_equivalent_class() -> bool
- .. py:method:: is_string() -> bool
+ .. py:method:: contains_owl_nothing() -> bool
- Whether this literal is typed as string.
+ .. py:method:: contains_owl_thing() -> bool
- .. py:method:: parse_string() -> str
- Parses the lexical value of this literal into a string. The lexical value of this literal should be in the
- lexical space of the string datatype ("http://www.w3.org/2001/XMLSchema#string").
+ .. py:method:: named_classes() -> Iterable[owlapy.owl_class_expression.OWLClass]
- :returns: A string value that is represented by this literal.
- .. py:method:: is_date() -> bool
+.. py:class:: OWLDisjointClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- Whether this literal is typed as date.
+ Bases: :py:obj:`OWLNaryClassAxiom`
- .. py:method:: parse_date() -> datetime.date
+ Represents a DisjointClasses axiom in the OWL 2 Specification.
- Parses the lexical value of this literal into a date. The lexical value of this literal should be in the
- lexical space of the date datatype ("http://www.w3.org/2001/XMLSchema#date").
+ .. py:attribute:: __slots__
+ :value: ()
- :returns: A date value that is represented by this literal.
+
- .. py:method:: is_datetime() -> bool
+.. py:class:: OWLNaryIndividualAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLIndividualAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`owlapy.owl_individual.OWLIndividual`\ ]
+
+ Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise individual axioms.
+
+ .. py:attribute:: __slots__
+ :value: '_individuals'
+
+
+
+ .. py:method:: individuals() -> Iterable[owlapy.owl_individual.OWLIndividual]
+
+ Get the individuals.
+
+ :returns: Generator containing the individuals.
+
+
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryIndividualAxiom]
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLDifferentIndividualsAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryIndividualAxiom`
+
+ Represents a DifferentIndividuals axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLSameIndividualAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryIndividualAxiom`
- Whether this literal is typed as dateTime.
+ Represents a SameIndividual axiom in the OWL 2 Specification.
+ .. py:attribute:: __slots__
+ :value: ()
- .. py:method:: parse_datetime() -> datetime.datetime
+
- Parses the lexical value of this literal into a datetime. The lexical value of this literal should be in the
- lexical space of the dateTime datatype ("http://www.w3.org/2001/XMLSchema#dateTime").
- :returns: A datetime value that is represented by this literal.
+.. py:class:: OWLNaryPropertyAxiom(properties: List[_P], annotations: Optional[Iterable[OWLAnnotation]] = None)
- .. py:method:: is_duration() -> bool
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`OWLPropertyAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`_P`\ ]
- Whether this literal is typed as duration.
+ Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise property axioms.
+ .. py:attribute:: __slots__
+ :value: '_properties'
- .. py:method:: parse_duration() -> pandas.Timedelta
+
- Parses the lexical value of this literal into a Timedelta. The lexical value of this literal should be in the
- lexical space of the duration datatype ("http://www.w3.org/2001/XMLSchema#duration").
+ .. py:method:: properties() -> Iterable[_P]
- :returns: A Timedelta value that is represented by this literal.
+ Get all the properties that appear in the axiom.
+ :returns: Generator containing the properties.
- .. py:method:: is_literal() -> bool
- :returns: true if the annotation value is a literal
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryPropertyAxiom]
- .. py:method:: as_literal() -> OWLLiteral
+ .. py:method:: __eq__(other)
- :returns: if the value is a literal, returns it. Return None otherwise
+ Return self==value.
- .. py:method:: to_python() -> Literals
+ .. py:method:: __hash__()
+ Return hash(self).
- .. py:method:: get_datatype() -> OWLDatatype
- :abstractmethod:
- Gets the OWLDatatype which types this literal.
+ .. py:method:: __repr__()
- :returns: The OWLDatatype that types this literal.
+ Return repr(self).
-.. py:class:: OWLQuantifiedDataRestriction(filler: owlapy.owl_class_expression.OWLDataRange)
+.. py:class:: OWLEquivalentObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`owlapy.owl_restriction.OWLQuantifiedRestriction`\ [\ :py:obj:`owlapy.owl_class_expression.OWLDataRange`\ ], :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
- Represents a quantified data restriction.
+ Represents EquivalentObjectProperties axioms in the OWL 2 Specification.
.. py:attribute:: __slots__
:value: ()
- .. py:method:: get_filler() -> owlapy.owl_class_expression.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.
+.. py:class:: OWLDisjointObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- :returns: the value
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+ Represents DisjointObjectProperties axioms in the OWL 2 Specification.
-.. py:class:: OWLDataCardinalityRestriction(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)
+ .. py:attribute:: __slots__
+ :value: ()
+
- Bases: :py:obj:`owlapy.owl_restriction.OWLCardinalityRestriction`\ [\ :py:obj:`owlapy.owl_class_expression.OWLDataRange`\ ], :py:obj:`OWLQuantifiedDataRestriction`, :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
- Represents Data Property Cardinality Restrictions in the OWL 2 specification.
+.. py:class:: OWLInverseObjectPropertiesAxiom(first: owlapy.owl_property.OWLObjectPropertyExpression, second: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+
+ Represents InverseObjectProperties axioms in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ()
+ :value: ('_first', '_second')
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+ .. py:method:: get_first_property() -> owlapy.owl_property.OWLObjectPropertyExpression
- :returns: Property being restricted.
+
+ .. py:method:: get_second_property() -> owlapy.owl_property.OWLObjectPropertyExpression
.. py:method:: __repr__()
@@ -2120,38 +2455,49 @@ Attributes
Return repr(self).
- .. py:method:: __eq__(other)
- Return self==value.
+.. py:class:: OWLEquivalentDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- .. py:method:: __hash__()
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
- Return hash(self).
+ Represents EquivalentDataProperties axioms in the OWL 2 Specification.
+ .. py:attribute:: __slots__
+ :value: ()
+
-.. py:class:: OWLDataAllValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)
+.. py:class:: OWLDisjointDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLQuantifiedDataRestriction`
- Represents DataAllValuesFrom class expressions in the OWL 2 Specification.
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
+
+ Represents DisjointDataProperties axioms in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: '_property'
+ :value: ()
- .. py:attribute:: type_index
- :type: Final
- :value: 3013
+
+.. py:class:: OWLSubClassOfAxiom(sub_class: owlapy.owl_class_expression.OWLClassExpression, super_class: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLClassAxiom`
+
+ Represents an SubClassOf axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_sub_class', '_super_class')
- .. py:method:: __repr__()
+ .. py:method:: get_sub_class() -> owlapy.owl_class_expression.OWLClassExpression
- Return repr(self).
+
+ .. py:method:: get_super_class() -> owlapy.owl_class_expression.OWLClassExpression
.. py:method:: __eq__(other)
@@ -2164,33 +2510,34 @@ Attributes
Return hash(self).
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+ .. py:method:: __repr__()
- :returns: Property being restricted.
+ Return repr(self).
-.. py:class:: OWLDataComplementOf(data_range: owlapy.owl_class_expression.OWLDataRange)
+.. py:class:: OWLDisjointUnionAxiom(cls_: owlapy.owl_class_expression.OWLClass, class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`owlapy.owl_class_expression.OWLDataRange`
+ Bases: :py:obj:`OWLClassAxiom`
- Represents DataComplementOf in the OWL 2 Specification.
+ Represents a DisjointUnion axiom in the OWL 2 Specification.
- .. py:attribute:: type_index
- :type: Final
- :value: 4002
+ .. py:attribute:: __slots__
+ :value: ('_cls', '_class_expressions')
- .. py:method:: get_data_range() -> owlapy.owl_class_expression.OWLDataRange
+ .. py:method:: get_owl_class() -> owlapy.owl_class_expression.OWLClass
- :returns: The wrapped data range.
+ .. py:method:: get_class_expressions() -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
- .. py:method:: __repr__()
- Return repr(self).
+ .. py:method:: get_owl_equivalent_classes_axiom() -> OWLEquivalentClassesAxiom
+
+
+ .. py:method:: get_owl_disjoint_classes_axiom() -> OWLDisjointClassesAxiom
.. py:method:: __eq__(other)
@@ -2203,54 +2550,28 @@ Attributes
Return hash(self).
+ .. py:method:: __repr__()
-.. py:class:: OWLDataExactCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)
-
-
- Bases: :py:obj:`OWLDataCardinalityRestriction`
-
- Represents DataExactCardinality restrictions in the OWL 2 Specification.
-
- .. py:attribute:: __slots__
- :value: ('_cardinality', '_filler', '_property')
-
-
-
- .. py:attribute:: type_index
- :type: Final
- :value: 3016
-
-
-
- .. py:method:: as_intersection_of_min_max() -> owlapy.owl_class_expression.OWLObjectIntersectionOf
-
- Obtains an equivalent form that is a conjunction of a min cardinality and max cardinality restriction.
-
- :returns: The semantically equivalent but structurally simpler form (= 1 R D) = >= 1 R D and <= 1 R D.
+ Return repr(self).
-.. py:class:: OWLDataHasValue(property: owlapy.owl_property.OWLDataPropertyExpression, value: OWLLiteral)
+.. py:class:: OWLClassAssertionAxiom(individual: owlapy.owl_individual.OWLIndividual, class_expression: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`owlapy.owl_restriction.OWLHasValueRestriction`\ [\ :py:obj:`OWLLiteral`\ ], :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
+ Bases: :py:obj:`OWLIndividualAxiom`
- Represents DataHasValue restrictions in the OWL 2 Specification.
+ Represents ClassAssertion axioms in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: '_property'
+ :value: ('_individual', '_class_expression')
- .. py:attribute:: type_index
- :type: Final
- :value: 3014
-
-
+ .. py:method:: get_individual() -> owlapy.owl_individual.OWLIndividual
- .. py:method:: __repr__()
- Return repr(self).
+ .. py:method:: get_class_expression() -> owlapy.owl_class_expression.OWLClassExpression
.. py:method:: __eq__(other)
@@ -2263,93 +2584,60 @@ Attributes
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
+ .. py:method:: __repr__()
- :returns: Property being restricted.
+ Return repr(self).
-.. py:class:: OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)
+.. py:class:: OWLAnnotationAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLDataCardinalityRestriction`
+ Bases: :py:obj:`OWLAxiom`
- Represents DataMaxCardinality restrictions in the OWL 2 Specification.
+ A super interface for annotation axioms.
.. py:attribute:: __slots__
- :value: ('_cardinality', '_filler', '_property')
+ :value: ()
- .. py:attribute:: type_index
- :type: Final
- :value: 3017
+ .. py:method:: is_annotation_axiom() -> bool
-
-.. py:class:: OWLDataMinCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)
+.. py:data:: Literals
+
- Bases: :py:obj:`OWLDataCardinalityRestriction`
+.. py:class:: OWLObjectHasValue(property: owlapy.owl_axiom.OWLObjectPropertyExpression, individual: owlapy.owl_axiom.OWLIndividual)
- Represents DataMinCardinality restrictions in the OWL 2 Specification.
- .. py:attribute:: __slots__
- :value: ('_cardinality', '_filler', '_property')
+ Bases: :py:obj:`owlapy.owl_restriction.OWLHasValueRestriction`\ [\ :py:obj:`owlapy.owl_axiom.OWLIndividual`\ ], :py:obj:`owlapy.owl_restriction.OWLObjectRestriction`
-
+ Represents an ObjectHasValue class expression in the OWL 2 Specification.
- .. py:attribute:: type_index
- :type: Final
- :value: 3015
+ .. py:attribute:: __slots__
+ :value: ('_property', '_v')
-
-.. py:class:: OWLDataOneOf(values: Union[OWLLiteral, Iterable[OWLLiteral]])
-
-
- Bases: :py:obj:`owlapy.owl_class_expression.OWLDataRange`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`OWLLiteral`\ ]
-
- Represents DataOneOf in the OWL 2 Specification.
-
.. py:attribute:: type_index
:type: Final
- :value: 4003
+ :value: 3007
- .. py:method:: values() -> Iterable[OWLLiteral]
-
- Gets the values that are in the oneOf.
-
- :returns: The values of this {@code DataOneOf} class expression.
-
-
- .. py:method:: operands() -> Iterable[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:: get_property() -> owlapy.owl_axiom.OWLObjectPropertyExpression
+ :returns: Property being restricted.
- .. py:method:: __hash__()
-
- Return hash(self).
+ .. py:method:: as_some_values_from() -> owlapy.owl_axiom.OWLClassExpression
- .. py:method:: __eq__(other)
+ A convenience method that obtains this restriction as an existential restriction with a nominal filler.
- Return self==value.
+ :returns: The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
.. py:method:: __repr__()
@@ -2358,32 +2646,46 @@ Attributes
-.. py:class:: OWLDataSomeValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)
+.. py:class:: OWLObjectOneOf(values: Union[owlapy.owl_axiom.OWLIndividual, owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLIndividual]])
- Bases: :py:obj:`OWLQuantifiedDataRestriction`
+ Bases: :py:obj:`owlapy.owl_class_expression.OWLAnonymousClassExpression`, :py:obj:`owlapy.owl_axiom.HasOperands`\ [\ :py:obj:`owlapy.owl_axiom.OWLIndividual`\ ]
- Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
+ Represents an ObjectOneOf class expression in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: '_property'
+ :value: '_values'
.. py:attribute:: type_index
:type: Final
- :value: 3012
+ :value: 3004
- .. py:method:: __repr__()
+ .. py:method:: individuals() -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLIndividual]
- Return repr(self).
+ 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:: __eq__(other)
+ .. py:method:: operands() -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLIndividual]
- Return self==value.
+ 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_axiom.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__()
@@ -2391,344 +2693,328 @@ Attributes
Return hash(self).
- .. py:method:: get_property() -> owlapy.owl_property.OWLDataPropertyExpression
+ .. py:method:: __eq__(other)
- :returns: Property being restricted.
+ Return self==value.
+
+
+ .. py:method:: __repr__()
+ Return repr(self).
-.. py:class:: OWLNaryDataRange(operands: Iterable[owlapy.owl_class_expression.OWLDataRange])
+.. py:class:: OWLOntologyID(ontology_iri: owlapy.owl_axiom.Optional[owlapy.iri.IRI] = None, version_iri: owlapy.owl_axiom.Optional[owlapy.iri.IRI] = None)
- Bases: :py:obj:`owlapy.owl_class_expression.OWLDataRange`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.owl_class_expression.OWLDataRange`\ ]
- OWLNaryDataRange.
+ An object that identifies an ontology. Since OWL 2, ontologies do not have to have an ontology IRI, or if they
+ have an ontology IRI then they can optionally also have a version IRI. Instances of this OWLOntologyID class bundle
+ identifying information of an ontology together. If an ontology doesn't have an ontology IRI then we say that it is
+ "anonymous".
.. py:attribute:: __slots__
- :value: ()
+ :value: ('_ontology_iri', '_version_iri')
- .. py:method:: operands() -> Iterable[owlapy.owl_class_expression.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:: get_ontology_iri() -> owlapy.owl_axiom.Optional[owlapy.iri.IRI]
+ Gets the ontology IRI.
- .. py:method:: __repr__()
+ :returns: Ontology IRI. If the ontology is anonymous, it will return None.
- Return repr(self).
+ .. py:method:: get_version_iri() -> owlapy.owl_axiom.Optional[owlapy.iri.IRI]
- .. py:method:: __eq__(other)
+ Gets the version IRI.
- Return self==value.
+ :returns: Version IRI or None.
- .. py:method:: __hash__()
+ .. py:method:: get_default_document_iri() -> owlapy.owl_axiom.Optional[owlapy.iri.IRI]
- Return hash(self).
+ Gets the IRI which is used as a default for the document that contain a representation of an ontology with
+ this ID. This will be the version IRI if there is an ontology IRI and version IRI, else it will be the ontology
+ IRI if there is an ontology IRI but no version IRI, else it will be None if there is no ontology IRI. See
+ Ontology Documents in the OWL 2 Structural Specification.
+ :returns: the IRI that can be used as a default for an ontology document, or None.
-.. py:class:: OWLDataUnionOf(operands: Iterable[owlapy.owl_class_expression.OWLDataRange])
+ .. py:method:: is_anonymous() -> bool
- Bases: :py:obj:`OWLNaryDataRange`
+ .. py:method:: __repr__()
- Represents a DataUnionOf data range in the OWL 2 Specification.
+ Return repr(self).
- .. py:attribute:: __slots__
- :value: '_operands'
-
+ .. py:method:: __eq__(other)
- .. py:attribute:: type_index
- :type: Final
- :value: 4005
+ Return self==value.
-
-.. py:class:: OWLDataIntersectionOf(operands: Iterable[owlapy.owl_class_expression.OWLDataRange])
+.. py:class:: OWLDatatypeRestriction(type_: owlapy.owl_axiom.OWLDatatype, facet_restrictions: Union[OWLFacetRestriction, owlapy.owl_axiom.Iterable[OWLFacetRestriction]])
- Bases: :py:obj:`OWLNaryDataRange`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLDataRange`
- Represents DataIntersectionOf in the OWL 2 Specification.
+ Represents a DatatypeRestriction data range in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: '_operands'
+ :value: ('_type', '_facet_restrictions')
.. py:attribute:: type_index
:type: Final
- :value: 4004
-
-
-
-
-.. py:class:: OWLImportsDeclaration(import_iri: owlapy.iri.IRI)
-
-
- Bases: :py:obj:`owlapy.has.HasIRI`
-
- Represents an import statement in an ontology.
-
- .. py:attribute:: __slots__
- :value: '_iri'
+ :value: 4006
- .. py:method:: get_iri() -> owlapy.iri.IRI
+ .. py:method:: get_datatype() -> owlapy.owl_axiom.OWLDatatype
- Gets the import IRI.
- :returns: The import IRI that points to the ontology to be imported. The imported ontology might have this IRI as
- its ontology IRI but this is not mandated. For example, an ontology with a non-resolvable ontology IRI
- can be deployed at a resolvable URL.
+ .. py:method:: get_facet_restrictions() -> Sequence[OWLFacetRestriction]
+ .. py:method:: __eq__(other)
-.. py:class:: OWLLogicalAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+ Return self==value.
- Bases: :py:obj:`OWLAxiom`
+ .. py:method:: __hash__()
- A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
- (including imports declarations) and annotation axioms.
+ Return hash(self).
- .. py:attribute:: __slots__
- :value: ()
-
+ .. py:method:: __repr__()
- .. py:method:: is_logical_axiom() -> bool
+ Return repr(self).
-.. py:class:: OWLPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLFacetRestriction(facet: owlapy.vocab.OWLFacet, literal: Literals)
- Bases: :py:obj:`OWLLogicalAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLObject`
- The base interface for property axioms.
+ A facet restriction is used to restrict a particular datatype.
.. py:attribute:: __slots__
- :value: ()
+ :value: ('_facet', '_literal')
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4007
-.. py:class:: OWLObjectPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+ .. py:method:: get_facet() -> owlapy.vocab.OWLFacet
- Bases: :py:obj:`OWLPropertyAxiom`
- The base interface for object property axioms.
+ .. py:method:: get_facet_value() -> OWLLiteral
- .. py:attribute:: __slots__
- :value: ()
-
+ .. py:method:: __eq__(other)
+ Return self==value.
-.. py:class:: OWLDataPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+ .. py:method:: __hash__()
- Bases: :py:obj:`OWLPropertyAxiom`
+ Return hash(self).
- The base interface for data property axioms.
- .. py:attribute:: __slots__
- :value: ()
+ .. py:method:: __repr__()
-
+ Return repr(self).
-.. py:class:: OWLIndividualAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLLiteral
- Bases: :py:obj:`OWLLogicalAxiom`
- The base interface for individual axioms.
+ 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:class:: OWLClassAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
-
-
- Bases: :py:obj:`OWLLogicalAxiom`
-
- The base interface for class axioms.
+
- .. py:attribute:: __slots__
- :value: ()
+ .. py:method:: get_literal() -> str
-
+ Gets the lexical value of this literal. Note that the language tag is not included.
+ :returns: The lexical value of this literal.
-.. py:class:: OWLDeclarationAxiom(entity: owlapy.owlobject.OWLEntity, annotations: Optional[Iterable[OWLAnnotation]] = None)
+ .. py:method:: is_boolean() -> bool
- Bases: :py:obj:`OWLAxiom`
+ Whether this literal is typed as boolean.
- Represents a Declaration axiom in the OWL 2 Specification. A declaration axiom declares an entity in an ontology.
- It doesn't affect the logical meaning of the ontology.
- .. py:attribute:: __slots__
- :value: '_entity'
+ .. py:method:: parse_boolean() -> bool
-
+ Parses the lexical value of this literal into a bool. The lexical value of this literal should be in the
+ lexical space of the boolean datatype ("http://www.w3.org/2001/XMLSchema#boolean").
- .. py:method:: get_entity() -> owlapy.owlobject.OWLEntity
+ :returns: A bool value that is represented by this literal.
- .. py:method:: __eq__(other)
+ .. py:method:: is_double() -> bool
- Return self==value.
+ Whether this literal is typed as double.
- .. py:method:: __hash__()
+ .. py:method:: parse_double() -> float
- Return hash(self).
+ Parses the lexical value of this literal into a double. The lexical value of this literal should be in the
+ lexical space of the double datatype ("http://www.w3.org/2001/XMLSchema#double").
+ :returns: A double value that is represented by this literal.
- .. py:method:: __repr__()
- Return repr(self).
+ .. py:method:: is_integer() -> bool
+ Whether this literal is typed as integer.
-.. py:class:: OWLDatatypeDefinitionAxiom(datatype: OWLDatatype, datarange: owlapy.owl_class_expression.OWLDataRange, annotations: Optional[Iterable[OWLAnnotation]] = None)
+ .. py:method:: parse_integer() -> int
+ Parses the lexical value of this literal into an integer. The lexical value of this literal should be in the
+ lexical space of the integer datatype ("http://www.w3.org/2001/XMLSchema#integer").
- Bases: :py:obj:`OWLLogicalAxiom`
+ :returns: An integer value that is represented by this literal.
- Represents a DatatypeDefinition axiom in the OWL 2 Specification.
- .. py:attribute:: __slots__
- :value: ('_datatype', '_datarange')
+ .. py:method:: is_string() -> bool
-
+ Whether this literal is typed as string.
- .. py:method:: get_datatype() -> OWLDatatype
+ .. py:method:: parse_string() -> str
- .. py:method:: get_datarange() -> owlapy.owl_class_expression.OWLDataRange
+ Parses the lexical value of this literal into a string. The lexical value of this literal should be in the
+ lexical space of the string datatype ("http://www.w3.org/2001/XMLSchema#string").
+ :returns: A string value that is represented by this literal.
- .. py:method:: __eq__(other)
- Return self==value.
+ .. py:method:: is_date() -> bool
+ Whether this literal is typed as date.
- .. py:method:: __hash__()
- Return hash(self).
+ .. py:method:: parse_date() -> datetime.date
+ Parses the lexical value of this literal into a date. The lexical value of this literal should be in the
+ lexical space of the date datatype ("http://www.w3.org/2001/XMLSchema#date").
- .. py:method:: __repr__()
+ :returns: A date value that is represented by this literal.
- Return repr(self).
+ .. py:method:: is_datetime() -> bool
+ Whether this literal is typed as dateTime.
-.. py:class:: OWLHasKeyAxiom(class_expression: owlapy.owl_class_expression.OWLClassExpression, property_expressions: List[owlapy.owl_property.OWLPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+ .. py:method:: parse_datetime() -> datetime.datetime
- Bases: :py:obj:`OWLLogicalAxiom`, :py:obj:`owlapy.has.HasOperands`\ [\ :py:obj:`owlapy.owl_property.OWLPropertyExpression`\ ]
+ Parses the lexical value of this literal into a datetime. The lexical value of this literal should be in the
+ lexical space of the dateTime datatype ("http://www.w3.org/2001/XMLSchema#dateTime").
- Represents a HasKey axiom in the OWL 2 Specification.
+ :returns: A datetime value that is represented by this literal.
- .. py:attribute:: __slots__
- :value: ('_class_expression', '_property_expressions')
-
+ .. py:method:: is_duration() -> bool
- .. py:method:: get_class_expression() -> owlapy.owl_class_expression.OWLClassExpression
+ Whether this literal is typed as duration.
- .. py:method:: get_property_expressions() -> List[owlapy.owl_property.OWLPropertyExpression]
+ .. py:method:: parse_duration() -> pandas.Timedelta
+ Parses the lexical value of this literal into a Timedelta. The lexical value of this literal should be in the
+ lexical space of the duration datatype ("http://www.w3.org/2001/XMLSchema#duration").
- .. py:method:: operands() -> Iterable[owlapy.owl_property.OWLPropertyExpression]
+ :returns: A Timedelta value that is represented by this literal.
- Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
- classes axiom.
- :returns: The operands.
+ .. py:method:: is_literal() -> bool
+ :returns: true if the annotation value is a literal
- .. py:method:: __eq__(other)
- Return self==value.
+ .. py:method:: as_literal() -> OWLLiteral
+ :returns: if the value is a literal, returns it. Return None otherwise
- .. py:method:: __hash__()
- Return hash(self).
+ .. py:method:: to_python() -> Literals
- .. py:method:: __repr__()
+ .. py:method:: get_datatype() -> owlapy.owl_axiom.OWLDatatype
+ :abstractmethod:
- Return repr(self).
+ Gets the OWLDatatype which types this literal.
+ :returns: The OWLDatatype that types this literal.
-.. py:class:: OWLNaryAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLQuantifiedDataRestriction(filler: owlapy.owl_axiom.OWLDataRange)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_C`\ ], :py:obj:`OWLAxiom`
- Represents an axiom that contains two or more operands that could also be represented with multiple pairwise
- axioms.
+ Bases: :py:obj:`owlapy.owl_restriction.OWLQuantifiedRestriction`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataRange`\ ], :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
- :param _C: Class of contained objects.
+ Represents a quantified data restriction.
.. py:attribute:: __slots__
:value: ()
- .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryAxiom[_C]]
- :abstractmethod:
+ .. py:method:: get_filler() -> owlapy.owl_axiom.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:: OWLNaryClassAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataCardinalityRestriction(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)
- Bases: :py:obj:`OWLClassAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`owlapy.owl_class_expression.OWLClassExpression`\ ]
- Represents an axiom that contains two or more operands that could also be represented with
- multiple pairwise axioms.
+ Bases: :py:obj:`owlapy.owl_restriction.OWLCardinalityRestriction`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataRange`\ ], :py:obj:`OWLQuantifiedDataRestriction`, :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
+
+ Represents Data Property Cardinality Restrictions in the OWL 2 specification.
.. py:attribute:: __slots__
- :value: '_class_expressions'
+ :value: ()
- .. py:method:: class_expressions() -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
-
- Gets all of the top level class expressions that appear in this axiom.
-
- :returns: Sorted stream of class expressions that appear in the axiom.
+ .. py:method:: get_property() -> owlapy.owl_axiom.OWLDataPropertyExpression
+ :returns: Property being restricted.
- .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryClassAxiom]
- Gets this axiom as a set of pairwise axioms; if the axiom contains only two operands,
- the axiom itself is returned unchanged, including its annotations.
+ .. py:method:: __repr__()
- :returns: This axiom as a set of pairwise axioms.
+ Return repr(self).
.. py:method:: __eq__(other)
@@ -2741,71 +3027,67 @@ Attributes
Return hash(self).
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-.. py:class:: OWLEquivalentClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataAllValuesFrom(property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)
- Bases: :py:obj:`OWLNaryClassAxiom`
+ Bases: :py:obj:`OWLQuantifiedDataRestriction`
- Represents an EquivalentClasses axiom in the OWL 2 Specification.
+ Represents DataAllValuesFrom class expressions in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ()
+ :value: '_property'
- .. py:method:: contains_named_equivalent_class() -> bool
-
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3013
- .. py:method:: contains_owl_nothing() -> bool
+
+ .. py:method:: __repr__()
- .. py:method:: contains_owl_thing() -> bool
+ Return repr(self).
- .. py:method:: named_classes() -> Iterable[owlapy.owl_class_expression.OWLClass]
+ .. py:method:: __eq__(other)
+ Return self==value.
-.. py:class:: OWLDisjointClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+ .. py:method:: __hash__()
+ Return hash(self).
- Bases: :py:obj:`OWLNaryClassAxiom`
- Represents a DisjointClasses axiom in the OWL 2 Specification.
+ .. py:method:: get_property() -> owlapy.owl_axiom.OWLDataPropertyExpression
- .. py:attribute:: __slots__
- :value: ()
+ :returns: Property being restricted.
-
-.. py:class:: OWLNaryIndividualAxiom(individuals: List[OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataComplementOf(data_range: owlapy.owl_axiom.OWLDataRange)
- Bases: :py:obj:`OWLIndividualAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`OWLIndividual`\ ]
+ Bases: :py:obj:`owlapy.owl_axiom.OWLDataRange`
- Represents an axiom that contains two or more operands that could also be represented with
- multiple pairwise individual axioms.
+ Represents DataComplementOf in the OWL 2 Specification.
- .. py:attribute:: __slots__
- :value: '_individuals'
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4002
- .. py:method:: individuals() -> Iterable[OWLIndividual]
+ .. py:method:: get_data_range() -> owlapy.owl_axiom.OWLDataRange
- Get the individuals.
+ :returns: The wrapped data range.
- :returns: Generator containing the individuals.
+ .. py:method:: __repr__()
- .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryIndividualAxiom]
+ Return repr(self).
.. py:method:: __eq__(other)
@@ -2818,59 +3100,54 @@ Attributes
Return hash(self).
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-.. py:class:: OWLDifferentIndividualsAxiom(individuals: List[OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataExactCardinality(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)
- Bases: :py:obj:`OWLNaryIndividualAxiom`
+ Bases: :py:obj:`OWLDataCardinalityRestriction`
- Represents a DifferentIndividuals axiom in the OWL 2 Specification.
+ Represents DataExactCardinality restrictions in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ()
+ :value: ('_cardinality', '_filler', '_property')
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3016
-.. py:class:: OWLSameIndividualAxiom(individuals: List[OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
-
+
- Bases: :py:obj:`OWLNaryIndividualAxiom`
+ .. py:method:: as_intersection_of_min_max() -> owlapy.owl_class_expression.OWLObjectIntersectionOf
- Represents a SameIndividual axiom in the OWL 2 Specification.
+ Obtains an equivalent form that is a conjunction of a min cardinality and max cardinality restriction.
- .. py:attribute:: __slots__
- :value: ()
+ :returns: The semantically equivalent but structurally simpler form (= 1 R D) = >= 1 R D and <= 1 R D.
-
-.. py:class:: OWLNaryPropertyAxiom(properties: List[_P], annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataHasValue(property: owlapy.owl_axiom.OWLDataPropertyExpression, value: OWLLiteral)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`OWLPropertyAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`_P`\ ]
+ Bases: :py:obj:`owlapy.owl_restriction.OWLHasValueRestriction`\ [\ :py:obj:`OWLLiteral`\ ], :py:obj:`owlapy.owl_restriction.OWLDataRestriction`
- Represents an axiom that contains two or more operands that could also be represented with
- multiple pairwise property axioms.
+ Represents DataHasValue restrictions in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: '_properties'
+ :value: '_property'
- .. py:method:: properties() -> Iterable[_P]
-
- Get all the properties that appear in the axiom.
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3014
- :returns: Generator containing the properties.
+
+ .. py:method:: __repr__()
- .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryPropertyAxiom]
+ Return repr(self).
.. py:method:: __eq__(other)
@@ -2883,104 +3160,122 @@ Attributes
Return hash(self).
- .. py:method:: __repr__()
-
- Return repr(self).
+ .. py:method:: as_some_values_from() -> owlapy.owl_axiom.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:class:: OWLEquivalentObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+ .. py:method:: get_property() -> owlapy.owl_axiom.OWLDataPropertyExpression
- Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+ :returns: Property being restricted.
- Represents EquivalentObjectProperties axioms in the OWL 2 Specification.
- .. py:attribute:: __slots__
- :value: ()
-
+.. py:class:: OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)
-.. py:class:: OWLDisjointObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+ Bases: :py:obj:`OWLDataCardinalityRestriction`
+ Represents DataMaxCardinality restrictions in the OWL 2 Specification.
- Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+ .. py:attribute:: __slots__
+ :value: ('_cardinality', '_filler', '_property')
- Represents DisjointObjectProperties axioms in the OWL 2 Specification.
+
- .. py:attribute:: __slots__
- :value: ()
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3017
-.. py:class:: OWLInverseObjectPropertiesAxiom(first: owlapy.owl_property.OWLObjectPropertyExpression, second: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataMinCardinality(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)
- Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+ Bases: :py:obj:`OWLDataCardinalityRestriction`
- Represents InverseObjectProperties axioms in the OWL 2 Specification.
+ Represents DataMinCardinality restrictions in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ('_first', '_second')
+ :value: ('_cardinality', '_filler', '_property')
- .. py:method:: get_first_property() -> owlapy.owl_property.OWLObjectPropertyExpression
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3015
+
- .. py:method:: get_second_property() -> owlapy.owl_property.OWLObjectPropertyExpression
+.. py:class:: OWLDataOneOf(values: Union[OWLLiteral, owlapy.owl_axiom.Iterable[OWLLiteral]])
- .. py:method:: __repr__()
- Return repr(self).
+ Bases: :py:obj:`owlapy.owl_axiom.OWLDataRange`, :py:obj:`owlapy.owl_axiom.HasOperands`\ [\ :py:obj:`OWLLiteral`\ ]
+ Represents DataOneOf in the OWL 2 Specification.
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4003
-.. py:class:: OWLEquivalentDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+ .. py:method:: values() -> owlapy.owl_axiom.Iterable[OWLLiteral]
- Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
+ Gets the values that are in the oneOf.
- Represents EquivalentDataProperties axioms in the OWL 2 Specification.
+ :returns: The values of this {@code DataOneOf} class expression.
- .. py:attribute:: __slots__
- :value: ()
-
+ .. py:method:: operands() -> owlapy.owl_axiom.Iterable[OWLLiteral]
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
-.. py:class:: OWLDisjointDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+ :returns: The operands.
- Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
+ .. py:method:: __hash__()
- Represents DisjointDataProperties axioms in the OWL 2 Specification.
+ Return hash(self).
- .. py:attribute:: __slots__
- :value: ()
-
+ .. py:method:: __eq__(other)
+ Return self==value.
-.. py:class:: OWLSubClassOfAxiom(sub_class: owlapy.owl_class_expression.OWLClassExpression, super_class: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+ .. py:method:: __repr__()
- Bases: :py:obj:`OWLClassAxiom`
+ Return repr(self).
- Represents an SubClassOf axiom in the OWL 2 Specification.
+
+
+.. py:class:: OWLDataSomeValuesFrom(property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)
+
+
+ Bases: :py:obj:`OWLQuantifiedDataRestriction`
+
+ Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ('_sub_class', '_super_class')
+ :value: '_property'
- .. py:method:: get_sub_class() -> owlapy.owl_class_expression.OWLClassExpression
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 3012
+
- .. py:method:: get_super_class() -> owlapy.owl_class_expression.OWLClassExpression
+ .. py:method:: __repr__()
+
+ Return repr(self).
.. py:method:: __eq__(other)
@@ -2993,34 +3288,35 @@ Attributes
Return hash(self).
- .. py:method:: __repr__()
+ .. py:method:: get_property() -> owlapy.owl_axiom.OWLDataPropertyExpression
- Return repr(self).
+ :returns: Property being restricted.
-.. py:class:: OWLDisjointUnionAxiom(cls_: owlapy.owl_class_expression.OWLClass, class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLNaryDataRange(operands: owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange])
- Bases: :py:obj:`OWLClassAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLDataRange`, :py:obj:`owlapy.owl_axiom.HasOperands`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataRange`\ ]
- Represents a DisjointUnion axiom in the OWL 2 Specification.
+ OWLNaryDataRange.
.. py:attribute:: __slots__
- :value: ('_cls', '_class_expressions')
+ :value: ()
- .. py:method:: get_owl_class() -> owlapy.owl_class_expression.OWLClass
-
+ .. py:method:: operands() -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange]
- .. py:method:: get_class_expressions() -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+ :returns: The operands.
- .. py:method:: get_owl_equivalent_classes_axiom() -> OWLEquivalentClassesAxiom
+ .. py:method:: __repr__()
- .. py:method:: get_owl_disjoint_classes_axiom() -> OWLDisjointClassesAxiom
+ Return repr(self).
.. py:method:: __eq__(other)
@@ -3033,59 +3329,64 @@ Attributes
Return hash(self).
- .. py:method:: __repr__()
-
- Return repr(self).
-
-
-.. py:class:: OWLClassAssertionAxiom(individual: OWLIndividual, class_expression: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataUnionOf(operands: owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange])
- Bases: :py:obj:`OWLIndividualAxiom`
+ Bases: :py:obj:`OWLNaryDataRange`
- Represents ClassAssertion axioms in the OWL 2 Specification.
+ Represents a DataUnionOf data range in the OWL 2 Specification.
.. py:attribute:: __slots__
- :value: ('_individual', '_class_expression')
+ :value: '_operands'
- .. py:method:: get_individual() -> OWLIndividual
-
-
- .. py:method:: get_class_expression() -> owlapy.owl_class_expression.OWLClassExpression
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4005
+
- .. py:method:: __eq__(other)
- Return self==value.
+.. py:class:: OWLDataIntersectionOf(operands: owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange])
- .. py:method:: __hash__()
+ Bases: :py:obj:`OWLNaryDataRange`
- Return hash(self).
+ Represents DataIntersectionOf in the OWL 2 Specification.
+ .. py:attribute:: __slots__
+ :value: '_operands'
- .. py:method:: __repr__()
+
- Return repr(self).
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4004
+
-.. py:class:: OWLAnnotationAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLImportsDeclaration(import_iri: owlapy.iri.IRI)
- Bases: :py:obj:`OWLAxiom`
+ Bases: :py:obj:`owlapy.has.HasIRI`
- A super interface for annotation axioms.
+ Represents an import statement in an ontology.
.. py:attribute:: __slots__
- :value: ()
+ :value: '_iri'
- .. py:method:: is_annotation_axiom() -> bool
+ .. py:method:: get_iri() -> owlapy.iri.IRI
+
+ Gets the import IRI.
+
+ :returns: The import IRI that points to the ontology to be imported. The imported ontology might have this IRI as
+ its ontology IRI but this is not mandated. For example, an ontology with a non-resolvable ontology IRI
+ can be deployed at a resolvable URL.
@@ -3112,7 +3413,7 @@ Attributes
.. py:class:: OWLAnnotation(property: OWLAnnotationProperty, value: owlapy.owl_annotation.OWLAnnotationValue)
- Bases: :py:obj:`owlapy.owlobject.OWLObject`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLObject`
Annotations are used in the various types of annotation axioms, which bind annotations to their subjects
(i.e. axioms or declarations).
@@ -3156,7 +3457,7 @@ Attributes
.. py:class:: OWLAnnotationAssertionAxiom(subject: owlapy.owl_annotation.OWLAnnotationSubject, annotation: OWLAnnotation)
- Bases: :py:obj:`OWLAnnotationAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLAnnotationAxiom`
Represents AnnotationAssertion axioms in the OWL 2 specification.
@@ -3202,10 +3503,10 @@ Attributes
-.. py:class:: OWLSubAnnotationPropertyOfAxiom(sub_property: OWLAnnotationProperty, super_property: OWLAnnotationProperty, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLSubAnnotationPropertyOfAxiom(sub_property: OWLAnnotationProperty, super_property: OWLAnnotationProperty, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLAnnotationAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLAnnotationAxiom`
Represents an SubAnnotationPropertyOf axiom in the OWL 2 specification.
@@ -3236,10 +3537,10 @@ Attributes
-.. py:class:: OWLAnnotationPropertyDomainAxiom(property_: OWLAnnotationProperty, domain: owlapy.iri.IRI, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLAnnotationPropertyDomainAxiom(property_: OWLAnnotationProperty, domain: owlapy.iri.IRI, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLAnnotationAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLAnnotationAxiom`
Represents an AnnotationPropertyDomain axiom in the OWL 2 specification.
@@ -3270,10 +3571,10 @@ Attributes
-.. py:class:: OWLAnnotationPropertyRangeAxiom(property_: OWLAnnotationProperty, range_: owlapy.iri.IRI, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLAnnotationPropertyRangeAxiom(property_: OWLAnnotationProperty, range_: owlapy.iri.IRI, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLAnnotationAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLAnnotationAxiom`
Represents an AnnotationPropertyRange axiom in the OWL 2 specification.
@@ -3304,10 +3605,10 @@ Attributes
-.. py:class:: OWLSubPropertyAxiom(sub_property: _P, super_property: _P, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLSubPropertyAxiom(sub_property: _P, super_property: _P, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`OWLPropertyAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`owlapy.owl_axiom.OWLPropertyAxiom`
Base interface for object and data sub-property axioms.
@@ -3338,10 +3639,10 @@ Attributes
-.. py:class:: OWLSubObjectPropertyOfAxiom(sub_property: owlapy.owl_property.OWLObjectPropertyExpression, super_property: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLSubObjectPropertyOfAxiom(sub_property: owlapy.owl_axiom.OWLObjectPropertyExpression, super_property: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLSubPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+ Bases: :py:obj:`OWLSubPropertyAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLObjectPropertyExpression`\ ], :py:obj:`owlapy.owl_axiom.OWLObjectPropertyAxiom`
Represents a SubObjectPropertyOf axiom in the OWL 2 specification.
@@ -3351,10 +3652,10 @@ Attributes
-.. py:class:: OWLSubDataPropertyOfAxiom(sub_property: owlapy.owl_property.OWLDataPropertyExpression, super_property: owlapy.owl_property.OWLDataPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLSubDataPropertyOfAxiom(sub_property: owlapy.owl_axiom.OWLDataPropertyExpression, super_property: owlapy.owl_axiom.OWLDataPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLSubPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
+ Bases: :py:obj:`OWLSubPropertyAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataPropertyExpression`\ ], :py:obj:`owlapy.owl_axiom.OWLDataPropertyAxiom`
Represents a SubDataPropertyOf axiom in the OWL 2 specification.
@@ -3364,10 +3665,10 @@ Attributes
-.. py:class:: OWLPropertyAssertionAxiom(subject: OWLIndividual, property_: _P, object_: _C, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: _P, object_: _C, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ , :py:obj:`_C`\ ], :py:obj:`OWLIndividualAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.Generic`\ [\ :py:obj:`_P`\ , :py:obj:`_C`\ ], :py:obj:`owlapy.owl_axiom.OWLIndividualAxiom`
Represents a PropertyAssertion axiom in the OWL 2 specification.
@@ -3376,7 +3677,7 @@ Attributes
- .. py:method:: get_subject() -> OWLIndividual
+ .. py:method:: get_subject() -> owlapy.owl_axiom.OWLIndividual
.. py:method:: get_property() -> _P
@@ -3401,10 +3702,10 @@ Attributes
-.. py:class:: OWLObjectPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLObjectPropertyExpression, object_: OWLIndividual, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLObjectPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLObjectPropertyExpression, object_: owlapy.owl_axiom.OWLIndividual, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ , :py:obj:`OWLIndividual`\ ]
+ Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLObjectPropertyExpression`\ , :py:obj:`owlapy.owl_axiom.OWLIndividual`\ ]
Represents an ObjectPropertyAssertion axiom in the OWL 2 specification.
@@ -3414,10 +3715,10 @@ Attributes
-.. py:class:: OWLNegativeObjectPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLObjectPropertyExpression, object_: OWLIndividual, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLNegativeObjectPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLObjectPropertyExpression, object_: owlapy.owl_axiom.OWLIndividual, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ , :py:obj:`OWLIndividual`\ ]
+ Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLObjectPropertyExpression`\ , :py:obj:`owlapy.owl_axiom.OWLIndividual`\ ]
Represents a NegativeObjectPropertyAssertion axiom in the OWL 2 specification.
@@ -3427,10 +3728,10 @@ Attributes
-.. py:class:: OWLDataPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLDataPropertyExpression, object_: OWLLiteral, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLDataPropertyExpression, object_: OWLLiteral, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ , :py:obj:`OWLLiteral`\ ]
+ Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataPropertyExpression`\ , :py:obj:`OWLLiteral`\ ]
Represents an DataPropertyAssertion axiom in the OWL 2 specification.
@@ -3440,10 +3741,10 @@ Attributes
-.. py:class:: OWLNegativeDataPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLDataPropertyExpression, object_: OWLLiteral, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLNegativeDataPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLDataPropertyExpression, object_: OWLLiteral, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ , :py:obj:`OWLLiteral`\ ]
+ Bases: :py:obj:`OWLPropertyAssertionAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataPropertyExpression`\ , :py:obj:`OWLLiteral`\ ]
Represents an NegativeDataPropertyAssertion axiom in the OWL 2 specification.
@@ -3453,10 +3754,10 @@ Attributes
-.. py:class:: OWLUnaryPropertyAxiom(property_: _P, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLUnaryPropertyAxiom(property_: _P, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`OWLPropertyAxiom`
+ Bases: :py:obj:`owlapy.owl_axiom.Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`owlapy.owl_axiom.OWLPropertyAxiom`
Unary property axiom.
@@ -3469,10 +3770,10 @@ Attributes
-.. py:class:: OWLObjectPropertyCharacteristicAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLObjectPropertyCharacteristicAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+ Bases: :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLObjectPropertyExpression`\ ], :py:obj:`owlapy.owl_axiom.OWLObjectPropertyAxiom`
Base interface for functional object property axiom.
@@ -3497,7 +3798,7 @@ Attributes
-.. py:class:: OWLFunctionalObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLFunctionalObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLObjectPropertyCharacteristicAxiom`
@@ -3510,7 +3811,7 @@ Attributes
-.. py:class:: OWLAsymmetricObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLAsymmetricObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLObjectPropertyCharacteristicAxiom`
@@ -3523,7 +3824,7 @@ Attributes
-.. py:class:: OWLInverseFunctionalObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLInverseFunctionalObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLObjectPropertyCharacteristicAxiom`
@@ -3536,7 +3837,7 @@ Attributes
-.. py:class:: OWLIrreflexiveObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLIrreflexiveObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLObjectPropertyCharacteristicAxiom`
@@ -3549,7 +3850,7 @@ Attributes
-.. py:class:: OWLReflexiveObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLReflexiveObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLObjectPropertyCharacteristicAxiom`
@@ -3562,7 +3863,7 @@ Attributes
-.. py:class:: OWLSymmetricObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLSymmetricObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLObjectPropertyCharacteristicAxiom`
@@ -3575,7 +3876,7 @@ Attributes
-.. py:class:: OWLTransitiveObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLTransitiveObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLObjectPropertyCharacteristicAxiom`
@@ -3588,10 +3889,10 @@ Attributes
-.. py:class:: OWLDataPropertyCharacteristicAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataPropertyCharacteristicAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
+ Bases: :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataPropertyExpression`\ ], :py:obj:`owlapy.owl_axiom.OWLDataPropertyAxiom`
Base interface for Functional data property axiom.
@@ -3616,7 +3917,7 @@ Attributes
-.. py:class:: OWLFunctionalDataPropertyAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLFunctionalDataPropertyAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
Bases: :py:obj:`OWLDataPropertyCharacteristicAxiom`
@@ -3629,10 +3930,10 @@ Attributes
-.. py:class:: OWLPropertyDomainAxiom(property_: _P, domain: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLPropertyDomainAxiom(property_: _P, domain: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`_P`\ ]
+ Bases: :py:obj:`owlapy.owl_axiom.Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`_P`\ ]
Represents ObjectPropertyDomain axioms in the OWL 2 specification.
@@ -3641,7 +3942,7 @@ Attributes
- .. py:method:: get_domain() -> owlapy.owl_class_expression.OWLClassExpression
+ .. py:method:: get_domain() -> owlapy.owl_axiom.OWLClassExpression
.. py:method:: __eq__(other)
@@ -3660,10 +3961,10 @@ Attributes
-.. py:class:: OWLPropertyRangeAxiom(property_: _P, range_: _R, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLPropertyRangeAxiom(property_: _P, range_: _R, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ , :py:obj:`_R`\ ], :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`_P`\ ]
+ Bases: :py:obj:`owlapy.owl_axiom.Generic`\ [\ :py:obj:`_P`\ , :py:obj:`_R`\ ], :py:obj:`OWLUnaryPropertyAxiom`\ [\ :py:obj:`_P`\ ]
Represents ObjectPropertyRange axioms in the OWL 2 specification.
@@ -3691,10 +3992,10 @@ Attributes
-.. py:class:: OWLObjectPropertyDomainAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, domain: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLObjectPropertyDomainAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, domain: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyDomainAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ]
+ Bases: :py:obj:`OWLPropertyDomainAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLObjectPropertyExpression`\ ]
Represents a ObjectPropertyDomain axiom in the OWL 2 Specification.
@@ -3704,10 +4005,10 @@ Attributes
-.. py:class:: OWLDataPropertyDomainAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, domain: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataPropertyDomainAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, domain: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyDomainAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ]
+ Bases: :py:obj:`OWLPropertyDomainAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataPropertyExpression`\ ]
Represents a DataPropertyDomain axiom in the OWL 2 Specification.
@@ -3717,10 +4018,10 @@ Attributes
-.. py:class:: OWLObjectPropertyRangeAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, range_: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLObjectPropertyRangeAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, range_: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyRangeAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ , :py:obj:`owlapy.owl_class_expression.OWLClassExpression`\ ]
+ Bases: :py:obj:`OWLPropertyRangeAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLObjectPropertyExpression`\ , :py:obj:`owlapy.owl_axiom.OWLClassExpression`\ ]
Represents a ObjectPropertyRange axiom in the OWL 2 Specification.
@@ -3730,10 +4031,10 @@ Attributes
-.. py:class:: OWLDataPropertyRangeAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, range_: owlapy.owl_class_expression.OWLDataRange, annotations: Optional[Iterable[OWLAnnotation]] = None)
+.. py:class:: OWLDataPropertyRangeAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, range_: owlapy.owl_axiom.OWLDataRange, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)
- Bases: :py:obj:`OWLPropertyRangeAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ , :py:obj:`owlapy.owl_class_expression.OWLDataRange`\ ]
+ Bases: :py:obj:`OWLPropertyRangeAxiom`\ [\ :py:obj:`owlapy.owl_axiom.OWLDataPropertyExpression`\ , :py:obj:`owlapy.owl_axiom.OWLDataRange`\ ]
Represents a DataPropertyRange axiom in the OWL 2 Specification.
@@ -3746,7 +4047,7 @@ Attributes
.. py:class:: OWLOntology
- Bases: :py:obj:`owlapy.owlobject.OWLObject`
+ Bases: :py:obj:`owlapy.owl_axiom.OWLObject`
Represents an OWL 2 Ontology in the OWL 2 specification.
@@ -3768,7 +4069,7 @@ Attributes
- .. py:method:: classes_in_signature() -> Iterable[owlapy.owl_class_expression.OWLClass]
+ .. py:method:: classes_in_signature() -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClass]
:abstractmethod:
Gets the classes in the signature of this object.
@@ -3776,7 +4077,7 @@ Attributes
:returns: Classes in the signature of this object.
- .. py:method:: data_properties_in_signature() -> Iterable[owlapy.owl_property.OWLDataProperty]
+ .. py:method:: data_properties_in_signature() -> owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty]
:abstractmethod:
Get the data properties that are in the signature of this object.
@@ -3784,7 +4085,7 @@ Attributes
:returns: Data properties that are in the signature of this object.
- .. py:method:: object_properties_in_signature() -> Iterable[owlapy.owl_property.OWLObjectProperty]
+ .. py:method:: object_properties_in_signature() -> owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLObjectProperty]
:abstractmethod:
A convenience method that obtains the object properties that are in the signature of this object.
@@ -3792,7 +4093,7 @@ Attributes
:returns: Object properties that are in the signature of this object.
- .. py:method:: individuals_in_signature() -> Iterable[OWLNamedIndividual]
+ .. py:method:: individuals_in_signature() -> owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual]
:abstractmethod:
A convenience method that obtains the individuals that are in the signature of this object.
@@ -3800,7 +4101,7 @@ Attributes
:returns: Individuals that are in the signature of this object.
- .. py:method:: equivalent_classes_axioms(c: owlapy.owl_class_expression.OWLClass) -> Iterable[OWLEquivalentClassesAxiom]
+ .. py:method:: equivalent_classes_axioms(c: owlapy.owl_axiom.OWLClass) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLEquivalentClassesAxiom]
:abstractmethod:
Gets all of the equivalent axioms in this ontology that contain the specified class as an operand.
@@ -3810,7 +4111,7 @@ Attributes
:returns: EquivalentClasses axioms contained in this ontology.
- .. py:method:: general_class_axioms() -> Iterable[OWLClassAxiom]
+ .. py:method:: general_class_axioms() -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassAxiom]
:abstractmethod:
Get the general class axioms of this ontology. This includes SubClass axioms with a complex class expression
@@ -3819,7 +4120,7 @@ Attributes
:returns: General class axioms contained in this ontology.
- .. py:method:: data_property_domain_axioms(property: owlapy.owl_property.OWLDataProperty) -> Iterable[OWLDataPropertyDomainAxiom]
+ .. py:method:: data_property_domain_axioms(property: owlapy.owl_property.OWLDataProperty) -> owlapy.owl_axiom.Iterable[OWLDataPropertyDomainAxiom]
:abstractmethod:
Gets the OWLDataPropertyDomainAxiom objects where the property is equal to the specified property.
@@ -3829,7 +4130,7 @@ Attributes
:returns: The axioms matching the search.
- .. py:method:: data_property_range_axioms(property: owlapy.owl_property.OWLDataProperty) -> Iterable[OWLDataPropertyRangeAxiom]
+ .. py:method:: data_property_range_axioms(property: owlapy.owl_property.OWLDataProperty) -> owlapy.owl_axiom.Iterable[OWLDataPropertyRangeAxiom]
:abstractmethod:
Gets the OWLDataPropertyRangeAxiom objects where the property is equal to the specified property.
@@ -3839,7 +4140,7 @@ Attributes
:returns: The axioms matching the search.
- .. py:method:: object_property_domain_axioms(property: owlapy.owl_property.OWLObjectProperty) -> Iterable[OWLObjectPropertyDomainAxiom]
+ .. py:method:: object_property_domain_axioms(property: owlapy.owl_property.OWLObjectProperty) -> owlapy.owl_axiom.Iterable[OWLObjectPropertyDomainAxiom]
:abstractmethod:
Gets the OWLObjectPropertyDomainAxiom objects where the property is equal to the specified property.
@@ -3849,7 +4150,7 @@ Attributes
:returns: The axioms matching the search.
- .. py:method:: object_property_range_axioms(property: owlapy.owl_property.OWLObjectProperty) -> Iterable[OWLObjectPropertyRangeAxiom]
+ .. py:method:: object_property_range_axioms(property: owlapy.owl_property.OWLObjectProperty) -> owlapy.owl_axiom.Iterable[OWLObjectPropertyRangeAxiom]
:abstractmethod:
Gets the OWLObjectPropertyRangeAxiom objects where the property is equal to the specified property.
@@ -3958,7 +4259,7 @@ Attributes
:raises ChangeApplied.UNSUCCESSFULLY: if the change was not applied successfully.
- .. py:method:: add_axiom(ontology: OWLOntology, axiom: OWLAxiom)
+ .. py:method:: add_axiom(ontology: OWLOntology, axiom: owlapy.owl_axiom.OWLAxiom)
:abstractmethod:
A convenience method that adds a single axiom to an ontology.
@@ -3967,7 +4268,7 @@ Attributes
:param axiom: The axiom to be added.
- .. py:method:: remove_axiom(ontology: OWLOntology, axiom: OWLAxiom)
+ .. py:method:: remove_axiom(ontology: OWLOntology, axiom: owlapy.owl_axiom.OWLAxiom)
:abstractmethod:
A convenience method that removes a single axiom from an ontology.
@@ -3998,7 +4299,7 @@ Attributes
- .. py:method:: data_property_domains(pe: owlapy.owl_property.OWLDataProperty, direct: bool = False) -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ .. py:method:: data_property_domains(pe: owlapy.owl_property.OWLDataProperty, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression]
:abstractmethod:
Gets the class expressions that are the direct or indirect domains of this property with respect to the
@@ -4015,7 +4316,7 @@ Attributes
(Note, rdfs:Literal is the top datatype).
- .. py:method:: object_property_domains(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ .. py:method:: object_property_domains(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression]
:abstractmethod:
Gets the class expressions that are the direct or indirect domains of this property with respect to the
@@ -4031,7 +4332,7 @@ Attributes
super_classes(ObjectSomeValuesFrom(pe owl:Thing), false) together with N if N is non-empty.
- .. py:method:: object_property_ranges(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ .. py:method:: object_property_ranges(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression]
:abstractmethod:
Gets the class expressions that are the direct or indirect ranges of this property with respect to the
@@ -4048,7 +4349,7 @@ Attributes
if N is non-empty.
- .. py:method:: equivalent_classes(ce: owlapy.owl_class_expression.OWLClassExpression, only_named: bool = True) -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ .. py:method:: equivalent_classes(ce: owlapy.owl_axiom.OWLClassExpression, only_named: bool = True) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression]
:abstractmethod:
Gets the class expressions that are equivalent to the specified class expression with respect to the set of
@@ -4063,7 +4364,7 @@ Attributes
bottom node, will be returned.
- .. py:method:: disjoint_classes(ce: owlapy.owl_class_expression.OWLClassExpression, only_named: bool = True) -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ .. py:method:: disjoint_classes(ce: owlapy.owl_axiom.OWLClassExpression, only_named: bool = True) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression]
:abstractmethod:
Gets the class expressions that are disjoint with specified class expression with respect to the set of
@@ -4076,7 +4377,7 @@ Attributes
or StrictSubClassOf(D ObjectComplementOf(ce)).
- .. py:method:: different_individuals(ind: OWLNamedIndividual) -> Iterable[OWLNamedIndividual]
+ .. py:method:: different_individuals(ind: owlapy.owl_individual.OWLNamedIndividual) -> owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual]
:abstractmethod:
Gets the individuals that are different from the specified individual with respect to the set of
@@ -4087,7 +4388,7 @@ Attributes
:returns: All individuals x where the set of reasoner axioms entails DifferentIndividuals(ind x).
- .. py:method:: same_individuals(ind: OWLNamedIndividual) -> Iterable[OWLNamedIndividual]
+ .. py:method:: same_individuals(ind: owlapy.owl_individual.OWLNamedIndividual) -> owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual]
:abstractmethod:
Gets the individuals that are the same as the specified individual with respect to the set of
@@ -4098,7 +4399,7 @@ Attributes
:returns: All individuals x where the root ontology imports closure entails SameIndividual(ind x).
- .. py:method:: equivalent_object_properties(op: owlapy.owl_property.OWLObjectPropertyExpression) -> Iterable[owlapy.owl_property.OWLObjectPropertyExpression]
+ .. py:method:: equivalent_object_properties(op: owlapy.owl_axiom.OWLObjectPropertyExpression) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLObjectPropertyExpression]
:abstractmethod:
Gets the simplified object properties that are equivalent to the specified object property with respect
@@ -4111,7 +4412,7 @@ Attributes
then owl:bottomDataProperty will be returned.
- .. py:method:: equivalent_data_properties(dp: owlapy.owl_property.OWLDataProperty) -> Iterable[owlapy.owl_property.OWLDataProperty]
+ .. py:method:: equivalent_data_properties(dp: owlapy.owl_property.OWLDataProperty) -> owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty]
:abstractmethod:
Gets the data properties that are equivalent to the specified data property with respect to the set of
@@ -4124,7 +4425,7 @@ Attributes
be returned.
- .. py:method:: data_property_values(ind: OWLNamedIndividual, pe: owlapy.owl_property.OWLDataProperty, direct: bool = True) -> Iterable[OWLLiteral]
+ .. py:method:: data_property_values(ind: owlapy.owl_individual.OWLNamedIndividual, pe: owlapy.owl_property.OWLDataProperty, direct: bool = True) -> owlapy.owl_axiom.Iterable[OWLLiteral]
:abstractmethod:
Gets the data property values for the specified individual and data property expression.
@@ -4138,7 +4439,7 @@ Attributes
axioms entails DataPropertyAssertion(pe ind l).
- .. py:method:: object_property_values(ind: OWLNamedIndividual, pe: owlapy.owl_property.OWLObjectPropertyExpression, direct: bool = True) -> Iterable[OWLNamedIndividual]
+ .. py:method:: object_property_values(ind: owlapy.owl_individual.OWLNamedIndividual, pe: owlapy.owl_axiom.OWLObjectPropertyExpression, direct: bool = True) -> owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual]
:abstractmethod:
Gets the object property values for the specified individual and object property expression.
@@ -4159,7 +4460,7 @@ Attributes
the current root ontology specified by the changes.
- .. py:method:: instances(ce: owlapy.owl_class_expression.OWLClassExpression, direct: bool = False) -> Iterable[OWLNamedIndividual]
+ .. py:method:: instances(ce: owlapy.owl_axiom.OWLClassExpression, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual]
:abstractmethod:
Gets the individuals which are instances of the specified class expression.
@@ -4174,7 +4475,7 @@ Attributes
nothing returned.
- .. py:method:: sub_classes(ce: owlapy.owl_class_expression.OWLClassExpression, direct: bool = False, only_named: bool = True) -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ .. py:method:: sub_classes(ce: owlapy.owl_axiom.OWLClassExpression, direct: bool = False, only_named: bool = True) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression]
:abstractmethod:
Gets the set of named classes that are the strict (potentially direct) subclasses of the specified class
@@ -4190,7 +4491,7 @@ Attributes
nothing will be returned.
- .. py:method:: disjoint_object_properties(op: owlapy.owl_property.OWLObjectPropertyExpression) -> Iterable[owlapy.owl_property.OWLObjectPropertyExpression]
+ .. py:method:: disjoint_object_properties(op: owlapy.owl_axiom.OWLObjectPropertyExpression) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLObjectPropertyExpression]
:abstractmethod:
Gets the simplified object properties that are disjoint with the specified object property with respect
@@ -4203,7 +4504,7 @@ Attributes
StrictSubObjectPropertyOf(e ObjectPropertyComplementOf(op)).
- .. py:method:: disjoint_data_properties(dp: owlapy.owl_property.OWLDataProperty) -> Iterable[owlapy.owl_property.OWLDataProperty]
+ .. py:method:: disjoint_data_properties(dp: owlapy.owl_property.OWLDataProperty) -> owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty]
:abstractmethod:
Gets the data properties that are disjoint with the specified data property with respect
@@ -4216,7 +4517,7 @@ Attributes
StrictSubDataPropertyOf(e DataPropertyComplementOf(dp)).
- .. py:method:: sub_data_properties(dp: owlapy.owl_property.OWLDataProperty, direct: bool = False) -> Iterable[owlapy.owl_property.OWLDataProperty]
+ .. py:method:: sub_data_properties(dp: owlapy.owl_property.OWLDataProperty, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty]
:abstractmethod:
Gets the set of named data properties that are the strict (potentially direct) subproperties of the
@@ -4232,7 +4533,7 @@ Attributes
returned.
- .. py:method:: super_data_properties(dp: owlapy.owl_property.OWLDataProperty, direct: bool = False) -> Iterable[owlapy.owl_property.OWLDataProperty]
+ .. py:method:: super_data_properties(dp: owlapy.owl_property.OWLDataProperty, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty]
:abstractmethod:
Gets the stream of data properties that are the strict (potentially direct) super properties of the
@@ -4247,7 +4548,7 @@ Attributes
:returns: Iterable of super properties.
- .. py:method:: sub_object_properties(op: owlapy.owl_property.OWLObjectPropertyExpression, direct: bool = False) -> Iterable[owlapy.owl_property.OWLObjectPropertyExpression]
+ .. py:method:: sub_object_properties(op: owlapy.owl_axiom.OWLObjectPropertyExpression, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLObjectPropertyExpression]
:abstractmethod:
Gets the stream of simplified object property expressions that are the strict (potentially direct)
@@ -4265,7 +4566,7 @@ Attributes
If pe is equivalent to owl:bottomObjectProperty then nothing will be returned.
- .. py:method:: super_object_properties(op: owlapy.owl_property.OWLObjectPropertyExpression, direct: bool = False) -> Iterable[owlapy.owl_property.OWLObjectPropertyExpression]
+ .. py:method:: super_object_properties(op: owlapy.owl_axiom.OWLObjectPropertyExpression, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLObjectPropertyExpression]
:abstractmethod:
Gets the stream of object properties that are the strict (potentially direct) super properties of the
@@ -4281,7 +4582,7 @@ Attributes
:returns: Iterable of super properties.
- .. py:method:: types(ind: OWLNamedIndividual, direct: bool = False) -> Iterable[owlapy.owl_class_expression.OWLClass]
+ .. py:method:: types(ind: owlapy.owl_individual.OWLNamedIndividual, direct: bool = False) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClass]
:abstractmethod:
Gets the named classes which are (potentially direct) types of the specified named individual.
@@ -4314,7 +4615,7 @@ Attributes
Return True if this reasoner is using a triplestore to retrieve instances.
- .. py:method:: super_classes(ce: owlapy.owl_class_expression.OWLClassExpression, direct: bool = False, only_named: bool = True) -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+ .. py:method:: super_classes(ce: owlapy.owl_axiom.OWLClassExpression, direct: bool = False, only_named: bool = True) -> owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression]
:abstractmethod:
Gets the stream of named classes that are the strict (potentially direct) super classes of the specified
@@ -4402,12 +4703,12 @@ Attributes
.. py:data:: NUMERIC_DATATYPES
- :type: Final[Set[OWLDatatype]]
+ :type: Final[Set[owlapy.owl_axiom.OWLDatatype]]
.. py:data:: TIME_DATATYPES
- :type: Final[Set[OWLDatatype]]
+ :type: Final[Set[owlapy.owl_axiom.OWLDatatype]]
diff --git a/_sources/autoapi/owlapy/owl_axiom/index.rst.txt b/_sources/autoapi/owlapy/owl_axiom/index.rst.txt
new file mode 100644
index 0000000..20d6e3f
--- /dev/null
+++ b/_sources/autoapi/owlapy/owl_axiom/index.rst.txt
@@ -0,0 +1,669 @@
+:py:mod:`owlapy.owl_axiom`
+==========================
+
+.. py:module:: owlapy.owl_axiom
+
+
+Module Contents
+---------------
+
+Classes
+~~~~~~~
+
+.. autoapisummary::
+
+ owlapy.owl_axiom.OWLAxiom
+ owlapy.owl_axiom.OWLLogicalAxiom
+ owlapy.owl_axiom.OWLPropertyAxiom
+ owlapy.owl_axiom.OWLObjectPropertyAxiom
+ owlapy.owl_axiom.OWLDataPropertyAxiom
+ owlapy.owl_axiom.OWLIndividualAxiom
+ owlapy.owl_axiom.OWLClassAxiom
+ owlapy.owl_axiom.OWLDeclarationAxiom
+ owlapy.owl_axiom.OWLDatatypeDefinitionAxiom
+ owlapy.owl_axiom.OWLHasKeyAxiom
+ owlapy.owl_axiom.OWLNaryAxiom
+ owlapy.owl_axiom.OWLNaryClassAxiom
+ owlapy.owl_axiom.OWLEquivalentClassesAxiom
+ owlapy.owl_axiom.OWLDisjointClassesAxiom
+ owlapy.owl_axiom.OWLNaryIndividualAxiom
+ owlapy.owl_axiom.OWLDifferentIndividualsAxiom
+ owlapy.owl_axiom.OWLSameIndividualAxiom
+ owlapy.owl_axiom.OWLNaryPropertyAxiom
+ owlapy.owl_axiom.OWLEquivalentObjectPropertiesAxiom
+ owlapy.owl_axiom.OWLDisjointObjectPropertiesAxiom
+ owlapy.owl_axiom.OWLInverseObjectPropertiesAxiom
+ owlapy.owl_axiom.OWLEquivalentDataPropertiesAxiom
+ owlapy.owl_axiom.OWLDisjointDataPropertiesAxiom
+ owlapy.owl_axiom.OWLSubClassOfAxiom
+ owlapy.owl_axiom.OWLDisjointUnionAxiom
+ owlapy.owl_axiom.OWLClassAssertionAxiom
+ owlapy.owl_axiom.OWLAnnotationAxiom
+
+
+
+
+.. py:class:: OWLAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLObject`
+
+ Represents Axioms in the OWL 2 Specification.
+
+ An OWL ontology contains a set of axioms. These axioms can be annotation axioms, declaration axioms, imports axioms
+ or logical axioms.
+
+ .. py:attribute:: __slots__
+ :value: '_annotations'
+
+
+
+ .. py:method:: annotations() -> Optional[List[OWLAnnotation]]
+
+
+ .. py:method:: is_annotated() -> bool
+
+
+ .. py:method:: is_logical_axiom() -> bool
+
+
+ .. py:method:: is_annotation_axiom() -> bool
+
+
+
+.. py:class:: OWLLogicalAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLAxiom`
+
+ A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
+ (including imports declarations) and annotation axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: is_logical_axiom() -> bool
+
+
+
+.. py:class:: OWLPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLLogicalAxiom`
+
+ The base interface for property axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLObjectPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLPropertyAxiom`
+
+ The base interface for object property axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLDataPropertyAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLPropertyAxiom`
+
+ The base interface for data property axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLIndividualAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLLogicalAxiom`
+
+ The base interface for individual axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLClassAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLLogicalAxiom`
+
+ The base interface for class axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLDeclarationAxiom(entity: owlapy.owlobject.OWLEntity, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLAxiom`
+
+ Represents a Declaration axiom in the OWL 2 Specification. A declaration axiom declares an entity in an ontology.
+ It doesn't affect the logical meaning of the ontology.
+
+ .. py:attribute:: __slots__
+ :value: '_entity'
+
+
+
+ .. py:method:: get_entity() -> owlapy.owlobject.OWLEntity
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLDatatypeDefinitionAxiom(datatype: owlapy.types.OWLDatatype, datarange: owlapy.types.OWLDataRange, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLLogicalAxiom`
+
+ Represents a DatatypeDefinition axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_datatype', '_datarange')
+
+
+
+ .. py:method:: get_datatype() -> owlapy.types.OWLDatatype
+
+
+ .. py:method:: get_datarange() -> owlapy.types.OWLDataRange
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. 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`\ ]
+
+ Represents a HasKey axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_class_expression', '_property_expressions')
+
+
+
+ .. py:method:: get_class_expression() -> owlapy.owl_class_expression.OWLClassExpression
+
+
+ .. py:method:: get_property_expressions() -> List[owlapy.owl_property.OWLPropertyExpression]
+
+
+ .. py:method:: operands() -> Iterable[owlapy.owl_property.OWLPropertyExpression]
+
+ Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+ classes axiom.
+
+ :returns: The operands.
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLNaryAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_C`\ ], :py:obj:`OWLAxiom`
+
+ Represents an axiom that contains two or more operands that could also be represented with multiple pairwise
+ axioms.
+
+ :param _C: Class of contained objects.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryAxiom[_C]]
+ :abstractmethod:
+
+
+
+.. py:class:: OWLNaryClassAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLClassAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`owlapy.owl_class_expression.OWLClassExpression`\ ]
+
+ Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise axioms.
+
+ .. py:attribute:: __slots__
+ :value: '_class_expressions'
+
+
+
+ .. py:method:: class_expressions() -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+
+ Gets all of the top level class expressions that appear in this axiom.
+
+ :returns: Sorted stream of class expressions that appear in the axiom.
+
+
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryClassAxiom]
+
+ Gets this axiom as a set of pairwise axioms; if the axiom contains only two operands,
+ the axiom itself is returned unchanged, including its annotations.
+
+ :returns: This axiom as a set of pairwise axioms.
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLEquivalentClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryClassAxiom`
+
+ Represents an EquivalentClasses axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: contains_named_equivalent_class() -> bool
+
+
+ .. py:method:: contains_owl_nothing() -> bool
+
+
+ .. py:method:: contains_owl_thing() -> bool
+
+
+ .. py:method:: named_classes() -> Iterable[owlapy.owl_class_expression.OWLClass]
+
+
+
+.. py:class:: OWLDisjointClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryClassAxiom`
+
+ Represents a DisjointClasses axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLNaryIndividualAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLIndividualAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`owlapy.owl_individual.OWLIndividual`\ ]
+
+ Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise individual axioms.
+
+ .. py:attribute:: __slots__
+ :value: '_individuals'
+
+
+
+ .. py:method:: individuals() -> Iterable[owlapy.owl_individual.OWLIndividual]
+
+ Get the individuals.
+
+ :returns: Generator containing the individuals.
+
+
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryIndividualAxiom]
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLDifferentIndividualsAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryIndividualAxiom`
+
+ Represents a DifferentIndividuals axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLSameIndividualAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryIndividualAxiom`
+
+ Represents a SameIndividual axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLNaryPropertyAxiom(properties: List[_P], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`Generic`\ [\ :py:obj:`_P`\ ], :py:obj:`OWLPropertyAxiom`, :py:obj:`OWLNaryAxiom`\ [\ :py:obj:`_P`\ ]
+
+ Represents an axiom that contains two or more operands that could also be represented with
+ multiple pairwise property axioms.
+
+ .. py:attribute:: __slots__
+ :value: '_properties'
+
+
+
+ .. py:method:: properties() -> Iterable[_P]
+
+ Get all the properties that appear in the axiom.
+
+ :returns: Generator containing the properties.
+
+
+ .. py:method:: as_pairwise_axioms() -> Iterable[OWLNaryPropertyAxiom]
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLEquivalentObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+
+ Represents EquivalentObjectProperties axioms in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLDisjointObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+
+ Represents DisjointObjectProperties axioms in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLInverseObjectPropertiesAxiom(first: owlapy.owl_property.OWLObjectPropertyExpression, second: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLObjectPropertyExpression`\ ], :py:obj:`OWLObjectPropertyAxiom`
+
+ Represents InverseObjectProperties axioms in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_first', '_second')
+
+
+
+ .. py:method:: get_first_property() -> owlapy.owl_property.OWLObjectPropertyExpression
+
+
+ .. py:method:: get_second_property() -> owlapy.owl_property.OWLObjectPropertyExpression
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLEquivalentDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
+
+ Represents EquivalentDataProperties axioms in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLDisjointDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLNaryPropertyAxiom`\ [\ :py:obj:`owlapy.owl_property.OWLDataPropertyExpression`\ ], :py:obj:`OWLDataPropertyAxiom`
+
+ Represents DisjointDataProperties axioms in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLSubClassOfAxiom(sub_class: owlapy.owl_class_expression.OWLClassExpression, super_class: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLClassAxiom`
+
+ Represents an SubClassOf axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_sub_class', '_super_class')
+
+
+
+ .. py:method:: get_sub_class() -> owlapy.owl_class_expression.OWLClassExpression
+
+
+ .. py:method:: get_super_class() -> owlapy.owl_class_expression.OWLClassExpression
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLDisjointUnionAxiom(cls_: owlapy.owl_class_expression.OWLClass, class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLClassAxiom`
+
+ Represents a DisjointUnion axiom in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_cls', '_class_expressions')
+
+
+
+ .. py:method:: get_owl_class() -> owlapy.owl_class_expression.OWLClass
+
+
+ .. py:method:: get_class_expressions() -> Iterable[owlapy.owl_class_expression.OWLClassExpression]
+
+
+ .. py:method:: get_owl_equivalent_classes_axiom() -> OWLEquivalentClassesAxiom
+
+
+ .. py:method:: get_owl_disjoint_classes_axiom() -> OWLDisjointClassesAxiom
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLClassAssertionAxiom(individual: owlapy.owl_individual.OWLIndividual, class_expression: owlapy.owl_class_expression.OWLClassExpression, annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLIndividualAxiom`
+
+ Represents ClassAssertion axioms in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: ('_individual', '_class_expression')
+
+
+
+ .. py:method:: get_individual() -> owlapy.owl_individual.OWLIndividual
+
+
+ .. py:method:: get_class_expression() -> owlapy.owl_class_expression.OWLClassExpression
+
+
+ .. py:method:: __eq__(other)
+
+ Return self==value.
+
+
+ .. py:method:: __hash__()
+
+ Return hash(self).
+
+
+ .. py:method:: __repr__()
+
+ Return repr(self).
+
+
+
+.. py:class:: OWLAnnotationAxiom(annotations: Optional[Iterable[OWLAnnotation]] = None)
+
+
+ Bases: :py:obj:`OWLAxiom`
+
+ A super interface for annotation axioms.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+ .. py:method:: is_annotation_axiom() -> bool
+
+
+
diff --git a/_sources/autoapi/owlapy/owl_individual/index.rst.txt b/_sources/autoapi/owlapy/owl_individual/index.rst.txt
new file mode 100644
index 0000000..3441895
--- /dev/null
+++ b/_sources/autoapi/owlapy/owl_individual/index.rst.txt
@@ -0,0 +1,65 @@
+:py:mod:`owlapy.owl_individual`
+===============================
+
+.. py:module:: owlapy.owl_individual
+
+
+Module Contents
+---------------
+
+Classes
+~~~~~~~
+
+.. autoapisummary::
+
+ owlapy.owl_individual.OWLIndividual
+ owlapy.owl_individual.OWLNamedIndividual
+
+
+
+
+.. py:class:: OWLIndividual
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLObject`
+
+ Represents a named or anonymous individual.
+
+ .. py:attribute:: __slots__
+ :value: ()
+
+
+
+
+.. py:class:: OWLNamedIndividual(iri: Union[owlapy.iri.IRI, str])
+
+
+ Bases: :py:obj:`OWLIndividual`, :py:obj:`owlapy.owlobject.OWLEntity`
+
+ Represents a Named Individual in the OWL 2 Specification.
+
+ .. py:property:: iri
+
+
+ .. py:property:: str
+
+
+ .. py:attribute:: __slots__
+ :value: '_iri'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 1005
+
+
+
+ .. py:method:: get_iri() -> owlapy.iri.IRI
+
+ Gets the IRI of this object.
+
+ :returns: The IRI of this object.
+
+
+
diff --git a/_sources/autoapi/owlapy/types/index.rst.txt b/_sources/autoapi/owlapy/types/index.rst.txt
new file mode 100644
index 0000000..a2b6339
--- /dev/null
+++ b/_sources/autoapi/owlapy/types/index.rst.txt
@@ -0,0 +1,45 @@
+:py:mod:`owlapy.types`
+======================
+
+.. py:module:: owlapy.types
+
+
+Module Contents
+---------------
+
+Classes
+~~~~~~~
+
+.. autoapisummary::
+
+ owlapy.types.OWLDatatype
+
+
+
+
+.. py:class:: OWLDatatype(iri: Union[owlapy.iri.IRI, owlapy.has.HasIRI])
+
+
+ Bases: :py:obj:`owlapy.owlobject.OWLEntity`, :py:obj:`owlapy.ranges.OWLDataRange`
+
+ Represents a Datatype (named data range) in the OWL 2 Specification.
+
+ .. py:attribute:: __slots__
+ :value: '_iri'
+
+
+
+ .. py:attribute:: type_index
+ :type: Final
+ :value: 4001
+
+
+
+ .. py:method:: get_iri() -> owlapy.iri.IRI
+
+ Gets the IRI of this object.
+
+ :returns: The IRI of this object.
+
+
+
diff --git a/autoapi/owlapy/has/index.html b/autoapi/owlapy/has/index.html
index 487f82e..482e96f 100644
--- a/autoapi/owlapy/has/index.html
+++ b/autoapi/owlapy/has/index.html
@@ -71,13 +71,16 @@
owlapy.iriowlapy.namespacesowlapy.owl_annotationowlapy.owl_axiomowlapy.owl_class_expressionowlapy.owl_individualowlapy.owl_propertyowlapy.owl_restrictionowlapy.owlobjectowlapy.parserowlapy.rangesowlapy.renderowlapy.typesowlapy.utilowlapy.vocabowlapy.iriowlapy.namespacesowlapy.owl_annotationowlapy.owl_axiomowlapy.owl_class_expressionowlapy.owl_individualowlapy.owl_propertyowlapy.owl_restrictionowlapy.owlobjectowlapy.parserowlapy.rangesowlapy.renderowlapy.typesowlapy.utilowlapy.vocabSubmodulesowlapy.iri
owlapy.namespacesowlapy.owl_annotationowlapy.owl_axiomowlapy.owl_class_expressionowlapy.owl_individualowlapy.owl_propertyowlapy.owl_restrictionowlapy.owlobjectowlapy.parserowlapy.rangesowlapy.renderowlapy.typesowlapy.utilowlapy.vocabowlapy.namespacesowlapy.owl_annotationowlapy.owl_axiomowlapy.owl_class_expressionowlapy.owl_individualowlapy.owl_propertyowlapy.owl_restrictionowlapy.owlobjectowlapy.parserowlapy.rangesowlapy.renderowlapy.typesowlapy.utilowlapy.vocabOWLObjectHasSelfOWLObjectMaxCardinalityOWLObjectExactCardinalityLiteralsOWLIndividualOWLObjectHasValueOWLObjectOneOfOWLNamedIndividualOWLOntologyIDOWLAxiomOWLIndividualOWLDataPropertyExpressionOWLObjectPropertyExpressionOWLObjectOWLEntityOWLDatatypeOWLDatatypeRestrictionOWLFacetRestrictionOWLLiteralOWLQuantifiedDataRestrictionOWLDataCardinalityRestrictionOWLDataAllValuesFromOWLDataComplementOfOWLDataExactCardinalityOWLDataHasValueOWLDataMaxCardinalityOWLDataMinCardinalityOWLDataOneOfOWLDataSomeValuesFromOWLNaryDataRangeOWLDataUnionOfOWLDataIntersectionOfOWLImportsDeclarationOWLDataRangeHasOperandsOWLPropertyExpressionOWLClassExpressionOWLClassOWLIndividualOWLAxiomOWLLogicalAxiomOWLPropertyAxiomOWLObjectPropertyAxiomOWLDisjointUnionAxiomOWLClassAssertionAxiomOWLAnnotationAxiomLiteralsOWLObjectHasValueOWLObjectOneOfOWLOntologyIDOWLDatatypeRestrictionOWLFacetRestrictionOWLLiteralOWLQuantifiedDataRestrictionOWLDataCardinalityRestrictionOWLDataAllValuesFromOWLDataComplementOfOWLDataExactCardinalityOWLDataHasValueOWLDataMaxCardinalityOWLDataMinCardinalityOWLDataOneOfOWLDataSomeValuesFromOWLNaryDataRangeOWLDataUnionOfOWLDataIntersectionOfOWLImportsDeclarationOWLAnnotationPropertyOWLAnnotationOWLAnnotationAssertionAxiom
owlapy.model
-@TODO: CD: This is not a python code. We should refactor this model module.
Submodules
@@ -276,10 +285,10 @@ Classes
Enumerations for OWL facets.
Base interface for OWL objects
Represents Entities in the OWL 2 Specification.
Classes
Simple class to access the IRI.
An interface to objects that have a collection of operands.
Classes
OWLNaryBooleanClassExpression.
An OWL 2 Class Expression.
Classes
OWL Objects that can be the ranges of properties.
Represents a DataRange in the OWL 2 Specification.
An OWL 2 named Class
Classes
Represents an OWLObjectIntersectionOf class expression in the OWL 2 Specification.
A high level interface to describe different types of object properties.
A marker interface for properties that aren't expression i.e. named properties. By definition, properties
Represents a property or possibly the inverse of a property.
A high level interface to describe different types of data properties.
Classes
Represents an ObjectExactCardinality restriction in the OWL 2 Specification.
Represents a named or anonymous individual.
Represents a Named Individual in the OWL 2 Specification.
Represents an ObjectHasValue class expression in the OWL 2 Specification.
Represents a named or anonymous individual.
Represents an ObjectOneOf class expression in the OWL 2 Specification.
A high level interface to describe different types of data properties.
Represents a Named Individual in the OWL 2 Specification.
A high level interface to describe different types of object properties.
An object that identifies an ontology. Since OWL 2, ontologies do not have to have an ontology IRI, or if they
Base interface for OWL objects
Represents Axioms in the OWL 2 Specification.
Represents Entities in the OWL 2 Specification.
Represents a Datatype (named data range) in the OWL 2 Specification.
Represents a DatatypeRestriction data range in the OWL 2 Specification.
A facet restriction is used to restrict a particular datatype.
Represents a Literal in the OWL 2 Specification.
Represents a quantified data restriction.
Represents Data Property Cardinality Restrictions in the OWL 2 specification.
Represents DataAllValuesFrom class expressions in the OWL 2 Specification.
Represents DataComplementOf in the OWL 2 Specification.
Represents DataExactCardinality restrictions in the OWL 2 Specification.
Represents DataHasValue restrictions in the OWL 2 Specification.
Represents DataMaxCardinality restrictions in the OWL 2 Specification.
Represents DataMinCardinality restrictions in the OWL 2 Specification.
Represents a DataRange in the OWL 2 Specification.
Represents DataOneOf in the OWL 2 Specification.
An interface to objects that have a collection of operands.
Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
Represents a property or possibly the inverse of a property.
OWLNaryDataRange.
An OWL 2 Class Expression.
Represents a DataUnionOf data range in the OWL 2 Specification.
An OWL 2 named Class
Represents DataIntersectionOf in the OWL 2 Specification.
Represents a named or anonymous individual.
Represents an import statement in an ontology.
Represents Axioms in the OWL 2 Specification.
A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
Classes
A super interface for annotation axioms.
Represents an ObjectHasValue class expression in the OWL 2 Specification.
Represents an ObjectOneOf class expression in the OWL 2 Specification.
An object that identifies an ontology. Since OWL 2, ontologies do not have to have an ontology IRI, or if they
Represents a DatatypeRestriction data range in the OWL 2 Specification.
A facet restriction is used to restrict a particular datatype.
Represents a Literal in the OWL 2 Specification.
Represents a quantified data restriction.
Represents Data Property Cardinality Restrictions in the OWL 2 specification.
Represents DataAllValuesFrom class expressions in the OWL 2 Specification.
Represents DataComplementOf in the OWL 2 Specification.
Represents DataExactCardinality restrictions in the OWL 2 Specification.
Represents DataHasValue restrictions in the OWL 2 Specification.
Represents DataMaxCardinality restrictions in the OWL 2 Specification.
Represents DataMinCardinality restrictions in the OWL 2 Specification.
Represents DataOneOf in the OWL 2 Specification.
Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
OWLNaryDataRange.
Represents a DataUnionOf data range in the OWL 2 Specification.
Represents DataIntersectionOf in the OWL 2 Specification.
Represents an import statement in an ontology.
Represents an AnnotationProperty in the OWL 2 specification.
Attributes
-class owlapy.model.OWLNaryBooleanClassExpression(operands: Iterable[OWLClassExpression])[source]
-Bases: OWLBooleanClassExpression, owlapy.has.HasOperands[OWLClassExpression]
+class owlapy.model.OWLNaryBooleanClassExpression(operands: Iterable[OWLClassExpression])[source]
+Bases: OWLBooleanClassExpression, owlapy.has.HasOperands[OWLClassExpression]
OWLNaryBooleanClassExpression.
-
@@ -1331,7 +1370,7 @@
Attributes
-
-operands() Iterable[OWLClassExpression][source]
+operands() Iterable[OWLClassExpression][source]
Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
classes axiom.
@@ -1406,7 +1445,7 @@ Attributes
-
-abstract get_nnf() OWLClassExpression[source]
+abstract get_nnf() OWLClassExpression[source]
Gets the negation normal form of the complement of this expression.
- Returns:
@@ -1419,8 +1458,8 @@ Attributes
-
-class owlapy.model.OWLObjectComplementOf(op: OWLClassExpression)[source]
-Bases: OWLBooleanClassExpression, owlapy.has.HasOperands[OWLClassExpression]
+class owlapy.model.OWLObjectComplementOf(op: OWLClassExpression)[source]
+Bases: OWLBooleanClassExpression, owlapy.has.HasOperands[OWLClassExpression]
Represents an ObjectComplementOf class expression in the OWL 2 Specification.
-
@@ -1434,7 +1473,7 @@
Attributes
-
-get_operand() OWLClassExpression[source]
+get_operand() OWLClassExpression[source]
- Returns:
The wrapped expression.
@@ -1444,7 +1483,7 @@ Attributes
-
-operands() Iterable[OWLClassExpression][source]
+operands() Iterable[OWLClassExpression][source]
Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
classes axiom.
@@ -1477,7 +1516,7 @@ Attributes
-
class owlapy.model.OWLAnonymousClassExpression[source]
-Bases: OWLClassExpression
+Bases: OWLClassExpression
A Class Expression which is not a named Class.
-
@@ -1514,7 +1553,7 @@
Attributes
-
-get_nnf() OWLClassExpression[source]
+get_nnf() OWLClassExpression[source]
Gets the negation normal form of the complement of this expression.
- Returns:
@@ -1554,7 +1593,7 @@ Attributes
-
class owlapy.model.OWLClass(iri: IRI)[source]
-Bases: OWLClassExpression, owlapy.owlobject.OWLEntity
+Bases: OWLClassExpression, owlapy.owlobject.OWLEntity
An OWL 2 named Class
-
@@ -1623,7 +1662,7 @@
Attributes
-
-get_nnf() OWLClass[source]
+get_nnf() OWLClass[source]
Gets the negation normal form of the complement of this expression.
- Returns:
@@ -1636,7 +1675,7 @@ Attributes
-
-class owlapy.model.OWLObjectUnionOf(operands: Iterable[OWLClassExpression])[source]
+class owlapy.model.OWLObjectUnionOf(operands: Iterable[OWLClassExpression])[source]
Bases: OWLNaryBooleanClassExpression
Represents an ObjectUnionOf class expression in the OWL 2 Specification.
@@ -1653,7 +1692,7 @@ Attributes
-
-class owlapy.model.OWLObjectIntersectionOf(operands: Iterable[OWLClassExpression])[source]
+class owlapy.model.OWLObjectIntersectionOf(operands: Iterable[OWLClassExpression])[source]
Bases: OWLNaryBooleanClassExpression
Represents an OWLObjectIntersectionOf class expression in the OWL 2 Specification.
@@ -1671,7 +1710,7 @@ Attributes
-
class owlapy.model.OWLObjectPropertyExpression[source]
-Bases: OWLPropertyExpression
+Bases: OWLPropertyExpression
A high level interface to describe different types of object properties.
-
@@ -1680,7 +1719,7 @@
Attributes
-
-abstract get_inverse_property() OWLObjectPropertyExpression[source]
+abstract get_inverse_property() OWLObjectPropertyExpression[source]
Obtains the property that corresponds to the inverse of this property.
- Returns:
@@ -1715,7 +1754,7 @@ Attributes
-
class owlapy.model.OWLProperty[source]
-Bases: OWLPropertyExpression, owlapy.owlobject.OWLEntity
+Bases: OWLPropertyExpression, owlapy.owlobject.OWLEntity
A marker interface for properties that aren’t expression i.e. named properties. By definition, properties
are either data properties or object properties.
@@ -1788,7 +1827,7 @@ Attributes
-
class owlapy.model.OWLDataPropertyExpression[source]
-Bases: OWLPropertyExpression
+Bases: OWLPropertyExpression
A high level interface to describe different types of data properties.
-
@@ -1810,7 +1849,7 @@
Attributes
-
class owlapy.model.OWLDataProperty(iri: owlapy.iri.IRI)[source]
-Bases: OWLDataPropertyExpression, OWLProperty
+Bases: OWLDataPropertyExpression, OWLProperty
Represents a Data Property in the OWL 2 Specification.
-
@@ -1852,7 +1891,7 @@
Attributes
-
class owlapy.model.OWLObjectProperty(iri: owlapy.iri.IRI | str)[source]
-Bases: OWLObjectPropertyExpression, OWLProperty
+Bases: OWLObjectPropertyExpression, OWLProperty
Represents an Object Property in the OWL 2 Specification.
-
@@ -2385,14 +2424,47 @@
Attributes
--
-owlapy.model.Literals
+
+-
+class owlapy.model.OWLNamedIndividual(iri: owlapy.iri.IRI | str)[source]
+Bases: OWLIndividual, owlapy.owlobject.OWLEntity
+Represents a Named Individual in the OWL 2 Specification.
+
+-
+property iri
+
+
+
+-
+property str
+
+
+
+-
+__slots__ = '_iri'
+
+
+
+-
+type_index: Final = 1005
+
+-
+get_iri() owlapy.iri.IRI[source]
+Gets the IRI of this object.
+
+- Returns:
+The IRI of this object.
+
+
+
+
+
Bases: owlapy.owlobject.OWLObject
Represents a named or anonymous individual.
@@ -2403,79 +2475,180 @@ Attributes
--
-class owlapy.model.OWLObjectHasValue(property: owlapy.owl_property.OWLObjectPropertyExpression, individual: OWLIndividual)[source]
-Bases: owlapy.owl_restriction.OWLHasValueRestriction[OWLIndividual], owlapy.owl_restriction.OWLObjectRestriction
-Represents an ObjectHasValue class expression in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataPropertyExpression[source]
+Bases: OWLPropertyExpression
+A high level interface to describe different types of data properties.
+
+
+
+
+
+-
+class owlapy.model.OWLObjectPropertyExpression[source]
+Bases: OWLPropertyExpression
+A high level interface to describe different types of object properties.
--
-get_property() owlapy.owl_property.OWLObjectPropertyExpression[source]
-
+-
+abstract get_inverse_property() OWLObjectPropertyExpression[source]
+Obtains the property that corresponds to the inverse of this property.
+
- Returns:
-Property being restricted.
+The inverse of this property. Note that this property will not necessarily be in the simplest form.
--
-as_some_values_from() owlapy.owl_class_expression.OWLClassExpression[source]
-A convenience method that obtains this restriction as an existential restriction with a nominal filler.
+-
+abstract get_named_property() OWLObjectProperty[source]
+Get the named object property used in this property expression.
- Returns:
-The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+P if this expression is either inv(P) or P.
--
-class owlapy.model.OWLObjectOneOf(values: OWLIndividual | Iterable[OWLIndividual])[source]
-Bases: owlapy.owl_class_expression.OWLAnonymousClassExpression, owlapy.has.HasOperands[OWLIndividual]
-Represents an ObjectOneOf class expression in the OWL 2 Specification.
+-
+class owlapy.model.OWLObject
+Base interface for OWL objects
-
--
-type_index: Final = 3004
-
+
--
-individuals() Iterable[OWLIndividual][source]
-Gets the individuals that are in the oneOf. These individuals represent the exact instances (extension)
-of this class expression.
+-
+abstract __hash__()[source]
+Return hash(self).
+
+
+
+
+
+
+
+
+
+-
+class owlapy.model.OWLEntity[source]
+Bases: OWLNamedObject
+Represents Entities in the OWL 2 Specification.
+
+-
+__slots__ = ()
+
+
+
+
+
+
+
+
+
+-
+class owlapy.model.OWLDatatype(iri: owlapy.iri.IRI | owlapy.has.HasIRI)[source]
+Bases: owlapy.owlobject.OWLEntity, owlapy.ranges.OWLDataRange
+Represents a Datatype (named data range) in the OWL 2 Specification.
+
+-
+__slots__ = '_iri'
+
+
+
+-
+type_index: Final = 4001
+
+
+
+-
+get_iri() owlapy.iri.IRI[source]
+Gets the IRI of this object.
- Returns:
-The individuals that are the values of this {@code ObjectOneOf} class expression.
+The IRI of this object.
+
+
+
+-
+class owlapy.model.OWLDataRange[source]
+Bases: OWLPropertyRange
+Represents a DataRange in the OWL 2 Specification.
+
+
+
+-
+class owlapy.model.HasOperands[source]
+Bases: Generic[_T]
+An interface to objects that have a collection of operands.
+
+- Parameters:
+_T – Operand type.
+
+
+-
+__slots__ = ()
+
+
--
-operands() Iterable[OWLIndividual][source]
+-
+abstract operands() Iterable[_T][source]
Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
classes axiom.
@@ -2485,66 +2658,153 @@ Attributes
+-
+class owlapy.model.OWLPropertyExpression[source]
+Bases: owlapy.owlobject.OWLObject
+Represents a property or possibly the inverse of a property.
+
+-
+__slots__ = ()
+
+
--
-as_object_union_of() owlapy.owl_class_expression.OWLClassExpression[source]
-Simplifies this enumeration to a union of singleton nominals.
+-
+is_data_property_expression() bool[source]
+
+- Returns:
+True if this is a data property.
+
+
+
+
+-
+is_object_property_expression() bool[source]
+
+- Returns:
+True if this is an object property.
+
+
+
+
+
+
+-
+class owlapy.model.OWLClassExpression[source]
+Bases: owlapy.ranges.OWLPropertyRange
+An OWL 2 Class Expression.
+
+-
+__slots__ = ()
+
+
--
-__eq__(other)[source]
-Return self==value.
+-
+abstract is_owl_thing() bool[source]
+Determines if this expression is the built in class owl:Thing. This method does not determine if the class
+is equivalent to owl:Thing.
+
+- Returns:
+Thing.
+- Return type:
+True if this expression is owl
+
--
-__repr__()[source]
-Return repr(self).
+-
+abstract is_owl_nothing() bool[source]
+Determines if this expression is the built in class owl:Nothing. This method does not determine if the class
+is equivalent to owl:Nothing.
+
+
+
+-
+abstract get_object_complement_of() OWLObjectComplementOf[source]
+Gets the object complement of this class expression.
+
+- Returns:
+A class expression that is the complement of this class expression.
+
+
+
+
+-
+abstract get_nnf() OWLClassExpression[source]
+Gets the negation normal form of the complement of this expression.
+
+- Returns:
+A expression that represents the NNF of the complement of this expression.
+
--
-class owlapy.model.OWLNamedIndividual(iri: owlapy.iri.IRI | str)[source]
-Bases: OWLIndividual, owlapy.owlobject.OWLEntity
-Represents a Named Individual in the OWL 2 Specification.
+-
+class owlapy.model.OWLClass(iri: IRI)[source]
+Bases: OWLClassExpression, owlapy.owlobject.OWLEntity
+An OWL 2 named Class
--
-property str
-
+-
+property reminder: str
+The reminder of the IRI
+
--
-get_iri() owlapy.iri.IRI[source]
+-
+get_iri() IRI[source]
Gets the IRI of this object.
- Returns:
@@ -2553,78 +2813,67 @@ Attributes
--
-class owlapy.model.OWLOntologyID(ontology_iri: owlapy.iri.IRI | None = None, version_iri: owlapy.iri.IRI | None = None)[source]
-An object that identifies an ontology. Since OWL 2, ontologies do not have to have an ontology IRI, or if they
-have an ontology IRI then they can optionally also have a version IRI. Instances of this OWLOntologyID class bundle
-identifying information of an ontology together. If an ontology doesn’t have an ontology IRI then we say that it is
-“anonymous”.
-
--
-__slots__ = ('_ontology_iri', '_version_iri')
-
-
--
-get_ontology_iri() owlapy.iri.IRI | None[source]
-Gets the ontology IRI.
+-
+is_owl_thing() bool[source]
+Determines if this expression is the built in class owl:Thing. This method does not determine if the class
+is equivalent to owl:Thing.
- Returns:
-Ontology IRI. If the ontology is anonymous, it will return None.
+Thing.
+- Return type:
+True if this expression is owl
--
-get_version_iri() owlapy.iri.IRI | None[source]
-Gets the version IRI.
+-
+is_owl_nothing() bool[source]
+Determines if this expression is the built in class owl:Nothing. This method does not determine if the class
+is equivalent to owl:Nothing.
+
+
+
+-
+get_object_complement_of() OWLObjectComplementOf[source]
+Gets the object complement of this class expression.
- Returns:
-Version IRI or None.
+A class expression that is the complement of this class expression.
--
-get_default_document_iri() owlapy.iri.IRI | None[source]
-Gets the IRI which is used as a default for the document that contain a representation of an ontology with
-this ID. This will be the version IRI if there is an ontology IRI and version IRI, else it will be the ontology
-IRI if there is an ontology IRI but no version IRI, else it will be None if there is no ontology IRI. See
-Ontology Documents in the OWL 2 Structural Specification.
+-
+get_nnf() OWLClass[source]
+Gets the negation normal form of the complement of this expression.
- Returns:
-the IRI that can be used as a default for an ontology document, or None.
+A expression that represents the NNF of the complement of this expression.
-
-
-
-
+
+-
+class owlapy.model.OWLIndividual[source]
+Bases: owlapy.owlobject.OWLObject
+Represents a named or anonymous individual.
+
+-
+__slots__ = ()
+
-
-class owlapy.model.OWLAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
Bases: owlapy.owlobject.OWLObject
Represents Axioms in the OWL 2 Specification.
An OWL ontology contains a set of axioms. These axioms can be annotation axioms, declaration axioms, imports axioms
@@ -2636,1466 +2885,1625 @@
Attributes
-
-annotations() List[OWLAnnotation] | None[source]
+annotations() List[OWLAnnotation] | None[source]
--
-class owlapy.model.OWLDatatype(iri: owlapy.iri.IRI | owlapy.has.HasIRI)[source]
-Bases: owlapy.owlobject.OWLEntity, owlapy.owl_class_expression.OWLDataRange
-Represents a Datatype (named data range) in the OWL 2 Specification.
-
--
-__slots__ = '_iri'
-
-
+-
+class owlapy.model.OWLLogicalAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLAxiom
+A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
+(including imports declarations) and annotation axioms.
--
-get_iri() owlapy.iri.IRI[source]
-Gets the IRI of this object.
-
-- Returns:
-The IRI of this object.
-
-
+-
+is_logical_axiom() bool[source]
+
--
-class owlapy.model.OWLDatatypeRestriction(type_: OWLDatatype, facet_restrictions: OWLFacetRestriction | Iterable[OWLFacetRestriction])[source]
-Bases: owlapy.owl_class_expression.OWLDataRange
-Represents a DatatypeRestriction data range in the OWL 2 Specification.
+-
+class owlapy.model.OWLPropertyAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLLogicalAxiom
+The base interface for property axioms.
+
+
+
+-
+class owlapy.model.OWLObjectPropertyAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLPropertyAxiom
+The base interface for object property axioms.
-
--
-get_datatype() OWLDatatype[source]
+
+
+
+-
+class owlapy.model.OWLDataPropertyAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLPropertyAxiom
+The base interface for data property axioms.
+
+-
+__slots__ = ()
+
+
+
+
+
+-
+class owlapy.model.OWLIndividualAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLLogicalAxiom
+The base interface for individual axioms.
+
+-
+__slots__ = ()
+
+
+
+
+
+-
+class owlapy.model.OWLClassAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLLogicalAxiom
+The base interface for class axioms.
+
+-
+__slots__ = ()
+
+
+
+
+
+-
+class owlapy.model.OWLDeclarationAxiom(entity: owlapy.owlobject.OWLEntity, annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLAxiom
+Represents a Declaration axiom in the OWL 2 Specification. A declaration axiom declares an entity in an ontology.
+It doesn’t affect the logical meaning of the ontology.
+
+-
+__slots__ = '_entity'
--
-get_facet_restrictions() Sequence[OWLFacetRestriction][source]
+-
+get_entity() owlapy.owlobject.OWLEntity[source]
--
-class owlapy.model.OWLFacetRestriction(facet: owlapy.vocab.OWLFacet, literal: Literals)[source]
-Bases: owlapy.owlobject.OWLObject
-A facet restriction is used to restrict a particular datatype.
-
--
-__slots__ = ('_facet', '_literal')
-
-
+-
+class owlapy.model.OWLDatatypeDefinitionAxiom(datatype: owlapy.types.OWLDatatype, datarange: owlapy.types.OWLDataRange, annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLLogicalAxiom
+Represents a DatatypeDefinition axiom in the OWL 2 Specification.
--
-get_facet() owlapy.vocab.OWLFacet[source]
+-
+get_datatype() owlapy.types.OWLDatatype[source]
--
-get_facet_value() OWLLiteral[source]
+-
+get_datarange() owlapy.types.OWLDataRange[source]
--
-class owlapy.model.OWLLiteral[source]
-Bases: owlapy.owl_annotation.OWLAnnotationValue
-Represents a Literal in the OWL 2 Specification.
+-
+class owlapy.model.OWLHasKeyAxiom(class_expression: owlapy.owl_class_expression.OWLClassExpression, property_expressions: List[owlapy.owl_property.OWLPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLLogicalAxiom, owlapy.has.HasOperands[owlapy.owl_property.OWLPropertyExpression]
+Represents a HasKey axiom in the OWL 2 Specification.
-
--
-type_index: Final = 4008
+
+-
+get_class_expression() owlapy.owl_class_expression.OWLClassExpression[source]
--
-get_literal() str[source]
-Gets the lexical value of this literal. Note that the language tag is not included.
+-
+get_property_expressions() List[owlapy.owl_property.OWLPropertyExpression][source]
+
+
+
+-
+operands() Iterable[owlapy.owl_property.OWLPropertyExpression][source]
+Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+classes axiom.
- Returns:
-The lexical value of this literal.
+The operands.
--
-is_boolean() bool[source]
-Whether this literal is typed as boolean.
+-
+__eq__(other)[source]
+Return self==value.
--
-parse_boolean() bool[source]
-Parses the lexical value of this literal into a bool. The lexical value of this literal should be in the
-lexical space of the boolean datatype (”http://www.w3.org/2001/XMLSchema#boolean”).
-
-- Returns:
-A bool value that is represented by this literal.
-
+-
+__hash__()[source]
+Return hash(self).
--
-is_double() bool[source]
-Whether this literal is typed as double.
+-
+__repr__()[source]
+Return repr(self).
-
--
-parse_double() float[source]
-Parses the lexical value of this literal into a double. The lexical value of this literal should be in the
-lexical space of the double datatype (”http://www.w3.org/2001/XMLSchema#double”).
+
+
+
+-
+class owlapy.model.OWLNaryAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: Generic[_C], OWLAxiom
+Represents an axiom that contains two or more operands that could also be represented with multiple pairwise
+axioms.
-- Returns:
-A double value that is represented by this literal.
+- Parameters:
+_C – Class of contained objects.
-
+
+-
+__slots__ = ()
+
--
-is_integer() bool[source]
-Whether this literal is typed as integer.
+-
+abstract as_pairwise_axioms() Iterable[OWLNaryAxiom[_C]][source]
+
+
+
+-
+class owlapy.model.OWLNaryClassAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLClassAxiom, OWLNaryAxiom[owlapy.owl_class_expression.OWLClassExpression]
+Represents an axiom that contains two or more operands that could also be represented with
+multiple pairwise axioms.
+
+-
+__slots__ = '_class_expressions'
+
+
--
-parse_integer() int[source]
-Parses the lexical value of this literal into an integer. The lexical value of this literal should be in the
-lexical space of the integer datatype (”http://www.w3.org/2001/XMLSchema#integer”).
+-
+class_expressions() Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+Gets all of the top level class expressions that appear in this axiom.
- Returns:
-An integer value that is represented by this literal.
+Sorted stream of class expressions that appear in the axiom.
-
-
--
-parse_string() str[source]
-Parses the lexical value of this literal into a string. The lexical value of this literal should be in the
-lexical space of the string datatype (”http://www.w3.org/2001/XMLSchema#string”).
+-
+as_pairwise_axioms() Iterable[OWLNaryClassAxiom][source]
+Gets this axiom as a set of pairwise axioms; if the axiom contains only two operands,
+the axiom itself is returned unchanged, including its annotations.
- Returns:
-A string value that is represented by this literal.
+This axiom as a set of pairwise axioms.
--
-is_date() bool[source]
-Whether this literal is typed as date.
+-
+__eq__(other)[source]
+Return self==value.
--
-parse_date() datetime.date[source]
-Parses the lexical value of this literal into a date. The lexical value of this literal should be in the
-lexical space of the date datatype (”http://www.w3.org/2001/XMLSchema#date”).
-
-- Returns:
-A date value that is represented by this literal.
-
+-
+__hash__()[source]
+Return hash(self).
--
-is_datetime() bool[source]
-Whether this literal is typed as dateTime.
+-
+__repr__()[source]
+Return repr(self).
-
--
-parse_datetime() datetime.datetime[source]
-Parses the lexical value of this literal into a datetime. The lexical value of this literal should be in the
-lexical space of the dateTime datatype (”http://www.w3.org/2001/XMLSchema#dateTime”).
-
-- Returns:
-A datetime value that is represented by this literal.
-
+
+-
+class owlapy.model.OWLEquivalentClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryClassAxiom
+Represents an EquivalentClasses axiom in the OWL 2 Specification.
+
+-
+__slots__ = ()
+
+
-
-
--
-parse_duration() pandas.Timedelta[source]
-Parses the lexical value of this literal into a Timedelta. The lexical value of this literal should be in the
-lexical space of the duration datatype (”http://www.w3.org/2001/XMLSchema#duration”).
-
-- Returns:
-A Timedelta value that is represented by this literal.
-
-
-
-
+-
+contains_named_equivalent_class() bool[source]
+
--
-as_literal() OWLLiteral[source]
-
-- Returns:
-if the value is a literal, returns it. Return None otherwise
-
-
+-
+contains_owl_nothing() bool[source]
+
--
-abstract get_datatype() OWLDatatype[source]
-Gets the OWLDatatype which types this literal.
-
-- Returns:
-The OWLDatatype that types this literal.
-
-
+-
+named_classes() Iterable[owlapy.owl_class_expression.OWLClass][source]
+
--
-class owlapy.model.OWLQuantifiedDataRestriction(filler: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: owlapy.owl_restriction.OWLQuantifiedRestriction[owlapy.owl_class_expression.OWLDataRange], owlapy.owl_restriction.OWLDataRestriction
-Represents a quantified data restriction.
+-
+class owlapy.model.OWLDisjointClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryClassAxiom
+Represents a DisjointClasses axiom in the OWL 2 Specification.
-
--
-get_filler() owlapy.owl_class_expression.OWLDataRange[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.model.OWLDataCardinalityRestriction(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: owlapy.owl_restriction.OWLCardinalityRestriction[owlapy.owl_class_expression.OWLDataRange], OWLQuantifiedDataRestriction, owlapy.owl_restriction.OWLDataRestriction
-Represents Data Property Cardinality Restrictions in the OWL 2 specification.
+-
+class owlapy.model.OWLNaryIndividualAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLIndividualAxiom, OWLNaryAxiom[owlapy.owl_individual.OWLIndividual]
+Represents an axiom that contains two or more operands that could also be represented with
+multiple pairwise individual axioms.
--
-get_property() owlapy.owl_property.OWLDataPropertyExpression[source]
-
+-
+individuals() Iterable[owlapy.owl_individual.OWLIndividual][source]
+Get the individuals.
+
- Returns:
-Property being restricted.
+Generator containing the individuals.
+-
+as_pairwise_axioms() Iterable[OWLNaryIndividualAxiom][source]
+
-
-
-
--
-class owlapy.model.OWLDataAllValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: OWLQuantifiedDataRestriction
-Represents DataAllValuesFrom class expressions in the OWL 2 Specification.
-
--
-__slots__ = '_property'
-
-
-
--
-type_index: Final = 3013
-
-
-
-
+
+-
+class owlapy.model.OWLDifferentIndividualsAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryIndividualAxiom
+Represents a DifferentIndividuals axiom in the OWL 2 Specification.
+
+-
+__slots__ = ()
+
-
--
-get_property() owlapy.owl_property.OWLDataPropertyExpression[source]
-
-- Returns:
-Property being restricted.
-
+
+-
+class owlapy.model.OWLSameIndividualAxiom(individuals: List[owlapy.owl_individual.OWLIndividual], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryIndividualAxiom
+Represents a SameIndividual axiom in the OWL 2 Specification.
+
+-
+__slots__ = ()
+
+
--
-class owlapy.model.OWLDataComplementOf(data_range: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: owlapy.owl_class_expression.OWLDataRange
-Represents DataComplementOf in the OWL 2 Specification.
+-
+class owlapy.model.OWLNaryPropertyAxiom(properties: List[_P], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: Generic[_P], OWLPropertyAxiom, OWLNaryAxiom[_P]
+Represents an axiom that contains two or more operands that could also be represented with
+multiple pairwise property axioms.
+
+
--
-class owlapy.model.OWLDataExactCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: OWLDataCardinalityRestriction
-Represents DataExactCardinality restrictions in the OWL 2 Specification.
+-
+class owlapy.model.OWLEquivalentObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
+Represents EquivalentObjectProperties axioms in the OWL 2 Specification.
+
+
+
+-
+class owlapy.model.OWLDisjointObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
+Represents DisjointObjectProperties axioms in the OWL 2 Specification.
-
--
-as_intersection_of_min_max() owlapy.owl_class_expression.OWLObjectIntersectionOf[source]
-Obtains an equivalent form that is a conjunction of a min cardinality and max cardinality restriction.
-
-- Returns:
-The semantically equivalent but structurally simpler form (= 1 R D) = >= 1 R D and <= 1 R D.
-
-
-
--
-class owlapy.model.OWLDataHasValue(property: owlapy.owl_property.OWLDataPropertyExpression, value: OWLLiteral)[source]
-Bases: owlapy.owl_restriction.OWLHasValueRestriction[OWLLiteral], owlapy.owl_restriction.OWLDataRestriction
-Represents DataHasValue restrictions in the OWL 2 Specification.
+-
+class owlapy.model.OWLInverseObjectPropertiesAxiom(first: owlapy.owl_property.OWLObjectPropertyExpression, second: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
+Represents InverseObjectProperties axioms in the OWL 2 Specification.
-
--
-type_index: Final = 3014
+
+-
+get_first_property() owlapy.owl_property.OWLObjectPropertyExpression[source]
--
-__repr__()[source]
+-
+get_second_property() owlapy.owl_property.OWLObjectPropertyExpression[source]
+
+
+
-
-
-
-
-
--
-as_some_values_from() owlapy.owl_class_expression.OWLClassExpression[source]
-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}).
-
-
-
-
--
-get_property() owlapy.owl_property.OWLDataPropertyExpression[source]
-
-- Returns:
-Property being restricted.
-
+
+-
+class owlapy.model.OWLEquivalentDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLDataPropertyExpression], OWLDataPropertyAxiom
+Represents EquivalentDataProperties axioms in the OWL 2 Specification.
+
+-
+__slots__ = ()
+
+
--
-class owlapy.model.OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: OWLDataCardinalityRestriction
-Represents DataMaxCardinality restrictions in the OWL 2 Specification.
-
--
-__slots__ = ('_cardinality', '_filler', '_property')
-
-
+-
+class owlapy.model.OWLDisjointDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLDataPropertyExpression], OWLDataPropertyAxiom
+Represents DisjointDataProperties axioms in the OWL 2 Specification.
--
-class owlapy.model.OWLDataMinCardinality(cardinality: int, property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: OWLDataCardinalityRestriction
-Represents DataMinCardinality restrictions in the OWL 2 Specification.
-
--
-__slots__ = ('_cardinality', '_filler', '_property')
-
-
+-
+class owlapy.model.OWLSubClassOfAxiom(sub_class: owlapy.owl_class_expression.OWLClassExpression, super_class: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLClassAxiom
+Represents an SubClassOf axiom in the OWL 2 Specification.
-
-
-
--
-class owlapy.model.OWLDataOneOf(values: OWLLiteral | Iterable[OWLLiteral])[source]
-Bases: owlapy.owl_class_expression.OWLDataRange, owlapy.has.HasOperands[OWLLiteral]
-Represents DataOneOf in the OWL 2 Specification.
-
--
-type_index: Final = 4003
+
+-
+get_sub_class() owlapy.owl_class_expression.OWLClassExpression[source]
--
-values() Iterable[OWLLiteral][source]
-Gets the values that are in the oneOf.
-
-- Returns:
-The values of this {@code DataOneOf} class expression.
-
-
+-
+get_super_class() owlapy.owl_class_expression.OWLClassExpression[source]
+
--
-operands() Iterable[OWLLiteral][source]
-Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
-classes axiom.
-
-- Returns:
-The operands.
-
+-
+__eq__(other)[source]
+Return self==value.
-
-
--
-class owlapy.model.OWLDataSomeValuesFrom(property: owlapy.owl_property.OWLDataPropertyExpression, filler: owlapy.owl_class_expression.OWLDataRange)[source]
-Bases: OWLQuantifiedDataRestriction
-Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
+-
+class owlapy.model.OWLDisjointUnionAxiom(cls_: owlapy.owl_class_expression.OWLClass, class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLClassAxiom
+Represents a DisjointUnion axiom in the OWL 2 Specification.
-
--
-type_index: Final = 3012
+
+-
+get_owl_class() owlapy.owl_class_expression.OWLClass[source]
+-
+get_class_expressions() Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+
--
-__eq__(other)[source]
+-
+get_owl_equivalent_classes_axiom() OWLEquivalentClassesAxiom[source]
+
+
+
+-
+get_owl_disjoint_classes_axiom() OWLDisjointClassesAxiom[source]
+
+
+
--
-get_property() owlapy.owl_property.OWLDataPropertyExpression[source]
-
-- Returns:
-Property being restricted.
-
+-
+__repr__()[source]
+Return repr(self).
--
-class owlapy.model.OWLNaryDataRange(operands: Iterable[owlapy.owl_class_expression.OWLDataRange])[source]
-Bases: owlapy.owl_class_expression.OWLDataRange, owlapy.has.HasOperands[owlapy.owl_class_expression.OWLDataRange]
-OWLNaryDataRange.
+-
+class owlapy.model.OWLClassAssertionAxiom(individual: owlapy.owl_individual.OWLIndividual, class_expression: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLIndividualAxiom
+Represents ClassAssertion axioms in the OWL 2 Specification.
+-
+get_individual() owlapy.owl_individual.OWLIndividual[source]
+
+-
+get_class_expression() owlapy.owl_class_expression.OWLClassExpression[source]
+
+
+
--
-class owlapy.model.OWLDataUnionOf(operands: Iterable[owlapy.owl_class_expression.OWLDataRange])[source]
-Bases: OWLNaryDataRange
-Represents a DataUnionOf data range in the OWL 2 Specification.
+-
+class owlapy.model.OWLAnnotationAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
+Bases: OWLAxiom
+A super interface for annotation axioms.
-
+
+-
+owlapy.model.Literals
+
+
--
-class owlapy.model.OWLDataIntersectionOf(operands: Iterable[owlapy.owl_class_expression.OWLDataRange])[source]
-Bases: OWLNaryDataRange
-Represents DataIntersectionOf in the OWL 2 Specification.
+-
+class owlapy.model.OWLObjectHasValue(property: owlapy.owl_axiom.OWLObjectPropertyExpression, individual: owlapy.owl_axiom.OWLIndividual)[source]
+Bases: owlapy.owl_restriction.OWLHasValueRestriction[owlapy.owl_axiom.OWLIndividual], owlapy.owl_restriction.OWLObjectRestriction
+Represents an ObjectHasValue class expression in the OWL 2 Specification.
+
+-
+get_property() owlapy.owl_axiom.OWLObjectPropertyExpression[source]
+
+- Returns:
+Property being restricted.
+
-
--
-class owlapy.model.OWLImportsDeclaration(import_iri: owlapy.iri.IRI)[source]
-Bases: owlapy.has.HasIRI
-Represents an import statement in an ontology.
-
--
-__slots__ = '_iri'
-
-
--
-get_iri() owlapy.iri.IRI[source]
-Gets the import IRI.
+-
+as_some_values_from() owlapy.owl_axiom.OWLClassExpression[source]
+A convenience method that obtains this restriction as an existential restriction with a nominal filler.
- Returns:
-The import IRI that points to the ontology to be imported. The imported ontology might have this IRI as
-its ontology IRI but this is not mandated. For example, an ontology with a non-resolvable ontology IRI
-can be deployed at a resolvable URL.
+The existential equivalent of this value restriction. simp(HasValue(p a)) = some(p {a}).
+
+
--
-class owlapy.model.OWLLogicalAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLAxiom
-A base interface of all axioms that affect the logical meaning of an ontology. This excludes declaration axioms
-(including imports declarations) and annotation axioms.
+-
+class owlapy.model.OWLObjectOneOf(values: owlapy.owl_axiom.OWLIndividual | owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLIndividual])[source]
+Bases: owlapy.owl_class_expression.OWLAnonymousClassExpression, owlapy.owl_axiom.HasOperands[owlapy.owl_axiom.OWLIndividual]
+Represents an ObjectOneOf class expression in the OWL 2 Specification.
-
-
-
--
-class owlapy.model.OWLPropertyAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLLogicalAxiom
-The base interface for property axioms.
-
--
-__slots__ = ()
-
+
+-
+individuals() owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLIndividual][source]
+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.
+
+
+
+-
+operands() owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLIndividual][source]
+Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+classes axiom.
+
+- Returns:
+The operands.
+
-
--
-class owlapy.model.OWLObjectPropertyAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyAxiom
-The base interface for object property axioms.
-
--
-__slots__ = ()
-
+
+-
+as_object_union_of() owlapy.owl_axiom.OWLClassExpression[source]
+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})
+
+
+
-
--
-class owlapy.model.OWLDataPropertyAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyAxiom
-The base interface for data property axioms.
-
--
-__slots__ = ()
-
+
+
+
--
-class owlapy.model.OWLIndividualAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLLogicalAxiom
-The base interface for individual axioms.
+-
+class owlapy.model.OWLOntologyID(ontology_iri: owlapy.owl_axiom.Optional[owlapy.iri.IRI] = None, version_iri: owlapy.owl_axiom.Optional[owlapy.iri.IRI] = None)[source]
+An object that identifies an ontology. Since OWL 2, ontologies do not have to have an ontology IRI, or if they
+have an ontology IRI then they can optionally also have a version IRI. Instances of this OWLOntologyID class bundle
+identifying information of an ontology together. If an ontology doesn’t have an ontology IRI then we say that it is
+“anonymous”.
+
+-
+get_ontology_iri() owlapy.owl_axiom.Optional[owlapy.iri.IRI][source]
+Gets the ontology IRI.
+
+- Returns:
+Ontology IRI. If the ontology is anonymous, it will return None.
+
-
--
-class owlapy.model.OWLClassAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLLogicalAxiom
-The base interface for class axioms.
-
--
-__slots__ = ()
+
+-
+get_version_iri() owlapy.owl_axiom.Optional[owlapy.iri.IRI][source]
+Gets the version IRI.
+
+- Returns:
+Version IRI or None.
+
+
+
+
+-
+get_default_document_iri() owlapy.owl_axiom.Optional[owlapy.iri.IRI][source]
+Gets the IRI which is used as a default for the document that contain a representation of an ontology with
+this ID. This will be the version IRI if there is an ontology IRI and version IRI, else it will be the ontology
+IRI if there is an ontology IRI but no version IRI, else it will be None if there is no ontology IRI. See
+Ontology Documents in the OWL 2 Structural Specification.
+
+- Returns:
+the IRI that can be used as a default for an ontology document, or None.
+
+
+
+
+
+
+
+
--
-class owlapy.model.OWLDeclarationAxiom(entity: owlapy.owlobject.OWLEntity, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLAxiom
-Represents a Declaration axiom in the OWL 2 Specification. A declaration axiom declares an entity in an ontology.
-It doesn’t affect the logical meaning of the ontology.
+-
+class owlapy.model.OWLDatatypeRestriction(type_: owlapy.owl_axiom.OWLDatatype, facet_restrictions: OWLFacetRestriction | owlapy.owl_axiom.Iterable[OWLFacetRestriction])[source]
+Bases: owlapy.owl_axiom.OWLDataRange
+Represents a DatatypeRestriction data range in the OWL 2 Specification.
+
+
+-
+type_index: Final = 4006
--
-get_entity() owlapy.owlobject.OWLEntity[source]
+-
+get_datatype() owlapy.owl_axiom.OWLDatatype[source]
--
-__eq__(other)[source]
+-
+get_facet_restrictions() Sequence[OWLFacetRestriction][source]
+
+
+
--
-class owlapy.model.OWLDatatypeDefinitionAxiom(datatype: OWLDatatype, datarange: owlapy.owl_class_expression.OWLDataRange, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLLogicalAxiom
-Represents a DatatypeDefinition axiom in the OWL 2 Specification.
+-
+class owlapy.model.OWLFacetRestriction(facet: owlapy.vocab.OWLFacet, literal: Literals)[source]
+Bases: owlapy.owl_axiom.OWLObject
+A facet restriction is used to restrict a particular datatype.
+
+
+-
+type_index: Final = 4007
--
-get_datatype() OWLDatatype[source]
+-
+get_facet() owlapy.vocab.OWLFacet[source]
--
-get_datarange() owlapy.owl_class_expression.OWLDataRange[source]
+-
+get_facet_value() OWLLiteral[source]
--
-class owlapy.model.OWLHasKeyAxiom(class_expression: owlapy.owl_class_expression.OWLClassExpression, property_expressions: List[owlapy.owl_property.OWLPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLLogicalAxiom, owlapy.has.HasOperands[owlapy.owl_property.OWLPropertyExpression]
-Represents a HasKey axiom in the OWL 2 Specification.
+-
+class owlapy.model.OWLLiteral[source]
+Bases: owlapy.owl_annotation.OWLAnnotationValue
+Represents a Literal in the OWL 2 Specification.
-
--
-get_class_expression() owlapy.owl_class_expression.OWLClassExpression[source]
+
+-
+type_index: Final = 4008
--
-get_property_expressions() List[owlapy.owl_property.OWLPropertyExpression][source]
-
+-
+get_literal() str[source]
+Gets the lexical value of this literal. Note that the language tag is not included.
+
+- Returns:
+The lexical value of this literal.
+
+
--
-operands() Iterable[owlapy.owl_property.OWLPropertyExpression][source]
-Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
-classes axiom.
+-
+is_boolean() bool[source]
+Whether this literal is typed as boolean.
+
+
+
+-
+parse_boolean() bool[source]
+Parses the lexical value of this literal into a bool. The lexical value of this literal should be in the
+lexical space of the boolean datatype (”http://www.w3.org/2001/XMLSchema#boolean”).
+
+- Returns:
+A bool value that is represented by this literal.
+
+
+
+
+
+
+-
+parse_double() float[source]
+Parses the lexical value of this literal into a double. The lexical value of this literal should be in the
+lexical space of the double datatype (”http://www.w3.org/2001/XMLSchema#double”).
+
+- Returns:
+A double value that is represented by this literal.
+
+
+
+
+
+
+-
+parse_integer() int[source]
+Parses the lexical value of this literal into an integer. The lexical value of this literal should be in the
+lexical space of the integer datatype (”http://www.w3.org/2001/XMLSchema#integer”).
+
+- Returns:
+An integer value that is represented by this literal.
+
+
+
+
+
+
+-
+parse_string() str[source]
+Parses the lexical value of this literal into a string. The lexical value of this literal should be in the
+lexical space of the string datatype (”http://www.w3.org/2001/XMLSchema#string”).
+
+- Returns:
+A string value that is represented by this literal.
+
+
+
+
+
+
+-
+parse_date() datetime.date[source]
+Parses the lexical value of this literal into a date. The lexical value of this literal should be in the
+lexical space of the date datatype (”http://www.w3.org/2001/XMLSchema#date”).
+
+- Returns:
+A date value that is represented by this literal.
+
+
+
+
+
+
+-
+parse_datetime() datetime.datetime[source]
+Parses the lexical value of this literal into a datetime. The lexical value of this literal should be in the
+lexical space of the dateTime datatype (”http://www.w3.org/2001/XMLSchema#dateTime”).
+
+- Returns:
+A datetime value that is represented by this literal.
+
+
+
+
+
+
+-
+parse_duration() pandas.Timedelta[source]
+Parses the lexical value of this literal into a Timedelta. The lexical value of this literal should be in the
+lexical space of the duration datatype (”http://www.w3.org/2001/XMLSchema#duration”).
- Returns:
-The operands.
+A Timedelta value that is represented by this literal.
--
-__eq__(other)[source]
-Return self==value.
+-
+is_literal() bool[source]
+
+- Returns:
+true if the annotation value is a literal
+
--
-__hash__()[source]
-Return hash(self).
+-
+as_literal() OWLLiteral[source]
+
+- Returns:
+if the value is a literal, returns it. Return None otherwise
+
-
-
+-
+to_python() Literals[source]
+
-
--
-class owlapy.model.OWLNaryAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: Generic[_C], OWLAxiom
-Represents an axiom that contains two or more operands that could also be represented with multiple pairwise
-axioms.
+
+-
+abstract get_datatype() owlapy.owl_axiom.OWLDatatype[source]
+Gets the OWLDatatype which types this literal.
-- Parameters:
-_C – Class of contained objects.
+- Returns:
+The OWLDatatype that types this literal.
-
--
-__slots__ = ()
-
-
-
--
-abstract as_pairwise_axioms() Iterable[OWLNaryAxiom[_C]][source]
-
+
--
-class owlapy.model.OWLNaryClassAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLClassAxiom, OWLNaryAxiom[owlapy.owl_class_expression.OWLClassExpression]
-Represents an axiom that contains two or more operands that could also be represented with
-multiple pairwise axioms.
+-
+class owlapy.model.OWLQuantifiedDataRestriction(filler: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: owlapy.owl_restriction.OWLQuantifiedRestriction[owlapy.owl_axiom.OWLDataRange], owlapy.owl_restriction.OWLDataRestriction
+Represents a quantified data restriction.
--
-class_expressions() Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
-Gets all of the top level class expressions that appear in this axiom.
+-
+get_filler() owlapy.owl_axiom.OWLDataRange[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:
-Sorted stream of class expressions that appear in the axiom.
+the value
+
+
+
+-
+class owlapy.model.OWLDataCardinalityRestriction(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: owlapy.owl_restriction.OWLCardinalityRestriction[owlapy.owl_axiom.OWLDataRange], OWLQuantifiedDataRestriction, owlapy.owl_restriction.OWLDataRestriction
+Represents Data Property Cardinality Restrictions in the OWL 2 specification.
+
+-
+__slots__ = ()
+
+
--
-as_pairwise_axioms() Iterable[OWLNaryClassAxiom][source]
-Gets this axiom as a set of pairwise axioms; if the axiom contains only two operands,
-the axiom itself is returned unchanged, including its annotations.
-
--
-class owlapy.model.OWLEquivalentClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryClassAxiom
-Represents an EquivalentClasses axiom in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataAllValuesFrom(property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: OWLQuantifiedDataRestriction
+Represents DataAllValuesFrom class expressions in the OWL 2 Specification.
-
+-
+__eq__(other)[source]
+Return self==value.
+
--
-named_classes() Iterable[owlapy.owl_class_expression.OWLClass][source]
-
-
+-
+__hash__()[source]
+Return hash(self).
-
--
-class owlapy.model.OWLDisjointClassesAxiom(class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryClassAxiom
-Represents a DisjointClasses axiom in the OWL 2 Specification.
-
--
-__slots__ = ()
-
+
--
-class owlapy.model.OWLNaryIndividualAxiom(individuals: List[OWLIndividual], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLIndividualAxiom, OWLNaryAxiom[OWLIndividual]
-Represents an axiom that contains two or more operands that could also be represented with
-multiple pairwise individual axioms.
+-
+class owlapy.model.OWLDataComplementOf(data_range: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: owlapy.owl_axiom.OWLDataRange
+Represents DataComplementOf in the OWL 2 Specification.
--
-individuals() Iterable[OWLIndividual][source]
-Get the individuals.
-
+-
+get_data_range() owlapy.owl_axiom.OWLDataRange[source]
+
- Returns:
-Generator containing the individuals.
+The wrapped data range.
--
-as_pairwise_axioms() Iterable[OWLNaryIndividualAxiom][source]
-
+-
+__repr__()[source]
+Return repr(self).
+
-
-
--
-class owlapy.model.OWLDifferentIndividualsAxiom(individuals: List[OWLIndividual], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryIndividualAxiom
-Represents a DifferentIndividuals axiom in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataExactCardinality(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: OWLDataCardinalityRestriction
+Represents DataExactCardinality restrictions in the OWL 2 Specification.
-
-
-
--
-class owlapy.model.OWLSameIndividualAxiom(individuals: List[OWLIndividual], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryIndividualAxiom
-Represents a SameIndividual axiom in the OWL 2 Specification.
+
+-
+as_intersection_of_min_max() owlapy.owl_class_expression.OWLObjectIntersectionOf[source]
+Obtains an equivalent form that is a conjunction of a min cardinality and max cardinality restriction.
+
+- Returns:
+The semantically equivalent but structurally simpler form (= 1 R D) = >= 1 R D and <= 1 R D.
+
+
+
--
-class owlapy.model.OWLNaryPropertyAxiom(properties: List[_P], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: Generic[_P], OWLPropertyAxiom, OWLNaryAxiom[_P]
-Represents an axiom that contains two or more operands that could also be represented with
-multiple pairwise property axioms.
+-
+class owlapy.model.OWLDataHasValue(property: owlapy.owl_axiom.OWLDataPropertyExpression, value: OWLLiteral)[source]
+Bases: owlapy.owl_restriction.OWLHasValueRestriction[OWLLiteral], owlapy.owl_restriction.OWLDataRestriction
+Represents DataHasValue restrictions in the OWL 2 Specification.
+
+
+-
+type_index: Final = 3014
--
-properties() Iterable[_P][source]
-Get all the properties that appear in the axiom.
-
-- Returns:
-Generator containing the properties.
-
+-
+__repr__()[source]
+Return repr(self).
--
-as_pairwise_axioms() Iterable[OWLNaryPropertyAxiom][source]
-
+-
+__eq__(other)[source]
+Return self==value.
+
--
-__hash__()[source]
-Return hash(self).
+-
+as_some_values_from() owlapy.owl_axiom.OWLClassExpression[source]
+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}).
+
--
-class owlapy.model.OWLEquivalentObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
-Represents EquivalentObjectProperties axioms in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataMaxCardinality(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: OWLDataCardinalityRestriction
+Represents DataMaxCardinality restrictions in the OWL 2 Specification.
+
+
+-
+type_index: Final = 3017
--
-class owlapy.model.OWLDisjointObjectPropertiesAxiom(properties: List[owlapy.owl_property.OWLObjectPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
-Represents DisjointObjectProperties axioms in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataMinCardinality(cardinality: int, property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: OWLDataCardinalityRestriction
+Represents DataMinCardinality restrictions in the OWL 2 Specification.
+
+
+-
+type_index: Final = 3015
--
-class owlapy.model.OWLInverseObjectPropertiesAxiom(first: owlapy.owl_property.OWLObjectPropertyExpression, second: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
-Represents InverseObjectProperties axioms in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataOneOf(values: OWLLiteral | owlapy.owl_axiom.Iterable[OWLLiteral])[source]
+Bases: owlapy.owl_axiom.OWLDataRange, owlapy.owl_axiom.HasOperands[OWLLiteral]
+Represents DataOneOf in the OWL 2 Specification.
--
-get_first_property() owlapy.owl_property.OWLObjectPropertyExpression[source]
-
+-
+values() owlapy.owl_axiom.Iterable[OWLLiteral][source]
+Gets the values that are in the oneOf.
+
+- Returns:
+The values of this {@code DataOneOf} class expression.
+
+
--
-get_second_property() owlapy.owl_property.OWLObjectPropertyExpression[source]
-
+-
+operands() owlapy.owl_axiom.Iterable[OWLLiteral][source]
+Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+classes axiom.
+
+- Returns:
+The operands.
+
+
+
-
--
-class owlapy.model.OWLEquivalentDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLDataPropertyExpression], OWLDataPropertyAxiom
-Represents EquivalentDataProperties axioms in the OWL 2 Specification.
-
--
-__slots__ = ()
-
-
+
-
--
-class owlapy.model.OWLDisjointDataPropertiesAxiom(properties: List[owlapy.owl_property.OWLDataPropertyExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLNaryPropertyAxiom[owlapy.owl_property.OWLDataPropertyExpression], OWLDataPropertyAxiom
-Represents DisjointDataProperties axioms in the OWL 2 Specification.
-
--
-__slots__ = ()
-
-
--
-class owlapy.model.OWLSubClassOfAxiom(sub_class: owlapy.owl_class_expression.OWLClassExpression, super_class: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLClassAxiom
-Represents an SubClassOf axiom in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataSomeValuesFrom(property: owlapy.owl_axiom.OWLDataPropertyExpression, filler: owlapy.owl_axiom.OWLDataRange)[source]
+Bases: OWLQuantifiedDataRestriction
+Represents a DataSomeValuesFrom restriction in the OWL 2 Specification.
-
--
-get_sub_class() owlapy.owl_class_expression.OWLClassExpression[source]
+
+-
+type_index: Final = 3012
--
-get_super_class() owlapy.owl_class_expression.OWLClassExpression[source]
-
+-
+__repr__()[source]
+Return repr(self).
+
--
-class owlapy.model.OWLDisjointUnionAxiom(cls_: owlapy.owl_class_expression.OWLClass, class_expressions: List[owlapy.owl_class_expression.OWLClassExpression], annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLClassAxiom
-Represents a DisjointUnion axiom in the OWL 2 Specification.
+-
+class owlapy.model.OWLNaryDataRange(operands: owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange])[source]
+Bases: owlapy.owl_axiom.OWLDataRange, owlapy.owl_axiom.HasOperands[owlapy.owl_axiom.OWLDataRange]
+OWLNaryDataRange.
--
-__slots__ = ('_cls', '_class_expressions')
-
-
-
--
-get_owl_class() owlapy.owl_class_expression.OWLClass[source]
-
-
-
--
-get_class_expressions() Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+-
+__slots__ = ()
--
-get_owl_equivalent_classes_axiom() OWLEquivalentClassesAxiom[source]
-
+-
+operands() owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange][source]
+Gets the operands - e.g., the individuals in a sameAs axiom, or the classes in an equivalent
+classes axiom.
+
+- Returns:
+The operands.
+
+
--
-get_owl_disjoint_classes_axiom() OWLDisjointClassesAxiom[source]
-
+-
+__repr__()[source]
+Return repr(self).
+
-
-
--
-class owlapy.model.OWLClassAssertionAxiom(individual: OWLIndividual, class_expression: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLIndividualAxiom
-Represents ClassAssertion axioms in the OWL 2 Specification.
+-
+class owlapy.model.OWLDataUnionOf(operands: owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange])[source]
+Bases: OWLNaryDataRange
+Represents a DataUnionOf data range in the OWL 2 Specification.
--
-__slots__ = ('_individual', '_class_expression')
-
-
-
--
-get_individual() OWLIndividual[source]
+-
+__slots__ = '_operands'
-
--
-get_class_expression() owlapy.owl_class_expression.OWLClassExpression[source]
+
+-
+type_index: Final = 4005
-
-
+
+-
+class owlapy.model.OWLDataIntersectionOf(operands: owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLDataRange])[source]
+Bases: OWLNaryDataRange
+Represents DataIntersectionOf in the OWL 2 Specification.
+
+-
+__slots__ = '_operands'
+
-
+
+-
+type_index: Final = 4004
+
--
-class owlapy.model.OWLAnnotationAxiom(annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLAxiom
-A super interface for annotation axioms.
+-
+class owlapy.model.OWLImportsDeclaration(import_iri: owlapy.iri.IRI)[source]
+Bases: owlapy.has.HasIRI
+Represents an import statement in an ontology.
+-
+get_iri() owlapy.iri.IRI[source]
+Gets the import IRI.
+
+- Returns:
+The import IRI that points to the ontology to be imported. The imported ontology might have this IRI as
+its ontology IRI but this is not mandated. For example, an ontology with a non-resolvable ontology IRI
+can be deployed at a resolvable URL.
+
+
@@ -4125,7 +4533,7 @@ Attributes
-
class owlapy.model.OWLAnnotation(property: OWLAnnotationProperty, value: owlapy.owl_annotation.OWLAnnotationValue)[source]
-Bases: owlapy.owlobject.OWLObject
+Bases: owlapy.owl_axiom.OWLObject
Annotations are used in the various types of annotation axioms, which bind annotations to their subjects
(i.e. axioms or declarations).
@@ -4179,7 +4587,7 @@ Attributes
-
class owlapy.model.OWLAnnotationAssertionAxiom(subject: owlapy.owl_annotation.OWLAnnotationSubject, annotation: OWLAnnotation)[source]
-Bases: OWLAnnotationAxiom
+Bases: owlapy.owl_axiom.OWLAnnotationAxiom
Represents AnnotationAssertion axioms in the OWL 2 specification.
-
@@ -4241,8 +4649,8 @@
Attributes
-
-class owlapy.model.OWLSubAnnotationPropertyOfAxiom(sub_property: OWLAnnotationProperty, super_property: OWLAnnotationProperty, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLAnnotationAxiom
+class owlapy.model.OWLSubAnnotationPropertyOfAxiom(sub_property: OWLAnnotationProperty, super_property: OWLAnnotationProperty, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.OWLAnnotationAxiom
Represents an SubAnnotationPropertyOf axiom in the OWL 2 specification.
-
@@ -4281,8 +4689,8 @@
Attributes
-
-class owlapy.model.OWLAnnotationPropertyDomainAxiom(property_: OWLAnnotationProperty, domain: owlapy.iri.IRI, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLAnnotationAxiom
+class owlapy.model.OWLAnnotationPropertyDomainAxiom(property_: OWLAnnotationProperty, domain: owlapy.iri.IRI, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.OWLAnnotationAxiom
Represents an AnnotationPropertyDomain axiom in the OWL 2 specification.
-
@@ -4321,8 +4729,8 @@
Attributes
-
-class owlapy.model.OWLAnnotationPropertyRangeAxiom(property_: OWLAnnotationProperty, range_: owlapy.iri.IRI, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLAnnotationAxiom
+class owlapy.model.OWLAnnotationPropertyRangeAxiom(property_: OWLAnnotationProperty, range_: owlapy.iri.IRI, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.OWLAnnotationAxiom
Represents an AnnotationPropertyRange axiom in the OWL 2 specification.
-
@@ -4361,8 +4769,8 @@
Attributes
-
-class owlapy.model.OWLSubPropertyAxiom(sub_property: _P, super_property: _P, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: Generic[_P], OWLPropertyAxiom
+class owlapy.model.OWLSubPropertyAxiom(sub_property: _P, super_property: _P, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.Generic[_P], owlapy.owl_axiom.OWLPropertyAxiom
Base interface for object and data sub-property axioms.
-
@@ -4401,8 +4809,8 @@
Attributes
-
-class owlapy.model.OWLSubObjectPropertyOfAxiom(sub_property: owlapy.owl_property.OWLObjectPropertyExpression, super_property: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLSubPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
+class owlapy.model.OWLSubObjectPropertyOfAxiom(sub_property: owlapy.owl_axiom.OWLObjectPropertyExpression, super_property: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLSubPropertyAxiom[owlapy.owl_axiom.OWLObjectPropertyExpression], owlapy.owl_axiom.OWLObjectPropertyAxiom
Represents a SubObjectPropertyOf axiom in the OWL 2 specification.
-
@@ -4413,8 +4821,8 @@
Attributes
-
-class owlapy.model.OWLSubDataPropertyOfAxiom(sub_property: owlapy.owl_property.OWLDataPropertyExpression, super_property: owlapy.owl_property.OWLDataPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLSubPropertyAxiom[owlapy.owl_property.OWLDataPropertyExpression], OWLDataPropertyAxiom
+class owlapy.model.OWLSubDataPropertyOfAxiom(sub_property: owlapy.owl_axiom.OWLDataPropertyExpression, super_property: owlapy.owl_axiom.OWLDataPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLSubPropertyAxiom[owlapy.owl_axiom.OWLDataPropertyExpression], owlapy.owl_axiom.OWLDataPropertyAxiom
Represents a SubDataPropertyOf axiom in the OWL 2 specification.
-
@@ -4425,8 +4833,8 @@
Attributes
-
-class owlapy.model.OWLPropertyAssertionAxiom(subject: OWLIndividual, property_: _P, object_: _C, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: Generic[_P, _C], OWLIndividualAxiom
+class owlapy.model.OWLPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: _P, object_: _C, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.Generic[_P, _C], owlapy.owl_axiom.OWLIndividualAxiom
Represents a PropertyAssertion axiom in the OWL 2 specification.
-
@@ -4435,7 +4843,7 @@
Attributes
-
-get_subject() OWLIndividual[source]
+get_subject() owlapy.owl_axiom.OWLIndividual[source]
@@ -4470,8 +4878,8 @@ Attributes
-
-class owlapy.model.OWLObjectPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLObjectPropertyExpression, object_: OWLIndividual, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyAssertionAxiom[owlapy.owl_property.OWLObjectPropertyExpression, OWLIndividual]
+class owlapy.model.OWLObjectPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLObjectPropertyExpression, object_: owlapy.owl_axiom.OWLIndividual, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyAssertionAxiom[owlapy.owl_axiom.OWLObjectPropertyExpression, owlapy.owl_axiom.OWLIndividual]
Represents an ObjectPropertyAssertion axiom in the OWL 2 specification.
-
@@ -4482,8 +4890,8 @@
Attributes
-
-class owlapy.model.OWLNegativeObjectPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLObjectPropertyExpression, object_: OWLIndividual, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyAssertionAxiom[owlapy.owl_property.OWLObjectPropertyExpression, OWLIndividual]
+class owlapy.model.OWLNegativeObjectPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLObjectPropertyExpression, object_: owlapy.owl_axiom.OWLIndividual, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyAssertionAxiom[owlapy.owl_axiom.OWLObjectPropertyExpression, owlapy.owl_axiom.OWLIndividual]
Represents a NegativeObjectPropertyAssertion axiom in the OWL 2 specification.
-
@@ -4494,8 +4902,8 @@
Attributes
-
-class owlapy.model.OWLDataPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLDataPropertyExpression, object_: OWLLiteral, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyAssertionAxiom[owlapy.owl_property.OWLDataPropertyExpression, OWLLiteral]
+class owlapy.model.OWLDataPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLDataPropertyExpression, object_: OWLLiteral, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyAssertionAxiom[owlapy.owl_axiom.OWLDataPropertyExpression, OWLLiteral]
Represents an DataPropertyAssertion axiom in the OWL 2 specification.
-
@@ -4506,8 +4914,8 @@
Attributes
-
-class owlapy.model.OWLNegativeDataPropertyAssertionAxiom(subject: OWLIndividual, property_: owlapy.owl_property.OWLDataPropertyExpression, object_: OWLLiteral, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyAssertionAxiom[owlapy.owl_property.OWLDataPropertyExpression, OWLLiteral]
+class owlapy.model.OWLNegativeDataPropertyAssertionAxiom(subject: owlapy.owl_axiom.OWLIndividual, property_: owlapy.owl_axiom.OWLDataPropertyExpression, object_: OWLLiteral, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyAssertionAxiom[owlapy.owl_axiom.OWLDataPropertyExpression, OWLLiteral]
Represents an NegativeDataPropertyAssertion axiom in the OWL 2 specification.
-
@@ -4518,8 +4926,8 @@
Attributes
-
-class owlapy.model.OWLUnaryPropertyAxiom(property_: _P, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: Generic[_P], OWLPropertyAxiom
+class owlapy.model.OWLUnaryPropertyAxiom(property_: _P, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.Generic[_P], owlapy.owl_axiom.OWLPropertyAxiom
Unary property axiom.
-
@@ -4535,8 +4943,8 @@
Attributes
-
-class owlapy.model.OWLObjectPropertyCharacteristicAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLUnaryPropertyAxiom[owlapy.owl_property.OWLObjectPropertyExpression], OWLObjectPropertyAxiom
+class owlapy.model.OWLObjectPropertyCharacteristicAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLUnaryPropertyAxiom[owlapy.owl_axiom.OWLObjectPropertyExpression], owlapy.owl_axiom.OWLObjectPropertyAxiom
Base interface for functional object property axiom.
-
@@ -4565,7 +4973,7 @@
Attributes
-
-class owlapy.model.OWLFunctionalObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLFunctionalObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLObjectPropertyCharacteristicAxiom
Represents FunctionalObjectProperty axioms in the OWL 2 specification.
@@ -4577,7 +4985,7 @@ Attributes
-
-class owlapy.model.OWLAsymmetricObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLAsymmetricObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLObjectPropertyCharacteristicAxiom
Represents AsymmetricObjectProperty axioms in the OWL 2 specification.
@@ -4589,7 +4997,7 @@ Attributes
-
-class owlapy.model.OWLInverseFunctionalObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLInverseFunctionalObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLObjectPropertyCharacteristicAxiom
Represents InverseFunctionalObjectProperty axioms in the OWL 2 specification.
@@ -4601,7 +5009,7 @@ Attributes
-
-class owlapy.model.OWLIrreflexiveObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLIrreflexiveObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLObjectPropertyCharacteristicAxiom
Represents IrreflexiveObjectProperty axioms in the OWL 2 specification.
@@ -4613,7 +5021,7 @@ Attributes
-
-class owlapy.model.OWLReflexiveObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLReflexiveObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLObjectPropertyCharacteristicAxiom
Represents ReflexiveObjectProperty axioms in the OWL 2 specification.
@@ -4625,7 +5033,7 @@ Attributes
-
-class owlapy.model.OWLSymmetricObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLSymmetricObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLObjectPropertyCharacteristicAxiom
Represents SymmetricObjectProperty axioms in the OWL 2 specification.
@@ -4637,7 +5045,7 @@ Attributes
-
-class owlapy.model.OWLTransitiveObjectPropertyAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLTransitiveObjectPropertyAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLObjectPropertyCharacteristicAxiom
Represents TransitiveObjectProperty axioms in the OWL 2 specification.
@@ -4649,8 +5057,8 @@ Attributes
-
-class owlapy.model.OWLDataPropertyCharacteristicAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLUnaryPropertyAxiom[owlapy.owl_property.OWLDataPropertyExpression], OWLDataPropertyAxiom
+class owlapy.model.OWLDataPropertyCharacteristicAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLUnaryPropertyAxiom[owlapy.owl_axiom.OWLDataPropertyExpression], owlapy.owl_axiom.OWLDataPropertyAxiom
Base interface for Functional data property axiom.
-
@@ -4679,7 +5087,7 @@
Attributes
-
-class owlapy.model.OWLFunctionalDataPropertyAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
+class owlapy.model.OWLFunctionalDataPropertyAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
Bases: OWLDataPropertyCharacteristicAxiom
Represents FunctionalDataProperty axioms in the OWL 2 specification.
@@ -4691,8 +5099,8 @@ Attributes
-
-class owlapy.model.OWLPropertyDomainAxiom(property_: _P, domain: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: Generic[_P], OWLUnaryPropertyAxiom[_P]
+class owlapy.model.OWLPropertyDomainAxiom(property_: _P, domain: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.Generic[_P], OWLUnaryPropertyAxiom[_P]
Represents ObjectPropertyDomain axioms in the OWL 2 specification.
-
@@ -4701,7 +5109,7 @@
Attributes
-
-get_domain() owlapy.owl_class_expression.OWLClassExpression[source]
+get_domain() owlapy.owl_axiom.OWLClassExpression[source]
@@ -4726,8 +5134,8 @@ Attributes
-
-class owlapy.model.OWLPropertyRangeAxiom(property_: _P, range_: _R, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: Generic[_P, _R], OWLUnaryPropertyAxiom[_P]
+class owlapy.model.OWLPropertyRangeAxiom(property_: _P, range_: _R, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: owlapy.owl_axiom.Generic[_P, _R], OWLUnaryPropertyAxiom[_P]
Represents ObjectPropertyRange axioms in the OWL 2 specification.
-
@@ -4761,8 +5169,8 @@
Attributes
-
-class owlapy.model.OWLObjectPropertyDomainAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, domain: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyDomainAxiom[owlapy.owl_property.OWLObjectPropertyExpression]
+class owlapy.model.OWLObjectPropertyDomainAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, domain: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyDomainAxiom[owlapy.owl_axiom.OWLObjectPropertyExpression]
Represents a ObjectPropertyDomain axiom in the OWL 2 Specification.
-
@@ -4773,8 +5181,8 @@
Attributes
-
-class owlapy.model.OWLDataPropertyDomainAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, domain: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyDomainAxiom[owlapy.owl_property.OWLDataPropertyExpression]
+class owlapy.model.OWLDataPropertyDomainAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, domain: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyDomainAxiom[owlapy.owl_axiom.OWLDataPropertyExpression]
Represents a DataPropertyDomain axiom in the OWL 2 Specification.
-
@@ -4785,8 +5193,8 @@
Attributes
-
-class owlapy.model.OWLObjectPropertyRangeAxiom(property_: owlapy.owl_property.OWLObjectPropertyExpression, range_: owlapy.owl_class_expression.OWLClassExpression, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyRangeAxiom[owlapy.owl_property.OWLObjectPropertyExpression, owlapy.owl_class_expression.OWLClassExpression]
+class owlapy.model.OWLObjectPropertyRangeAxiom(property_: owlapy.owl_axiom.OWLObjectPropertyExpression, range_: owlapy.owl_axiom.OWLClassExpression, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyRangeAxiom[owlapy.owl_axiom.OWLObjectPropertyExpression, owlapy.owl_axiom.OWLClassExpression]
Represents a ObjectPropertyRange axiom in the OWL 2 Specification.
-
@@ -4797,8 +5205,8 @@
Attributes
-
-class owlapy.model.OWLDataPropertyRangeAxiom(property_: owlapy.owl_property.OWLDataPropertyExpression, range_: owlapy.owl_class_expression.OWLDataRange, annotations: Iterable[OWLAnnotation] | None = None)[source]
-Bases: OWLPropertyRangeAxiom[owlapy.owl_property.OWLDataPropertyExpression, owlapy.owl_class_expression.OWLDataRange]
+class owlapy.model.OWLDataPropertyRangeAxiom(property_: owlapy.owl_axiom.OWLDataPropertyExpression, range_: owlapy.owl_axiom.OWLDataRange, annotations: owlapy.owl_axiom.Optional[owlapy.owl_axiom.Iterable[OWLAnnotation]] = None)[source]
+Bases: OWLPropertyRangeAxiom[owlapy.owl_axiom.OWLDataPropertyExpression, owlapy.owl_axiom.OWLDataRange]
Represents a DataPropertyRange axiom in the OWL 2 Specification.
-
@@ -4810,7 +5218,7 @@
Attributes
-
class owlapy.model.OWLOntology[source]
-Bases: owlapy.owlobject.OWLObject
+Bases: owlapy.owl_axiom.OWLObject
Represents an OWL 2 Ontology in the OWL 2 specification.
An OWLOntology consists of a possibly empty set of OWLAxioms and a possibly empty set of OWLAnnotations.
An ontology can have an ontology IRI which can be used to identify the ontology. If it has an ontology IRI then
@@ -4829,7 +5237,7 @@
Attributes
-
-abstract classes_in_signature() Iterable[owlapy.owl_class_expression.OWLClass][source]
+abstract classes_in_signature() owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClass][source]
Gets the classes in the signature of this object.
- Returns:
@@ -4840,7 +5248,7 @@ Attributes
-
-abstract data_properties_in_signature() Iterable[owlapy.owl_property.OWLDataProperty][source]
+abstract data_properties_in_signature() owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty][source]
Get the data properties that are in the signature of this object.
- Returns:
@@ -4851,7 +5259,7 @@ Attributes
-
-abstract object_properties_in_signature() Iterable[owlapy.owl_property.OWLObjectProperty][source]
+abstract object_properties_in_signature() owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLObjectProperty][source]
A convenience method that obtains the object properties that are in the signature of this object.
- Returns:
@@ -4862,7 +5270,7 @@ Attributes
-
-abstract individuals_in_signature() Iterable[OWLNamedIndividual][source]
+abstract individuals_in_signature() owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual][source]
A convenience method that obtains the individuals that are in the signature of this object.
- Returns:
@@ -4873,7 +5281,7 @@ Attributes
-
-abstract equivalent_classes_axioms(c: owlapy.owl_class_expression.OWLClass) Iterable[OWLEquivalentClassesAxiom][source]
+abstract equivalent_classes_axioms(c: owlapy.owl_axiom.OWLClass) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLEquivalentClassesAxiom][source]
Gets all of the equivalent axioms in this ontology that contain the specified class as an operand.
- Parameters:
@@ -4887,7 +5295,7 @@ Attributes
-
-abstract general_class_axioms() Iterable[OWLClassAxiom][source]
+abstract general_class_axioms() owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassAxiom][source]
- Get the general class axioms of this ontology. This includes SubClass axioms with a complex class expression
as the sub class and EquivalentClass axioms and DisjointClass axioms with only complex class expressions.
Attributes
-
-abstract data_property_domain_axioms(property: owlapy.owl_property.OWLDataProperty) Iterable[OWLDataPropertyDomainAxiom][source]
+abstract data_property_domain_axioms(property: owlapy.owl_property.OWLDataProperty) owlapy.owl_axiom.Iterable[OWLDataPropertyDomainAxiom][source]
Gets the OWLDataPropertyDomainAxiom objects where the property is equal to the specified property.
- Parameters:
@@ -4915,7 +5323,7 @@ Attributes
-
-abstract data_property_range_axioms(property: owlapy.owl_property.OWLDataProperty) Iterable[OWLDataPropertyRangeAxiom][source]
+abstract data_property_range_axioms(property: owlapy.owl_property.OWLDataProperty) owlapy.owl_axiom.Iterable[OWLDataPropertyRangeAxiom][source]
Gets the OWLDataPropertyRangeAxiom objects where the property is equal to the specified property.
- Parameters:
@@ -4929,7 +5337,7 @@ Attributes
-
-abstract object_property_domain_axioms(property: owlapy.owl_property.OWLObjectProperty) Iterable[OWLObjectPropertyDomainAxiom][source]
+abstract object_property_domain_axioms(property: owlapy.owl_property.OWLObjectProperty) owlapy.owl_axiom.Iterable[OWLObjectPropertyDomainAxiom][source]
Gets the OWLObjectPropertyDomainAxiom objects where the property is equal to the specified property.
- Parameters:
@@ -4943,7 +5351,7 @@ Attributes
-
-abstract object_property_range_axioms(property: owlapy.owl_property.OWLObjectProperty) Iterable[OWLObjectPropertyRangeAxiom][source]
+abstract object_property_range_axioms(property: owlapy.owl_property.OWLObjectProperty) owlapy.owl_axiom.Iterable[OWLObjectPropertyRangeAxiom][source]
Gets the OWLObjectPropertyRangeAxiom objects where the property is equal to the specified property.
- Parameters:
@@ -5079,7 +5487,7 @@ Attributes
-
-abstract add_axiom(ontology: OWLOntology, axiom: OWLAxiom)[source]
+abstract add_axiom(ontology: OWLOntology, axiom: owlapy.owl_axiom.OWLAxiom)[source]
A convenience method that adds a single axiom to an ontology.
- Parameters:
@@ -5093,7 +5501,7 @@ Attributes
-
-abstract remove_axiom(ontology: OWLOntology, axiom: OWLAxiom)[source]
+abstract remove_axiom(ontology: OWLOntology, axiom: owlapy.owl_axiom.OWLAxiom)[source]
A convenience method that removes a single axiom from an ontology.
- Parameters:
@@ -5134,7 +5542,7 @@ Attributes
-
-abstract data_property_domains(pe: owlapy.owl_property.OWLDataProperty, direct: bool = False) Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+abstract data_property_domains(pe: owlapy.owl_property.OWLDataProperty, direct: bool = False) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression][source]
- Gets the class expressions that are the direct or indirect domains of this property with respect to the
imports closure of the root ontology.
Attributes
-
-abstract object_property_domains(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+abstract object_property_domains(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression][source]
- Gets the class expressions that are the direct or indirect domains of this property with respect to the
imports closure of the root ontology.
Attributes
-
-abstract object_property_ranges(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+abstract object_property_ranges(pe: owlapy.owl_property.OWLObjectProperty, direct: bool = False) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression][source]
- Gets the class expressions that are the direct or indirect ranges of this property with respect to the
imports closure of the root ontology.
Attributes
-
-abstract equivalent_classes(ce: owlapy.owl_class_expression.OWLClassExpression, only_named: bool = True) Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+abstract equivalent_classes(ce: owlapy.owl_axiom.OWLClassExpression, only_named: bool = True) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression][source]
Gets the class expressions that are equivalent to the specified class expression with respect to the set of
reasoner axioms.
@@ -5229,7 +5637,7 @@ Attributes
-
-abstract disjoint_classes(ce: owlapy.owl_class_expression.OWLClassExpression, only_named: bool = True) Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+abstract disjoint_classes(ce: owlapy.owl_axiom.OWLClassExpression, only_named: bool = True) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression][source]
Gets the class expressions that are disjoint with specified class expression with respect to the set of
reasoner axioms.
@@ -5248,7 +5656,7 @@ Attributes
-
-abstract different_individuals(ind: OWLNamedIndividual) Iterable[OWLNamedIndividual][source]
+abstract different_individuals(ind: owlapy.owl_individual.OWLNamedIndividual) owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual][source]
Gets the individuals that are different from the specified individual with respect to the set of
reasoner axioms.
@@ -5263,7 +5671,7 @@ Attributes
-
-abstract same_individuals(ind: OWLNamedIndividual) Iterable[OWLNamedIndividual][source]
+abstract same_individuals(ind: owlapy.owl_individual.OWLNamedIndividual) owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual][source]
Gets the individuals that are the same as the specified individual with respect to the set of
reasoner axioms.
@@ -5278,7 +5686,7 @@ Attributes
-
-abstract equivalent_object_properties(op: owlapy.owl_property.OWLObjectPropertyExpression) Iterable[owlapy.owl_property.OWLObjectPropertyExpression][source]
+abstract equivalent_object_properties(op: owlapy.owl_axiom.OWLObjectPropertyExpression) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLObjectPropertyExpression][source]
Gets the simplified object properties that are equivalent to the specified object property with respect
to the set of reasoner axioms.
@@ -5295,7 +5703,7 @@ Attributes
-
-abstract equivalent_data_properties(dp: owlapy.owl_property.OWLDataProperty) Iterable[owlapy.owl_property.OWLDataProperty][source]
+abstract equivalent_data_properties(dp: owlapy.owl_property.OWLDataProperty) owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty][source]
Gets the data properties that are equivalent to the specified data property with respect to the set of
reasoner axioms.
@@ -5312,7 +5720,7 @@ Attributes
-
-abstract data_property_values(ind: OWLNamedIndividual, pe: owlapy.owl_property.OWLDataProperty, direct: bool = True) Iterable[OWLLiteral][source]
+abstract data_property_values(ind: owlapy.owl_individual.OWLNamedIndividual, pe: owlapy.owl_property.OWLDataProperty, direct: bool = True) owlapy.owl_axiom.Iterable[OWLLiteral][source]
Gets the data property values for the specified individual and data property expression.
- Parameters:
@@ -5332,7 +5740,7 @@ Attributes
-
-abstract object_property_values(ind: OWLNamedIndividual, pe: owlapy.owl_property.OWLObjectPropertyExpression, direct: bool = True) Iterable[OWLNamedIndividual][source]
+abstract object_property_values(ind: owlapy.owl_individual.OWLNamedIndividual, pe: owlapy.owl_axiom.OWLObjectPropertyExpression, direct: bool = True) owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual][source]
Gets the object property values for the specified individual and object property expression.
- Parameters:
@@ -5359,7 +5767,7 @@ Attributes
-
-abstract instances(ce: owlapy.owl_class_expression.OWLClassExpression, direct: bool = False) Iterable[OWLNamedIndividual][source]
+abstract instances(ce: owlapy.owl_axiom.OWLClassExpression, direct: bool = False) owlapy.owl_axiom.Iterable[owlapy.owl_individual.OWLNamedIndividual][source]
Gets the individuals which are instances of the specified class expression.
- Parameters:
@@ -5380,7 +5788,7 @@ Attributes
-
-abstract sub_classes(ce: owlapy.owl_class_expression.OWLClassExpression, direct: bool = False, only_named: bool = True) Iterable[owlapy.owl_class_expression.OWLClassExpression][source]
+abstract sub_classes(ce: owlapy.owl_axiom.OWLClassExpression, direct: bool = False, only_named: bool = True) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLClassExpression][source]
Gets the set of named classes that are the strict (potentially direct) subclasses of the specified class
expression with respect to the reasoner axioms.
@@ -5402,7 +5810,7 @@ Attributes
-
-abstract disjoint_object_properties(op: owlapy.owl_property.OWLObjectPropertyExpression) Iterable[owlapy.owl_property.OWLObjectPropertyExpression][source]
+abstract disjoint_object_properties(op: owlapy.owl_axiom.OWLObjectPropertyExpression) owlapy.owl_axiom.Iterable[owlapy.owl_axiom.OWLObjectPropertyExpression][source]
Gets the simplified object properties that are disjoint with the specified object property with respect
to the set of reasoner axioms.
@@ -5419,7 +5827,7 @@ Attributes
-
-abstract disjoint_data_properties(dp: owlapy.owl_property.OWLDataProperty) Iterable[owlapy.owl_property.OWLDataProperty][source]
+abstract disjoint_data_properties(dp: owlapy.owl_property.OWLDataProperty) owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty][source]
Gets the data properties that are disjoint with the specified data property with respect
to the set of reasoner axioms.
@@ -5436,7 +5844,7 @@ Attributes
-
-abstract sub_data_properties(dp: owlapy.owl_property.OWLDataProperty, direct: bool = False) Iterable[owlapy.owl_property.OWLDataProperty][source]
+abstract sub_data_properties(dp: owlapy.owl_property.OWLDataProperty, direct: bool = False) owlapy.owl_axiom.Iterable[owlapy.owl_property.OWLDataProperty][source]
Gets the set of named data properties that are the strict (potentially direct) subproperties of the
specified data property expression with respect to the imports closure of the root ontology.
@@ -5458,7 +5866,7 @@ Attributes
-
-abstract super_data_properties(