hydra.owl.syntax module

An OWL 2 syntax model. See https://www.w3.org/TR/owl2-syntax.

class hydra.owl.syntax.Annotation(annotations: Sequence[Annotation], property: AnnotationProperty, value: AnnotationValue)

Bases: object

An OWL annotation on an axiom, consisting of a property and value.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'AnnotationProperty' = None, _value: 'AnnotationValue' = None)

Bases: object

annotations(annotations)

build()

property(property)

value(value)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.Annotation')

VALUE = Name(value='value')

annotations: Sequence[Annotation]

static builder()

property: AnnotationProperty

value: AnnotationValue

with_annotations(annotations)

with_property(property)

with_value(value)

class hydra.owl.syntax.AnnotationAssertion(annotations: Sequence[Annotation], property: AnnotationProperty, subject: AnnotationSubject, value: AnnotationValue)

Bases: object

An OWL annotation assertion axiom.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'AnnotationProperty' = None, _subject: 'AnnotationSubject' = None, _value: 'AnnotationValue' = None)

Bases: object

annotations(annotations)

build()

property(property)

subject(subject)

value(value)

PROPERTY = Name(value='property')

SUBJECT = Name(value='subject')

TYPE_ = Name(value='hydra.owl.syntax.AnnotationAssertion')

VALUE = Name(value='value')

annotations: Sequence[Annotation]

static builder()

property: AnnotationProperty

subject: AnnotationSubject

value: AnnotationValue

with_annotations(annotations)

with_property(property)

with_subject(subject)

with_value(value)

class hydra.owl.syntax.AnnotationAxiom

Bases: object

AnnotationAxiomAnnotationAssertion | AnnotationAxiomAnnotationPropertyDomain | AnnotationAxiomAnnotationPropertyRange | AnnotationAxiomSubAnnotationPropertyOf

ANNOTATION_ASSERTION = Name(value='annotationAssertion')

ANNOTATION_PROPERTY_DOMAIN = Name(value='annotationPropertyDomain')

ANNOTATION_PROPERTY_RANGE = Name(value='annotationPropertyRange')

SUB_ANNOTATION_PROPERTY_OF = Name(value='subAnnotationPropertyOf')

TYPE_ = Name(value='hydra.owl.syntax.AnnotationAxiom')

class hydra.owl.syntax.AnnotationAxiomAnnotationAssertion(value: T)

Bases: Node[AnnotationAssertion]

class hydra.owl.syntax.AnnotationAxiomAnnotationPropertyDomain(value: T)

Bases: Node[AnnotationPropertyDomain]

class hydra.owl.syntax.AnnotationAxiomAnnotationPropertyRange(value: T)

Bases: Node[AnnotationPropertyRange]

class hydra.owl.syntax.AnnotationAxiomSubAnnotationPropertyOf(value: T)

Bases: Node[SubAnnotationPropertyOf]

class hydra.owl.syntax.AnnotationProperty(value: T)

Bases: Node[None]

An OWL annotation property, identified by an IRI.

TYPE_ = Name(value='hydra.owl.syntax.AnnotationProperty')

class hydra.owl.syntax.AnnotationPropertyDomain(annotations: Sequence[Annotation], property: AnnotationProperty, iri: Iri)

Bases: object

An OWL axiom asserting the domain of an annotation property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'AnnotationProperty' = None, _iri: 'hydra.rdf.syntax.Iri' = None)

Bases: object

annotations(annotations)

build()

iri(iri)

property(property)

IRI = Name(value='iri')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.AnnotationPropertyDomain')

annotations: Sequence[Annotation]

static builder()

iri: Iri

property: AnnotationProperty

with_annotations(annotations)

with_iri(iri)

with_property(property)

class hydra.owl.syntax.AnnotationPropertyRange(annotations: Sequence[Annotation], property: AnnotationProperty, iri: Iri)

Bases: object

An OWL axiom asserting the range of an annotation property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'AnnotationProperty' = None, _iri: 'hydra.rdf.syntax.Iri' = None)

Bases: object

annotations(annotations)

build()

iri(iri)

property(property)

IRI = Name(value='iri')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.AnnotationPropertyRange')

annotations: Sequence[Annotation]

static builder()

iri: Iri

property: AnnotationProperty

with_annotations(annotations)

with_iri(iri)

with_property(property)

class hydra.owl.syntax.AnnotationSubject

Bases: object

AnnotationSubjectIri | AnnotationSubjectAnonymousIndividual

ANONYMOUS_INDIVIDUAL = Name(value='anonymousIndividual')

IRI = Name(value='iri')

TYPE_ = Name(value='hydra.owl.syntax.AnnotationSubject')

class hydra.owl.syntax.AnnotationSubjectAnonymousIndividual(value: T)

Bases: Node[AnonymousIndividual]

class hydra.owl.syntax.AnnotationSubjectIri(value: T)

Bases: Node[hydra.rdf.syntax.Iri]

class hydra.owl.syntax.AnnotationValue

Bases: object

AnnotationValueAnonymousIndividual | AnnotationValueIri | AnnotationValueLiteral

ANONYMOUS_INDIVIDUAL = Name(value='anonymousIndividual')

IRI = Name(value='iri')

LITERAL = Name(value='literal')

TYPE_ = Name(value='hydra.owl.syntax.AnnotationValue')

class hydra.owl.syntax.AnnotationValueAnonymousIndividual(value: T)

Bases: Node[AnonymousIndividual]

class hydra.owl.syntax.AnnotationValueIri(value: T)

Bases: Node[hydra.rdf.syntax.Iri]

class hydra.owl.syntax.AnnotationValueLiteral(value: T)

Bases: Node[hydra.rdf.syntax.Literal]

class hydra.owl.syntax.AnonymousIndividual(value: T)

Bases: Node[None]

An OWL anonymous individual, identified by a blank node id.

TYPE_ = Name(value='hydra.owl.syntax.AnonymousIndividual')

class hydra.owl.syntax.Assertion

Bases: object

AssertionClassAssertion | AssertionDataPropertyAssertion | AssertionDifferentIndividuals | AssertionObjectPropertyAssertion | AssertionNegativeDataPropertyAssertion | AssertionNegativeObjectPropertyAssertion | AssertionSameIndividual

CLASS_ASSERTION = Name(value='classAssertion')

DATA_PROPERTY_ASSERTION = Name(value='dataPropertyAssertion')

DIFFERENT_INDIVIDUALS = Name(value='differentIndividuals')

NEGATIVE_DATA_PROPERTY_ASSERTION = Name(value='negativeDataPropertyAssertion')

NEGATIVE_OBJECT_PROPERTY_ASSERTION = Name(value='negativeObjectPropertyAssertion')

OBJECT_PROPERTY_ASSERTION = Name(value='objectPropertyAssertion')

SAME_INDIVIDUAL = Name(value='sameIndividual')

TYPE_ = Name(value='hydra.owl.syntax.Assertion')

class hydra.owl.syntax.AssertionClassAssertion(value: T)

Bases: Node[ClassAssertion]

class hydra.owl.syntax.AssertionDataPropertyAssertion(value: T)

Bases: Node[DataPropertyAssertion]

class hydra.owl.syntax.AssertionDifferentIndividuals(value: T)

Bases: Node[DifferentIndividuals]

class hydra.owl.syntax.AssertionNegativeDataPropertyAssertion(value: T)

Bases: Node[NegativeDataPropertyAssertion]

class hydra.owl.syntax.AssertionNegativeObjectPropertyAssertion(value: T)

Bases: Node[NegativeObjectPropertyAssertion]

class hydra.owl.syntax.AssertionObjectPropertyAssertion(value: T)

Bases: Node[ObjectPropertyAssertion]

class hydra.owl.syntax.AssertionSameIndividual(value: T)

Bases: Node[SameIndividual]

class hydra.owl.syntax.AsymmetricObjectProperty(annotations: Sequence[Annotation], property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.AsymmetricObjectProperty')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

with_annotations(annotations)

with_property(property)

class hydra.owl.syntax.Axiom

Bases: object

AxiomAnnotationAxiom | AxiomAssertion | AxiomClassAxiom | AxiomDataPropertyAxiom | AxiomDatatypeDefinition | AxiomDeclaration | AxiomHasKey | AxiomObjectPropertyAxiom

ANNOTATION_AXIOM = Name(value='annotationAxiom')

ASSERTION = Name(value='assertion')

CLASS_AXIOM = Name(value='classAxiom')

DATATYPE_DEFINITION = Name(value='datatypeDefinition')

DATA_PROPERTY_AXIOM = Name(value='dataPropertyAxiom')

DECLARATION = Name(value='declaration')

HAS_KEY = Name(value='hasKey')

OBJECT_PROPERTY_AXIOM = Name(value='objectPropertyAxiom')

TYPE_ = Name(value='hydra.owl.syntax.Axiom')

class hydra.owl.syntax.AxiomAnnotationAxiom(value: T)

Bases: Node[AnnotationAxiom]

class hydra.owl.syntax.AxiomAssertion(value: T)

Bases: Node[Assertion]

class hydra.owl.syntax.AxiomClassAxiom(value: T)

Bases: Node[ClassAxiom]

class hydra.owl.syntax.AxiomDataPropertyAxiom(value: T)

Bases: Node[DataPropertyAxiom]

class hydra.owl.syntax.AxiomDatatypeDefinition(value: T)

Bases: Node[DatatypeDefinition]

class hydra.owl.syntax.AxiomDeclaration(value: T)

Bases: Node[Declaration]

class hydra.owl.syntax.AxiomHasKey(value: T)

Bases: Node[HasKey]

class hydra.owl.syntax.AxiomObjectPropertyAxiom(value: T)

Bases: Node[ObjectPropertyAxiom]

class hydra.owl.syntax.Class(value: T)

Bases: Node[None]

An OWL class, identified by an IRI.

TYPE_ = Name(value='hydra.owl.syntax.Class')

class hydra.owl.syntax.ClassAssertion(annotations: Sequence[Annotation], class_: ClassExpression, individual: Individual)

Bases: object

An OWL axiom asserting that an individual belongs to a class.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _class_: 'ClassExpression' = None, _individual: 'Individual' = None)

Bases: object

annotations(annotations)

build()

class_(class_)

individual(individual)

CLASS = Name(value='class')

INDIVIDUAL = Name(value='individual')

TYPE_ = Name(value='hydra.owl.syntax.ClassAssertion')

annotations: Sequence[Annotation]

static builder()

class_: ClassExpression

individual: Individual

with_annotations(annotations)

with_class_(class_)

with_individual(individual)

class hydra.owl.syntax.ClassAxiom

Bases: object

ClassAxiomDisjointClasses | ClassAxiomDisjointUnion | ClassAxiomEquivalentClasses | ClassAxiomSubClassOf

DISJOINT_CLASSES = Name(value='disjointClasses')

DISJOINT_UNION = Name(value='disjointUnion')

EQUIVALENT_CLASSES = Name(value='equivalentClasses')

SUB_CLASS_OF = Name(value='subClassOf')

TYPE_ = Name(value='hydra.owl.syntax.ClassAxiom')

class hydra.owl.syntax.ClassAxiomDisjointClasses(value: T)

Bases: Node[DisjointClasses]

class hydra.owl.syntax.ClassAxiomDisjointUnion(value: T)

Bases: Node[DisjointUnion]

class hydra.owl.syntax.ClassAxiomEquivalentClasses(value: T)

Bases: Node[EquivalentClasses]

class hydra.owl.syntax.ClassAxiomSubClassOf(value: T)

Bases: Node[SubClassOf]

class hydra.owl.syntax.ClassExpression

Bases: object

ClassExpressionClass | ClassExpressionDataSomeValuesFrom | ClassExpressionDataAllValuesFrom | ClassExpressionDataHasValue | ClassExpressionDataMinCardinality | ClassExpressionDataMaxCardinality | ClassExpressionDataExactCardinality | ClassExpressionObjectAllValuesFrom | ClassExpressionObjectExactCardinality | ClassExpressionObjectHasSelf | ClassExpressionObjectHasValue | ClassExpressionObjectIntersectionOf | ClassExpressionObjectMaxCardinality | ClassExpressionObjectMinCardinality | ClassExpressionObjectOneOf | ClassExpressionObjectSomeValuesFrom | ClassExpressionObjectUnionOf

CLASS = Name(value='class')

DATA_ALL_VALUES_FROM = Name(value='dataAllValuesFrom')

DATA_EXACT_CARDINALITY = Name(value='dataExactCardinality')

DATA_HAS_VALUE = Name(value='dataHasValue')

DATA_MAX_CARDINALITY = Name(value='dataMaxCardinality')

DATA_MIN_CARDINALITY = Name(value='dataMinCardinality')

DATA_SOME_VALUES_FROM = Name(value='dataSomeValuesFrom')

OBJECT_ALL_VALUES_FROM = Name(value='objectAllValuesFrom')

OBJECT_EXACT_CARDINALITY = Name(value='objectExactCardinality')

OBJECT_HAS_SELF = Name(value='objectHasSelf')

OBJECT_HAS_VALUE = Name(value='objectHasValue')

OBJECT_INTERSECTION_OF = Name(value='objectIntersectionOf')

OBJECT_MAX_CARDINALITY = Name(value='objectMaxCardinality')

OBJECT_MIN_CARDINALITY = Name(value='objectMinCardinality')

OBJECT_ONE_OF = Name(value='objectOneOf')

OBJECT_SOME_VALUES_FROM = Name(value='objectSomeValuesFrom')

OBJECT_UNION_OF = Name(value='objectUnionOf')

TYPE_ = Name(value='hydra.owl.syntax.ClassExpression')

class hydra.owl.syntax.ClassExpressionClass(value: T)

Bases: Node[Class]

class hydra.owl.syntax.ClassExpressionDataAllValuesFrom(value: T)

Bases: Node[DataAllValuesFrom]

class hydra.owl.syntax.ClassExpressionDataExactCardinality(value: T)

Bases: Node[DataExactCardinality]

class hydra.owl.syntax.ClassExpressionDataHasValue(value: T)

Bases: Node[DataHasValue]

class hydra.owl.syntax.ClassExpressionDataMaxCardinality(value: T)

Bases: Node[DataMaxCardinality]

class hydra.owl.syntax.ClassExpressionDataMinCardinality(value: T)

Bases: Node[DataMinCardinality]

class hydra.owl.syntax.ClassExpressionDataSomeValuesFrom(value: T)

Bases: Node[DataSomeValuesFrom]

class hydra.owl.syntax.ClassExpressionObjectAllValuesFrom(value: T)

Bases: Node[ObjectAllValuesFrom]

class hydra.owl.syntax.ClassExpressionObjectExactCardinality(value: T)

Bases: Node[ObjectExactCardinality]

class hydra.owl.syntax.ClassExpressionObjectHasSelf(value: T)

Bases: Node[ObjectHasSelf]

class hydra.owl.syntax.ClassExpressionObjectHasValue(value: T)

Bases: Node[ObjectHasValue]

class hydra.owl.syntax.ClassExpressionObjectIntersectionOf(value: T)

Bases: Node[ObjectIntersectionOf]

class hydra.owl.syntax.ClassExpressionObjectMaxCardinality(value: T)

Bases: Node[ObjectMaxCardinality]

class hydra.owl.syntax.ClassExpressionObjectMinCardinality(value: T)

Bases: Node[ObjectMinCardinality]

class hydra.owl.syntax.ClassExpressionObjectOneOf(value: T)

Bases: Node[ObjectOneOf]

class hydra.owl.syntax.ClassExpressionObjectSomeValuesFrom(value: T)

Bases: Node[ObjectSomeValuesFrom]

class hydra.owl.syntax.ClassExpressionObjectUnionOf(value: T)

Bases: Node[ObjectUnionOf]

class hydra.owl.syntax.DataAllValuesFrom(property: Sequence[DataPropertyExpression], range_: DataRange)

Bases: object

An OWL universal data property restriction.

class Builder(_property: 'Sequence[DataPropertyExpression]' = None, _range_: 'DataRange' = None)

Bases: object

build()

property(property)

range_(range_)

PROPERTY = Name(value='property')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.DataAllValuesFrom')

static builder()

property: Sequence[DataPropertyExpression]

range_: DataRange

with_property(property)

with_range_(range_)

class hydra.owl.syntax.DataComplementOf(value: T)

Bases: Node[DataRange]

An OWL data range which is the complement of another data range.

TYPE_ = Name(value='hydra.owl.syntax.DataComplementOf')

class hydra.owl.syntax.DataExactCardinality(bound: int, property: DataPropertyExpression, range_: Sequence[DataRange])

Bases: object

An OWL exact-cardinality restriction on a data property.

BOUND = Name(value='bound')

class Builder(_bound: 'int' = None, _property: 'DataPropertyExpression' = None, _range_: 'Sequence[DataRange]' = None)

Bases: object

bound(bound)

build()

property(property)

range_(range_)

PROPERTY = Name(value='property')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.DataExactCardinality')

bound: int

static builder()

property: DataPropertyExpression

range_: Sequence[DataRange]

with_bound(bound)

with_property(property)

with_range_(range_)

class hydra.owl.syntax.DataHasValue(property: DataPropertyExpression, value: Literal)

Bases: object

An OWL data property restriction requiring a specific literal value.

class Builder(_property: 'DataPropertyExpression' = None, _value: 'hydra.rdf.syntax.Literal' = None)

Bases: object

build()

property(property)

value(value)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.DataHasValue')

VALUE = Name(value='value')

static builder()

property: DataPropertyExpression

value: Literal

with_property(property)

with_value(value)

class hydra.owl.syntax.DataIntersectionOf(value: T)

Bases: Node[Sequence[DataRange]]

An OWL data range which is the intersection of two or more data ranges.

TYPE_ = Name(value='hydra.owl.syntax.DataIntersectionOf')

class hydra.owl.syntax.DataMaxCardinality(bound: int, property: DataPropertyExpression, range_: Sequence[DataRange])

Bases: object

An OWL maximum-cardinality restriction on a data property.

BOUND = Name(value='bound')

class Builder(_bound: 'int' = None, _property: 'DataPropertyExpression' = None, _range_: 'Sequence[DataRange]' = None)

Bases: object

bound(bound)

build()

property(property)

range_(range_)

PROPERTY = Name(value='property')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.DataMaxCardinality')

bound: int

static builder()

property: DataPropertyExpression

range_: Sequence[DataRange]

with_bound(bound)

with_property(property)

with_range_(range_)

class hydra.owl.syntax.DataMinCardinality(bound: int, property: DataPropertyExpression, range_: Sequence[DataRange])

Bases: object

An OWL minimum-cardinality restriction on a data property.

BOUND = Name(value='bound')

class Builder(_bound: 'int' = None, _property: 'DataPropertyExpression' = None, _range_: 'Sequence[DataRange]' = None)

Bases: object

bound(bound)

build()

property(property)

range_(range_)

PROPERTY = Name(value='property')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.DataMinCardinality')

bound: int

static builder()

property: DataPropertyExpression

range_: Sequence[DataRange]

with_bound(bound)

with_property(property)

with_range_(range_)

class hydra.owl.syntax.DataOneOf(value: T)

Bases: Node[Sequence[hydra.rdf.syntax.Literal]]

An OWL data range enumerating one or more literals.

TYPE_ = Name(value='hydra.owl.syntax.DataOneOf')

class hydra.owl.syntax.DataProperty(value: T)

Bases: Node[None]

An OWL data property, identified by an IRI.

TYPE_ = Name(value='hydra.owl.syntax.DataProperty')

class hydra.owl.syntax.DataPropertyAssertion(annotations: Sequence[Annotation], property: DataPropertyExpression, source: Individual, target: Individual)

Bases: object

An OWL axiom asserting a data property relationship between an individual and a literal.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'DataPropertyExpression' = None, _source: 'Individual' = None, _target: 'Individual' = None)

Bases: object

annotations(annotations)

build()

property(property)

source(source)

target(target)

PROPERTY = Name(value='property')

SOURCE = Name(value='source')

TARGET = Name(value='target')

TYPE_ = Name(value='hydra.owl.syntax.DataPropertyAssertion')

annotations: Sequence[Annotation]

static builder()

property: DataPropertyExpression

source: Individual

target: Individual

with_annotations(annotations)

with_property(property)

with_source(source)

with_target(target)

class hydra.owl.syntax.DataPropertyAxiom

Bases: object

DataPropertyAxiomDataPropertyAxiom | DataPropertyAxiomDataPropertyRange | DataPropertyAxiomDisjointDataProperties | DataPropertyAxiomEquivalentDataProperties | DataPropertyAxiomFunctionalDataProperty | DataPropertyAxiomSubDataPropertyOf

DATA_PROPERTY_AXIOM = Name(value='dataPropertyAxiom')

DATA_PROPERTY_RANGE = Name(value='dataPropertyRange')

DISJOINT_DATA_PROPERTIES = Name(value='disjointDataProperties')

EQUIVALENT_DATA_PROPERTIES = Name(value='equivalentDataProperties')

FUNCTIONAL_DATA_PROPERTY = Name(value='functionalDataProperty')

SUB_DATA_PROPERTY_OF = Name(value='subDataPropertyOf')

TYPE_ = Name(value='hydra.owl.syntax.DataPropertyAxiom')

class hydra.owl.syntax.DataPropertyAxiomDataPropertyAxiom(value: T)

Bases: Node[DataPropertyAxiom]

class hydra.owl.syntax.DataPropertyAxiomDataPropertyRange(value: T)

Bases: Node[DataPropertyRange]

class hydra.owl.syntax.DataPropertyAxiomDisjointDataProperties(value: T)

Bases: Node[DisjointDataProperties]

class hydra.owl.syntax.DataPropertyAxiomEquivalentDataProperties(value: T)

Bases: Node[EquivalentDataProperties]

class hydra.owl.syntax.DataPropertyAxiomFunctionalDataProperty(value: T)

Bases: Node[FunctionalDataProperty]

class hydra.owl.syntax.DataPropertyAxiomSubDataPropertyOf(value: T)

Bases: Node[SubDataPropertyOf]

class hydra.owl.syntax.DataPropertyDomain(annotations: Sequence[Annotation], property: DataPropertyExpression, domain: ClassExpression)

Bases: object

An OWL axiom asserting the domain of a data property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'DataPropertyExpression' = None, _domain: 'ClassExpression' = None)

Bases: object

annotations(annotations)

build()

domain(domain)

property(property)

DOMAIN = Name(value='domain')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.DataPropertyDomain')

annotations: Sequence[Annotation]

static builder()

domain: ClassExpression

property: DataPropertyExpression

with_annotations(annotations)

with_domain(domain)

with_property(property)

class hydra.owl.syntax.DataPropertyExpression(value: T)

Bases: Node[DataProperty]

An OWL data property expression.

TYPE_ = Name(value='hydra.owl.syntax.DataPropertyExpression')

class hydra.owl.syntax.DataPropertyRange(annotations: Sequence[Annotation], property: DataPropertyExpression, range_: ClassExpression)

Bases: object

An OWL axiom asserting the range of a data property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'DataPropertyExpression' = None, _range_: 'ClassExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

range_(range_)

PROPERTY = Name(value='property')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.DataPropertyRange')

annotations: Sequence[Annotation]

static builder()

property: DataPropertyExpression

range_: ClassExpression

with_annotations(annotations)

with_property(property)

with_range_(range_)

class hydra.owl.syntax.DataRange

Bases: object

DataRangeDataComplementOf | DataRangeDataIntersectionOf | DataRangeDataOneOf | DataRangeDataUnionOf | DataRangeDatatype | DataRangeDatatypeRestriction

DATATYPE = Name(value='datatype')

DATATYPE_RESTRICTION = Name(value='datatypeRestriction')

DATA_COMPLEMENT_OF = Name(value='dataComplementOf')

DATA_INTERSECTION_OF = Name(value='dataIntersectionOf')

DATA_ONE_OF = Name(value='dataOneOf')

DATA_UNION_OF = Name(value='dataUnionOf')

TYPE_ = Name(value='hydra.owl.syntax.DataRange')

class hydra.owl.syntax.DataRangeDataComplementOf(value: T)

Bases: Node[DataComplementOf]

class hydra.owl.syntax.DataRangeDataIntersectionOf(value: T)

Bases: Node[DataIntersectionOf]

class hydra.owl.syntax.DataRangeDataOneOf(value: T)

Bases: Node[DataOneOf]

class hydra.owl.syntax.DataRangeDataUnionOf(value: T)

Bases: Node[DataUnionOf]

class hydra.owl.syntax.DataRangeDatatype(value: T)

Bases: Node[Datatype]

class hydra.owl.syntax.DataRangeDatatypeRestriction(value: T)

Bases: Node[DatatypeRestriction]

class hydra.owl.syntax.DataSomeValuesFrom(property: Sequence[DataPropertyExpression], range_: DataRange)

Bases: object

An OWL existential data property restriction.

class Builder(_property: 'Sequence[DataPropertyExpression]' = None, _range_: 'DataRange' = None)

Bases: object

build()

property(property)

range_(range_)

PROPERTY = Name(value='property')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.DataSomeValuesFrom')

static builder()

property: Sequence[DataPropertyExpression]

range_: DataRange

with_property(property)

with_range_(range_)

class hydra.owl.syntax.DataUnionOf(value: T)

Bases: Node[Sequence[DataRange]]

An OWL data range which is the union of two or more data ranges.

TYPE_ = Name(value='hydra.owl.syntax.DataUnionOf')

class hydra.owl.syntax.Datatype

Bases: object

DatatypeXmlSchema | DatatypeOther

OTHER = Name(value='other')

TYPE_ = Name(value='hydra.owl.syntax.Datatype')

XML_SCHEMA = Name(value='xmlSchema')

class hydra.owl.syntax.DatatypeDefinition(annotations: Sequence[Annotation], datatype: Datatype, range_: DataRange)

Bases: object

An OWL axiom defining a datatype in terms of a data range.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _datatype: 'Datatype' = None, _range_: 'DataRange' = None)

Bases: object

annotations(annotations)

build()

datatype(datatype)

range_(range_)

DATATYPE = Name(value='datatype')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.DatatypeDefinition')

annotations: Sequence[Annotation]

static builder()

datatype: Datatype

range_: DataRange

with_annotations(annotations)

with_datatype(datatype)

with_range_(range_)

class hydra.owl.syntax.DatatypeOther(value: T)

Bases: Node[hydra.rdf.syntax.Iri]

class hydra.owl.syntax.DatatypeRestriction(datatype: Datatype, constraints: Sequence[DatatypeRestrictionConstraint])

Bases: object

An OWL datatype restricted by one or more constraining facets.

class Builder(_datatype: 'Datatype' = None, _constraints: 'Sequence[DatatypeRestrictionConstraint]' = None)

Bases: object

build()

constraints(constraints)

datatype(datatype)

CONSTRAINTS = Name(value='constraints')

DATATYPE = Name(value='datatype')

TYPE_ = Name(value='hydra.owl.syntax.DatatypeRestriction')

static builder()

constraints: Sequence[DatatypeRestrictionConstraint]

datatype: Datatype

with_constraints(constraints)

with_datatype(datatype)

class hydra.owl.syntax.DatatypeRestrictionConstrainingFacet

Bases: object

DatatypeRestrictionConstrainingFacetXmlSchema | DatatypeRestrictionConstrainingFacetOther

OTHER = Name(value='other')

TYPE_ = Name(value='hydra.owl.syntax.DatatypeRestrictionConstrainingFacet')

XML_SCHEMA = Name(value='xmlSchema')

class hydra.owl.syntax.DatatypeRestrictionConstrainingFacetOther(value: T)

Bases: Node[hydra.rdf.syntax.Iri]

class hydra.owl.syntax.DatatypeRestrictionConstrainingFacetXmlSchema(value: T)

Bases: Node[hydra.xml.schema.ConstrainingFacet]

Note: XML Schema constraining facets are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common

class hydra.owl.syntax.DatatypeRestrictionConstraint(constraining_facet: DatatypeRestrictionConstrainingFacet, restriction_value: Literal)

Bases: object

A single constraining facet and its restriction value in an OWL datatype restriction.

class Builder(_constraining_facet: 'DatatypeRestrictionConstrainingFacet' = None, _restriction_value: 'hydra.rdf.syntax.Literal' = None)

Bases: object

build()

constraining_facet(constraining_facet)

restriction_value(restriction_value)

CONSTRAINING_FACET = Name(value='constrainingFacet')

RESTRICTION_VALUE = Name(value='restrictionValue')

TYPE_ = Name(value='hydra.owl.syntax.DatatypeRestrictionConstraint')

static builder()

constraining_facet: DatatypeRestrictionConstrainingFacet

restriction_value: Literal

with_constraining_facet(constraining_facet)

with_restriction_value(restriction_value)

class hydra.owl.syntax.DatatypeXmlSchema(value: T)

Bases: Node[hydra.xml.schema.Datatype]

Note: XML Schema datatypes are treated as a special case in this model (not in the OWL 2 specification itself) because they are particularly common

class hydra.owl.syntax.Declaration(annotations: Sequence[Annotation], entity: Entity)

Bases: object

An OWL entity declaration.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _entity: 'Entity' = None)

Bases: object

annotations(annotations)

build()

entity(entity)

ENTITY = Name(value='entity')

TYPE_ = Name(value='hydra.owl.syntax.Declaration')

annotations: Sequence[Annotation]

static builder()

entity: Entity

with_annotations(annotations)

with_entity(entity)

class hydra.owl.syntax.DifferentIndividuals(annotations: Sequence[Annotation], individuals: Sequence[Individual])

Bases: object

An OWL axiom asserting that two or more individuals are pairwise distinct.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _individuals: 'Sequence[Individual]' = None)

Bases: object

annotations(annotations)

build()

individuals(individuals)

INDIVIDUALS = Name(value='individuals')

TYPE_ = Name(value='hydra.owl.syntax.DifferentIndividuals')

annotations: Sequence[Annotation]

static builder()

individuals: Sequence[Individual]

with_annotations(annotations)

with_individuals(individuals)

class hydra.owl.syntax.DisjointClasses(annotations: Sequence[Annotation], classes: Sequence[ClassExpression])

Bases: object

An OWL axiom asserting that two or more classes are pairwise disjoint.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _classes: 'Sequence[ClassExpression]' = None)

Bases: object

annotations(annotations)

build()

classes(classes)

CLASSES = Name(value='classes')

TYPE_ = Name(value='hydra.owl.syntax.DisjointClasses')

annotations: Sequence[Annotation]

static builder()

classes: Sequence[ClassExpression]

with_annotations(annotations)

with_classes(classes)

class hydra.owl.syntax.DisjointDataProperties(annotations: Sequence[Annotation], properties: Sequence[DataPropertyExpression])

Bases: object

An OWL axiom asserting that two or more data properties are pairwise disjoint.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _properties: 'Sequence[DataPropertyExpression]' = None)

Bases: object

annotations(annotations)

build()

properties(properties)

PROPERTIES = Name(value='properties')

TYPE_ = Name(value='hydra.owl.syntax.DisjointDataProperties')

annotations: Sequence[Annotation]

static builder()

properties: Sequence[DataPropertyExpression]

with_annotations(annotations)

with_properties(properties)

class hydra.owl.syntax.DisjointObjectProperties(annotations: Sequence[Annotation], properties: Sequence[ObjectPropertyExpression])

Bases: object

An OWL axiom asserting that two or more object properties are pairwise disjoint.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _properties: 'Sequence[ObjectPropertyExpression]' = None)

Bases: object

annotations(annotations)

build()

properties(properties)

PROPERTIES = Name(value='properties')

TYPE_ = Name(value='hydra.owl.syntax.DisjointObjectProperties')

annotations: Sequence[Annotation]

static builder()

properties: Sequence[ObjectPropertyExpression]

with_annotations(annotations)

with_properties(properties)

class hydra.owl.syntax.DisjointUnion(annotations: Sequence[Annotation], class_: Class, classes: Sequence[ClassExpression])

Bases: object

An OWL axiom asserting that a class is the disjoint union of other class expressions.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _class_: 'Class' = None, _classes: 'Sequence[ClassExpression]' = None)

Bases: object

annotations(annotations)

build()

class_(class_)

classes(classes)

CLASS = Name(value='class')

CLASSES = Name(value='classes')

TYPE_ = Name(value='hydra.owl.syntax.DisjointUnion')

annotations: Sequence[Annotation]

static builder()

class_: Class

classes: Sequence[ClassExpression]

with_annotations(annotations)

with_class_(class_)

with_classes(classes)

class hydra.owl.syntax.Entity

Bases: object

EntityAnnotationProperty | EntityClass | EntityDataProperty | EntityDatatype | EntityNamedIndividual | EntityObjectProperty

ANNOTATION_PROPERTY = Name(value='annotationProperty')

CLASS = Name(value='class')

DATATYPE = Name(value='datatype')

DATA_PROPERTY = Name(value='dataProperty')

NAMED_INDIVIDUAL = Name(value='namedIndividual')

OBJECT_PROPERTY = Name(value='objectProperty')

TYPE_ = Name(value='hydra.owl.syntax.Entity')

class hydra.owl.syntax.EntityAnnotationProperty(value: T)

Bases: Node[AnnotationProperty]

class hydra.owl.syntax.EntityClass(value: T)

Bases: Node[Class]

class hydra.owl.syntax.EntityDataProperty(value: T)

Bases: Node[DataProperty]

class hydra.owl.syntax.EntityDatatype(value: T)

Bases: Node[Datatype]

class hydra.owl.syntax.EntityNamedIndividual(value: T)

Bases: Node[NamedIndividual]

class hydra.owl.syntax.EntityObjectProperty(value: T)

Bases: Node[ObjectProperty]

class hydra.owl.syntax.EquivalentClasses(annotations: Sequence[Annotation], classes: Sequence[ClassExpression])

Bases: object

An OWL axiom asserting that two or more classes are equivalent.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _classes: 'Sequence[ClassExpression]' = None)

Bases: object

annotations(annotations)

build()

classes(classes)

CLASSES = Name(value='classes')

TYPE_ = Name(value='hydra.owl.syntax.EquivalentClasses')

annotations: Sequence[Annotation]

static builder()

classes: Sequence[ClassExpression]

with_annotations(annotations)

with_classes(classes)

class hydra.owl.syntax.EquivalentDataProperties(annotations: Sequence[Annotation], properties: Sequence[DataPropertyExpression])

Bases: object

An OWL axiom asserting that two or more data properties are equivalent.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _properties: 'Sequence[DataPropertyExpression]' = None)

Bases: object

annotations(annotations)

build()

properties(properties)

PROPERTIES = Name(value='properties')

TYPE_ = Name(value='hydra.owl.syntax.EquivalentDataProperties')

annotations: Sequence[Annotation]

static builder()

properties: Sequence[DataPropertyExpression]

with_annotations(annotations)

with_properties(properties)

class hydra.owl.syntax.EquivalentObjectProperties(annotations: Sequence[Annotation], properties: Sequence[ObjectPropertyExpression])

Bases: object

An OWL axiom asserting that two or more object properties are equivalent.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _properties: 'Sequence[ObjectPropertyExpression]' = None)

Bases: object

annotations(annotations)

build()

properties(properties)

PROPERTIES = Name(value='properties')

TYPE_ = Name(value='hydra.owl.syntax.EquivalentObjectProperties')

annotations: Sequence[Annotation]

static builder()

properties: Sequence[ObjectPropertyExpression]

with_annotations(annotations)

with_properties(properties)

class hydra.owl.syntax.FunctionalDataProperty(annotations: Sequence[Annotation], property: DataPropertyExpression)

Bases: object

An OWL axiom asserting that a data property is functional.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'DataPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.FunctionalDataProperty')

annotations: Sequence[Annotation]

static builder()

property: DataPropertyExpression

with_annotations(annotations)

with_property(property)

class hydra.owl.syntax.FunctionalObjectProperty(annotations: Sequence[Annotation], property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.FunctionalObjectProperty')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

with_annotations(annotations)

with_property(property)

class hydra.owl.syntax.HasKey(annotations: Sequence[Annotation], class_: ClassExpression, object_properties: Sequence[ObjectPropertyExpression], data_properties: Sequence[DataPropertyExpression])

Bases: object

An OWL axiom asserting that a set of properties functions as a key for a class.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _class_: 'ClassExpression' = None, _object_properties: 'Sequence[ObjectPropertyExpression]' = None, _data_properties: 'Sequence[DataPropertyExpression]' = None)

Bases: object

annotations(annotations)

build()

class_(class_)

data_properties(data_properties)

object_properties(object_properties)

CLASS = Name(value='class')

DATA_PROPERTIES = Name(value='dataProperties')

OBJECT_PROPERTIES = Name(value='objectProperties')

TYPE_ = Name(value='hydra.owl.syntax.HasKey')

annotations: Sequence[Annotation]

static builder()

class_: ClassExpression

data_properties: Sequence[DataPropertyExpression]

object_properties: Sequence[ObjectPropertyExpression]

with_annotations(annotations)

with_class_(class_)

with_data_properties(data_properties)

with_object_properties(object_properties)

class hydra.owl.syntax.Individual

Bases: object

IndividualNamed | IndividualAnonymous

ANONYMOUS = Name(value='anonymous')

NAMED = Name(value='named')

TYPE_ = Name(value='hydra.owl.syntax.Individual')

class hydra.owl.syntax.IndividualAnonymous(value: T)

Bases: Node[AnonymousIndividual]

class hydra.owl.syntax.IndividualNamed(value: T)

Bases: Node[NamedIndividual]

class hydra.owl.syntax.InverseFunctionalObjectProperty(annotations: Sequence[Annotation], property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.InverseFunctionalObjectProperty')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

with_annotations(annotations)

with_property(property)

class hydra.owl.syntax.InverseObjectProperties(annotations: Sequence[Annotation], property1: ObjectPropertyExpression, property2: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting that two object properties are inverses of each other.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property1: 'ObjectPropertyExpression' = None, _property2: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property1(property1)

property2(property2)

PROPERTY1 = Name(value='property1')

PROPERTY2 = Name(value='property2')

TYPE_ = Name(value='hydra.owl.syntax.InverseObjectProperties')

annotations: Sequence[Annotation]

static builder()

property1: ObjectPropertyExpression

property2: ObjectPropertyExpression

with_annotations(annotations)

with_property1(property1)

with_property2(property2)

class hydra.owl.syntax.InverseObjectProperty(value: T)

Bases: Node[ObjectProperty]

The inverse of an OWL object property.

TYPE_ = Name(value='hydra.owl.syntax.InverseObjectProperty')

class hydra.owl.syntax.IrreflexiveObjectProperty(annotations: Sequence[Annotation], property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.IrreflexiveObjectProperty')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

with_annotations(annotations)

with_property(property)

class hydra.owl.syntax.NamedIndividual(value: T)

Bases: Node[None]

An OWL named individual, identified by an IRI.

TYPE_ = Name(value='hydra.owl.syntax.NamedIndividual')

class hydra.owl.syntax.NegativeDataPropertyAssertion(annotations: Sequence[Annotation], property: DataPropertyExpression, source: Individual, target: Individual)

Bases: object

An OWL axiom asserting that a data property relationship does NOT hold.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'DataPropertyExpression' = None, _source: 'Individual' = None, _target: 'Individual' = None)

Bases: object

annotations(annotations)

build()

property(property)

source(source)

target(target)

PROPERTY = Name(value='property')

SOURCE = Name(value='source')

TARGET = Name(value='target')

TYPE_ = Name(value='hydra.owl.syntax.NegativeDataPropertyAssertion')

annotations: Sequence[Annotation]

static builder()

property: DataPropertyExpression

source: Individual

target: Individual

with_annotations(annotations)

with_property(property)

with_source(source)

with_target(target)

class hydra.owl.syntax.NegativeObjectPropertyAssertion(annotations: Sequence[Annotation], property: ObjectPropertyExpression, source: Individual, target: Individual)

Bases: object

An OWL axiom asserting that an object property relationship does NOT hold.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None, _source: 'Individual' = None, _target: 'Individual' = None)

Bases: object

annotations(annotations)

build()

property(property)

source(source)

target(target)

PROPERTY = Name(value='property')

SOURCE = Name(value='source')

TARGET = Name(value='target')

TYPE_ = Name(value='hydra.owl.syntax.NegativeObjectPropertyAssertion')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

source: Individual

target: Individual

with_annotations(annotations)

with_property(property)

with_source(source)

with_target(target)

class hydra.owl.syntax.ObjectAllValuesFrom(property: ObjectPropertyExpression, class_: ClassExpression)

Bases: object

An OWL universal object property restriction.

class Builder(_property: 'ObjectPropertyExpression' = None, _class_: 'ClassExpression' = None)

Bases: object

build()

class_(class_)

property(property)

CLASS = Name(value='class')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ObjectAllValuesFrom')

static builder()

class_: ClassExpression

property: ObjectPropertyExpression

with_class_(class_)

with_property(property)

class hydra.owl.syntax.ObjectComplementOf(value: T)

Bases: Node[ClassExpression]

An OWL class expression which is the complement of another class expression.

TYPE_ = Name(value='hydra.owl.syntax.ObjectComplementOf')

class hydra.owl.syntax.ObjectExactCardinality(bound: int, property: ObjectPropertyExpression, class_: Sequence[ClassExpression])

Bases: object

An OWL exact-cardinality restriction on an object property.

BOUND = Name(value='bound')

class Builder(_bound: 'int' = None, _property: 'ObjectPropertyExpression' = None, _class_: 'Sequence[ClassExpression]' = None)

Bases: object

bound(bound)

build()

class_(class_)

property(property)

CLASS = Name(value='class')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ObjectExactCardinality')

bound: int

static builder()

class_: Sequence[ClassExpression]

property: ObjectPropertyExpression

with_bound(bound)

with_class_(class_)

with_property(property)

class hydra.owl.syntax.ObjectHasSelf(value: T)

Bases: Node[ObjectPropertyExpression]

An OWL class expression restricting an object property to self-relationships.

TYPE_ = Name(value='hydra.owl.syntax.ObjectHasSelf')

class hydra.owl.syntax.ObjectHasValue(property: ObjectPropertyExpression, individual: Individual)

Bases: object

An OWL object property restriction requiring a specific individual value.

class Builder(_property: 'ObjectPropertyExpression' = None, _individual: 'Individual' = None)

Bases: object

build()

individual(individual)

property(property)

INDIVIDUAL = Name(value='individual')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ObjectHasValue')

static builder()

individual: Individual

property: ObjectPropertyExpression

with_individual(individual)

with_property(property)

class hydra.owl.syntax.ObjectIntersectionOf(value: T)

Bases: Node[Sequence[ClassExpression]]

An OWL class expression which is the intersection of two or more class expressions.

TYPE_ = Name(value='hydra.owl.syntax.ObjectIntersectionOf')

class hydra.owl.syntax.ObjectMaxCardinality(bound: int, property: ObjectPropertyExpression, class_: Sequence[ClassExpression])

Bases: object

An OWL maximum-cardinality restriction on an object property.

BOUND = Name(value='bound')

class Builder(_bound: 'int' = None, _property: 'ObjectPropertyExpression' = None, _class_: 'Sequence[ClassExpression]' = None)

Bases: object

bound(bound)

build()

class_(class_)

property(property)

CLASS = Name(value='class')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ObjectMaxCardinality')

bound: int

static builder()

class_: Sequence[ClassExpression]

property: ObjectPropertyExpression

with_bound(bound)

with_class_(class_)

with_property(property)

class hydra.owl.syntax.ObjectMinCardinality(bound: int, property: ObjectPropertyExpression, class_: Sequence[ClassExpression])

Bases: object

An OWL minimum-cardinality restriction on an object property.

BOUND = Name(value='bound')

class Builder(_bound: 'int' = None, _property: 'ObjectPropertyExpression' = None, _class_: 'Sequence[ClassExpression]' = None)

Bases: object

bound(bound)

build()

class_(class_)

property(property)

CLASS = Name(value='class')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ObjectMinCardinality')

bound: int

static builder()

class_: Sequence[ClassExpression]

property: ObjectPropertyExpression

with_bound(bound)

with_class_(class_)

with_property(property)

class hydra.owl.syntax.ObjectOneOf(value: T)

Bases: Node[Sequence[Individual]]

An OWL class expression enumerating one or more individuals.

TYPE_ = Name(value='hydra.owl.syntax.ObjectOneOf')

class hydra.owl.syntax.ObjectProperty(value: T)

Bases: Node[None]

An OWL object property, identified by an IRI.

TYPE_ = Name(value='hydra.owl.syntax.ObjectProperty')

class hydra.owl.syntax.ObjectPropertyAssertion(annotations: Sequence[Annotation], property: ObjectPropertyExpression, source: Individual, target: Individual)

Bases: object

An OWL axiom asserting an object property relationship between two individuals.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None, _source: 'Individual' = None, _target: 'Individual' = None)

Bases: object

annotations(annotations)

build()

property(property)

source(source)

target(target)

PROPERTY = Name(value='property')

SOURCE = Name(value='source')

TARGET = Name(value='target')

TYPE_ = Name(value='hydra.owl.syntax.ObjectPropertyAssertion')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

source: Individual

target: Individual

with_annotations(annotations)

with_property(property)

with_source(source)

with_target(target)

class hydra.owl.syntax.ObjectPropertyAxiom

Bases: object

ObjectPropertyAxiomAsymmetricObjectProperty | ObjectPropertyAxiomDisjointObjectProperties | ObjectPropertyAxiomEquivalentObjectProperties | ObjectPropertyAxiomFunctionalObjectProperty | ObjectPropertyAxiomInverseFunctionalObjectProperty | ObjectPropertyAxiomInverseObjectProperties | ObjectPropertyAxiomIrreflexiveObjectProperty | ObjectPropertyAxiomObjectPropertyDomain | ObjectPropertyAxiomObjectPropertyRange | ObjectPropertyAxiomReflexiveObjectProperty | ObjectPropertyAxiomSubObjectPropertyOf | ObjectPropertyAxiomSymmetricObjectProperty | ObjectPropertyAxiomTransitiveObjectProperty

ASYMMETRIC_OBJECT_PROPERTY = Name(value='asymmetricObjectProperty')

DISJOINT_OBJECT_PROPERTIES = Name(value='disjointObjectProperties')

EQUIVALENT_OBJECT_PROPERTIES = Name(value='equivalentObjectProperties')

FUNCTIONAL_OBJECT_PROPERTY = Name(value='functionalObjectProperty')

INVERSE_FUNCTIONAL_OBJECT_PROPERTY = Name(value='inverseFunctionalObjectProperty')

INVERSE_OBJECT_PROPERTIES = Name(value='inverseObjectProperties')

IRREFLEXIVE_OBJECT_PROPERTY = Name(value='irreflexiveObjectProperty')

OBJECT_PROPERTY_DOMAIN = Name(value='objectPropertyDomain')

OBJECT_PROPERTY_RANGE = Name(value='objectPropertyRange')

REFLEXIVE_OBJECT_PROPERTY = Name(value='reflexiveObjectProperty')

SUB_OBJECT_PROPERTY_OF = Name(value='subObjectPropertyOf')

SYMMETRIC_OBJECT_PROPERTY = Name(value='symmetricObjectProperty')

TRANSITIVE_OBJECT_PROPERTY = Name(value='transitiveObjectProperty')

TYPE_ = Name(value='hydra.owl.syntax.ObjectPropertyAxiom')

class hydra.owl.syntax.ObjectPropertyAxiomAsymmetricObjectProperty(value: T)

Bases: Node[AsymmetricObjectProperty]

class hydra.owl.syntax.ObjectPropertyAxiomDisjointObjectProperties(value: T)

Bases: Node[DisjointObjectProperties]

class hydra.owl.syntax.ObjectPropertyAxiomEquivalentObjectProperties(value: T)

Bases: Node[EquivalentObjectProperties]

class hydra.owl.syntax.ObjectPropertyAxiomFunctionalObjectProperty(value: T)

Bases: Node[FunctionalObjectProperty]

class hydra.owl.syntax.ObjectPropertyAxiomInverseFunctionalObjectProperty(value: T)

Bases: Node[InverseFunctionalObjectProperty]

class hydra.owl.syntax.ObjectPropertyAxiomInverseObjectProperties(value: T)

Bases: Node[InverseObjectProperties]

class hydra.owl.syntax.ObjectPropertyAxiomIrreflexiveObjectProperty(value: T)

Bases: Node[IrreflexiveObjectProperty]

class hydra.owl.syntax.ObjectPropertyAxiomObjectPropertyDomain(value: T)

Bases: Node[ObjectPropertyDomain]

class hydra.owl.syntax.ObjectPropertyAxiomObjectPropertyRange(value: T)

Bases: Node[ObjectPropertyRange]

class hydra.owl.syntax.ObjectPropertyAxiomReflexiveObjectProperty(value: T)

Bases: Node[ReflexiveObjectProperty]

class hydra.owl.syntax.ObjectPropertyAxiomSubObjectPropertyOf(value: T)

Bases: Node[SubObjectPropertyOf]

class hydra.owl.syntax.ObjectPropertyAxiomSymmetricObjectProperty(value: T)

Bases: Node[SymmetricObjectProperty]

class hydra.owl.syntax.ObjectPropertyAxiomTransitiveObjectProperty(value: T)

Bases: Node[TransitiveObjectProperty]

class hydra.owl.syntax.ObjectPropertyDomain(annotations: Sequence[Annotation], property: ObjectPropertyExpression, domain: ClassExpression)

Bases: object

An OWL axiom asserting the domain of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None, _domain: 'ClassExpression' = None)

Bases: object

annotations(annotations)

build()

domain(domain)

property(property)

DOMAIN = Name(value='domain')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ObjectPropertyDomain')

annotations: Sequence[Annotation]

static builder()

domain: ClassExpression

property: ObjectPropertyExpression

with_annotations(annotations)

with_domain(domain)

with_property(property)

class hydra.owl.syntax.ObjectPropertyExpression

Bases: object

ObjectPropertyExpressionObject | ObjectPropertyExpressionInverseObject

INVERSE_OBJECT = Name(value='inverseObject')

OBJECT = Name(value='object')

TYPE_ = Name(value='hydra.owl.syntax.ObjectPropertyExpression')

class hydra.owl.syntax.ObjectPropertyExpressionInverseObject(value: T)

Bases: Node[InverseObjectProperty]

class hydra.owl.syntax.ObjectPropertyExpressionObject(value: T)

Bases: Node[ObjectProperty]

class hydra.owl.syntax.ObjectPropertyRange(annotations: Sequence[Annotation], property: ObjectPropertyExpression, range_: ClassExpression)

Bases: object

An OWL axiom asserting the range of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None, _range_: 'ClassExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

range_(range_)

PROPERTY = Name(value='property')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.owl.syntax.ObjectPropertyRange')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

range_: ClassExpression

with_annotations(annotations)

with_property(property)

with_range_(range_)

class hydra.owl.syntax.ObjectSomeValuesFrom(property: ObjectPropertyExpression, class_: ClassExpression)

Bases: object

An OWL existential object property restriction.

class Builder(_property: 'ObjectPropertyExpression' = None, _class_: 'ClassExpression' = None)

Bases: object

build()

class_(class_)

property(property)

CLASS = Name(value='class')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ObjectSomeValuesFrom')

static builder()

class_: ClassExpression

property: ObjectPropertyExpression

with_class_(class_)

with_property(property)

class hydra.owl.syntax.ObjectUnionOf(value: T)

Bases: Node[Sequence[ClassExpression]]

An OWL class expression which is the union of two or more class expressions.

TYPE_ = Name(value='hydra.owl.syntax.ObjectUnionOf')

class hydra.owl.syntax.Ontology(direct_imports: Sequence[Ontology], annotations: Sequence[Annotation], axioms: Sequence[Axiom])

Bases: object

An OWL ontology: a set of imports, annotations, and axioms.

ANNOTATIONS = Name(value='annotations')

AXIOMS = Name(value='axioms')

class Builder(_direct_imports: 'Sequence[Ontology]' = None, _annotations: 'Sequence[Annotation]' = None, _axioms: 'Sequence[Axiom]' = None)

Bases: object

annotations(annotations)

axioms(axioms)

build()

direct_imports(direct_imports)

DIRECT_IMPORTS = Name(value='directImports')

TYPE_ = Name(value='hydra.owl.syntax.Ontology')

annotations: Sequence[Annotation]

axioms: Sequence[Axiom]

static builder()

direct_imports: Sequence[Ontology]

with_annotations(annotations)

with_axioms(axioms)

with_direct_imports(direct_imports)

class hydra.owl.syntax.ReflexiveObjectProperty(annotations: Sequence[Annotation], property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.ReflexiveObjectProperty')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

with_annotations(annotations)

with_property(property)

class hydra.owl.syntax.SameIndividual(annotations: Sequence[Annotation], individuals: Sequence[Individual])

Bases: object

An OWL axiom asserting that two or more individuals are the same.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _individuals: 'Sequence[Individual]' = None)

Bases: object

annotations(annotations)

build()

individuals(individuals)

INDIVIDUALS = Name(value='individuals')

TYPE_ = Name(value='hydra.owl.syntax.SameIndividual')

annotations: Sequence[Annotation]

static builder()

individuals: Sequence[Individual]

with_annotations(annotations)

with_individuals(individuals)

class hydra.owl.syntax.SubAnnotationPropertyOf(annotations: Sequence[Annotation], sub_property: AnnotationProperty, super_property: AnnotationProperty)

Bases: object

An OWL axiom asserting an annotation-property subsumption relationship.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _sub_property: 'AnnotationProperty' = None, _super_property: 'AnnotationProperty' = None)

Bases: object

annotations(annotations)

build()

sub_property(sub_property)

super_property(super_property)

SUB_PROPERTY = Name(value='subProperty')

SUPER_PROPERTY = Name(value='superProperty')

TYPE_ = Name(value='hydra.owl.syntax.SubAnnotationPropertyOf')

annotations: Sequence[Annotation]

static builder()

sub_property: AnnotationProperty

super_property: AnnotationProperty

with_annotations(annotations)

with_sub_property(sub_property)

with_super_property(super_property)

class hydra.owl.syntax.SubClassOf(annotations: Sequence[Annotation], sub_class: ClassExpression, super_class: ClassExpression)

Bases: object

An OWL axiom asserting a subclass relationship.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _sub_class: 'ClassExpression' = None, _super_class: 'ClassExpression' = None)

Bases: object

annotations(annotations)

build()

sub_class(sub_class)

super_class(super_class)

SUB_CLASS = Name(value='subClass')

SUPER_CLASS = Name(value='superClass')

TYPE_ = Name(value='hydra.owl.syntax.SubClassOf')

annotations: Sequence[Annotation]

static builder()

sub_class: ClassExpression

super_class: ClassExpression

with_annotations(annotations)

with_sub_class(sub_class)

with_super_class(super_class)

class hydra.owl.syntax.SubDataPropertyOf(annotations: Sequence[Annotation], sub_property: DataPropertyExpression, super_property: DataPropertyExpression)

Bases: object

An OWL axiom asserting a data-property subsumption relationship.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _sub_property: 'DataPropertyExpression' = None, _super_property: 'DataPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

sub_property(sub_property)

super_property(super_property)

SUB_PROPERTY = Name(value='subProperty')

SUPER_PROPERTY = Name(value='superProperty')

TYPE_ = Name(value='hydra.owl.syntax.SubDataPropertyOf')

annotations: Sequence[Annotation]

static builder()

sub_property: DataPropertyExpression

super_property: DataPropertyExpression

with_annotations(annotations)

with_sub_property(sub_property)

with_super_property(super_property)

class hydra.owl.syntax.SubObjectPropertyOf(annotations: Sequence[Annotation], sub_property: Sequence[ObjectPropertyExpression], super_property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting an object-property subsumption relationship.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _sub_property: 'Sequence[ObjectPropertyExpression]' = None, _super_property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

sub_property(sub_property)

super_property(super_property)

SUB_PROPERTY = Name(value='subProperty')

SUPER_PROPERTY = Name(value='superProperty')

TYPE_ = Name(value='hydra.owl.syntax.SubObjectPropertyOf')

annotations: Sequence[Annotation]

static builder()

sub_property: Sequence[ObjectPropertyExpression]

super_property: ObjectPropertyExpression

with_annotations(annotations)

with_sub_property(sub_property)

with_super_property(super_property)

class hydra.owl.syntax.SymmetricObjectProperty(annotations: Sequence[Annotation], property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.SymmetricObjectProperty')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

with_annotations(annotations)

with_property(property)

class hydra.owl.syntax.TransitiveObjectProperty(annotations: Sequence[Annotation], property: ObjectPropertyExpression)

Bases: object

An OWL axiom asserting a characteristic (e.g. symmetric, transitive) of an object property.

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _property: 'ObjectPropertyExpression' = None)

Bases: object

annotations(annotations)

build()

property(property)

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.owl.syntax.TransitiveObjectProperty')

annotations: Sequence[Annotation]

static builder()

property: ObjectPropertyExpression

with_annotations(annotations)

with_property(property)