hydra.shex.syntax module

A Shex model. Based on the BNF at: https://github.com/shexSpec/grammar/blob/master/bnf.

class hydra.shex.syntax.Annotation(predicate: Predicate, alts: AnnotationAlts)

Bases: object

ShEx grammar production: Annotation ::= ‘//’ Predicate (Iri | Literal).

ALTS = Name(value='alts')

class Builder(_predicate: 'Predicate' = None, _alts: 'AnnotationAlts' = None)

Bases: object

alts(alts)

build()

predicate(predicate)

PREDICATE = Name(value='Predicate')

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

alts: AnnotationAlts

static builder()

predicate: Predicate

with_alts(alts)

with_predicate(predicate)

class hydra.shex.syntax.AnnotationAlts

Bases: object

AnnotationAltsIri | AnnotationAltsLiteral

IRI = Name(value='Iri')

LITERAL = Name(value='Literal')

TYPE_ = Name(value='hydra.shex.syntax.AnnotationAlts')

class hydra.shex.syntax.AnnotationAltsIri(value: T)

Bases: Node[Iri]

class hydra.shex.syntax.AnnotationAltsLiteral(value: T)

Bases: Node[Literal]

class hydra.shex.syntax.AtpNameLn(pname_ns: PnameNs, pn_local: PnLocal)

Bases: object

ShEx grammar production: AtpNameLn ::= ‘@’ PnameNs PnLocal.

class Builder(_pname_ns: 'PnameNs' = None, _pn_local: 'PnLocal' = None)

Bases: object

build()

pn_local(pn_local)

pname_ns(pname_ns)

PNAME_NS = Name(value='PnameNs')

PN_LOCAL = Name(value='PnLocal')

TYPE_ = Name(value='hydra.shex.syntax.AtpNameLn')

static builder()

pn_local: PnLocal

pname_ns: PnameNs

with_pn_local(pn_local)

with_pname_ns(pname_ns)

class hydra.shex.syntax.AtpNameNs(value: T)

Bases: Node[Optional[PnPrefix]]

ShEx grammar production: AtpNameNs ::= ‘@’ PnPrefix? ‘:’.

TYPE_ = Name(value='hydra.shex.syntax.AtpNameNs')

class hydra.shex.syntax.BaseDecl(value: T)

Bases: Node[IriRef]

ShEx grammar production: BaseDecl ::= ‘BASE’ IriRef.

TYPE_ = Name(value='hydra.shex.syntax.BaseDecl')

class hydra.shex.syntax.BlankNode(value: T)

Bases: Node[BlankNodeLabel]

ShEx grammar production: BlankNode ::= BlankNodeLabel.

TYPE_ = Name(value='hydra.shex.syntax.BlankNode')

class hydra.shex.syntax.BlankNodeLabel(alts: BlankNodeLabelAlts, list_of_alts: object, pn_chars: PnChars)

Bases: object

A component of the ShEx BlankNodeLabel production.

ALTS = Name(value='alts')

class Builder(_alts: 'BlankNodeLabelAlts' = None, _list_of_alts: 'Optional[Sequence[BlankNodeLabelListOfAltsOptionElmt]]' = None, _pn_chars: 'PnChars' = None)

Bases: object

alts(alts)

build()

list_of_alts(list_of_alts)

pn_chars(pn_chars)

LIST_OF_ALTS = Name(value='ListOfAlts')

PN_CHARS = Name(value='PnChars')

TYPE_ = Name(value='hydra.shex.syntax.BlankNodeLabel')

alts: BlankNodeLabelAlts

static builder()

list_of_alts: object

pn_chars: PnChars

with_alts(alts)

with_list_of_alts(list_of_alts)

with_pn_chars(pn_chars)

class hydra.shex.syntax.BlankNodeLabelAlts

Bases: object

BlankNodeLabelAltsPnCharsU | BlankNodeLabelAltsRegex

PN_CHARS_U = Name(value='PnCharsU')

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.BlankNodeLabelAlts')

class hydra.shex.syntax.BlankNodeLabelAltsPnCharsU(value: T)

Bases: Node[PnCharsU]

class hydra.shex.syntax.BlankNodeLabelAltsRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.BlankNodeLabelListOfAltsOptionElmt

Bases: object

BlankNodeLabelListOfAltsOptionElmtPnChars | BlankNodeLabelListOfAltsOptionElmtPeriod

PERIOD = Name(value='Period')

PN_CHARS = Name(value='PnChars')

TYPE_ = Name(value='hydra.shex.syntax.BlankNodeLabelListOfAltsOptionElmt')

class hydra.shex.syntax.BlankNodeLabelListOfAltsOptionElmtPeriod

Bases: object

class hydra.shex.syntax.BlankNodeLabelListOfAltsOptionElmtPnChars(value: T)

Bases: Node[PnChars]

class hydra.shex.syntax.BooleanLiteral(*values)

Bases: Enum

ShEx grammar production: BooleanLiteral ::= ‘true’ | ‘false’.

FALSE = Name(value='False')

TRUE = Name(value='True')

TYPE_ = Name(value='hydra.shex.syntax.BooleanLiteral')

class hydra.shex.syntax.BracketedTripleExpr(inner_triple_expr: InnerTripleExpr, cardinality: object, list_of_annotation: Sequence[Annotation], semantic_actions: SemanticActions)

Bases: object

A component of the ShEx BracketedTripleExpr production.

class Builder(_inner_triple_expr: 'InnerTripleExpr' = None, _cardinality: 'Optional[Cardinality]' = None, _list_of_annotation: 'Sequence[Annotation]' = None, _semantic_actions: 'SemanticActions' = None)

Bases: object

build()

cardinality(cardinality)

inner_triple_expr(inner_triple_expr)

list_of_annotation(list_of_annotation)

semantic_actions(semantic_actions)

CARDINALITY = Name(value='Cardinality')

INNER_TRIPLE_EXPR = Name(value='InnerTripleExpr')

LIST_OF_ANNOTATION = Name(value='listOfAnnotation')

SEMANTIC_ACTIONS = Name(value='SemanticActions')

TYPE_ = Name(value='hydra.shex.syntax.BracketedTripleExpr')

static builder()

cardinality: object

inner_triple_expr: InnerTripleExpr

list_of_annotation: Sequence[Annotation]

semantic_actions: SemanticActions

with_cardinality(cardinality)

with_inner_triple_expr(inner_triple_expr)

with_list_of_annotation(list_of_annotation)

with_semantic_actions(semantic_actions)

class hydra.shex.syntax.Cardinality

Bases: object

CardinalityAst | CardinalityPlus | CardinalityQuest | CardinalityRepeatRange

AST = Name(value='Ast')

PLUS = Name(value='Plus')

QUEST = Name(value='Quest')

REPEAT_RANGE = Name(value='RepeatRange')

TYPE_ = Name(value='hydra.shex.syntax.Cardinality')

class hydra.shex.syntax.CardinalityAst

Bases: object

class hydra.shex.syntax.CardinalityPlus

Bases: object

class hydra.shex.syntax.CardinalityQuest

Bases: object

class hydra.shex.syntax.CardinalityRepeatRange(value: T)

Bases: Node[RepeatRange]

class hydra.shex.syntax.Code(value: T)

Bases: Node[Sequence[CodeElmt]]

A component of the ShEx Code production.

TYPE_ = Name(value='hydra.shex.syntax.Code')

class hydra.shex.syntax.CodeDecl(iri: Iri, alts: CodeDeclAlts)

Bases: object

ShEx grammar production: CodeDecl ::= ‘%’ Iri (Code | ‘%’).

ALTS = Name(value='alts')

class Builder(_iri: 'Iri' = None, _alts: 'CodeDeclAlts' = None)

Bases: object

alts(alts)

build()

iri(iri)

IRI = Name(value='Iri')

TYPE_ = Name(value='hydra.shex.syntax.CodeDecl')

alts: CodeDeclAlts

static builder()

iri: Iri

with_alts(alts)

with_iri(iri)

class hydra.shex.syntax.CodeDeclAlts

Bases: object

CodeDeclAltsCode | CodeDeclAltsPercnt

CODE = Name(value='Code')

PERCNT = Name(value='Percnt')

TYPE_ = Name(value='hydra.shex.syntax.CodeDeclAlts')

class hydra.shex.syntax.CodeDeclAltsCode(value: T)

Bases: Node[Code]

class hydra.shex.syntax.CodeDeclAltsPercnt

Bases: object

class hydra.shex.syntax.CodeElmt

Bases: object

CodeElmtRegex | CodeElmtSequence | CodeElmtUchar

REGEX = Name(value='regex')

SEQUENCE = Name(value='sequence')

TYPE_ = Name(value='hydra.shex.syntax.CodeElmt')

UCHAR = Name(value='Uchar')

class hydra.shex.syntax.CodeElmtRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.CodeElmtSequence(value: T)

Bases: Node[str]

class hydra.shex.syntax.CodeElmtUchar(value: T)

Bases: Node[Uchar]

class hydra.shex.syntax.Datatype(value: T)

Bases: Node[Iri]

ShEx grammar production: Datatype ::= Iri.

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

class hydra.shex.syntax.Decimal(value: T)

Bases: Node[str]

A component of the ShEx Decimal production.

TYPE_ = Name(value='hydra.shex.syntax.Decimal')

class hydra.shex.syntax.Directive

Bases: object

DirectiveBaseDecl | DirectivePrefixDecl

BASE_DECL = Name(value='BaseDecl')

PREFIX_DECL = Name(value='PrefixDecl')

TYPE_ = Name(value='hydra.shex.syntax.Directive')

class hydra.shex.syntax.DirectiveBaseDecl(value: T)

Bases: Node[BaseDecl]

class hydra.shex.syntax.DirectivePrefixDecl(value: T)

Bases: Node[PrefixDecl]

class hydra.shex.syntax.Double(value: T)

Bases: Node[str]

A component of the ShEx Double production.

TYPE_ = Name(value='hydra.shex.syntax.Double')

class hydra.shex.syntax.Echar(value: T)

Bases: Node[str]

ShEx grammar production: Echar ::= ‘' [tbnrf'’].

TYPE_ = Name(value='hydra.shex.syntax.Echar')

class hydra.shex.syntax.Exclusion(value: T)

Bases: Node[Iri]

ShEx grammar production: Exclusion ::= ‘-’ Iri ‘~’?.

TYPE_ = Name(value='hydra.shex.syntax.Exclusion')

class hydra.shex.syntax.ExtraPropertySet(value: T)

Bases: Node[Sequence[Predicate]]

ShEx grammar production: ExtraPropertySet ::= ‘EXTRA’ Predicate+.

TYPE_ = Name(value='hydra.shex.syntax.ExtraPropertySet')

class hydra.shex.syntax.GroupTripleExpr

Bases: object

GroupTripleExprSingleElementGroup | GroupTripleExprMultiElementGroup

MULTI_ELEMENT_GROUP = Name(value='MultiElementGroup')

SINGLE_ELEMENT_GROUP = Name(value='SingleElementGroup')

TYPE_ = Name(value='hydra.shex.syntax.GroupTripleExpr')

class hydra.shex.syntax.GroupTripleExprMultiElementGroup(value: T)

Bases: Node[MultiElementGroup]

class hydra.shex.syntax.GroupTripleExprSingleElementGroup(value: T)

Bases: Node[SingleElementGroup]

class hydra.shex.syntax.Hex(value: T)

Bases: Node[str]

ShEx grammar production: Hex ::= [0-9] | [A-F] | [a-f].

TYPE_ = Name(value='hydra.shex.syntax.Hex')

class hydra.shex.syntax.Include(value: T)

Bases: Node[TripleExprLabel]

ShEx grammar production: Include ::= ‘&’ TripleExprLabel.

TYPE_ = Name(value='hydra.shex.syntax.Include')

class hydra.shex.syntax.IncludeSet(value: T)

Bases: Node[Sequence[ShapeExprLabel]]

ShEx grammar production: IncludeSet ::= ‘&’ ShapeExprLabel+.

TYPE_ = Name(value='hydra.shex.syntax.IncludeSet')

class hydra.shex.syntax.InlineShapeAnd(inline_shape_not: InlineShapeNot, list_of_sequence: Sequence[InlineShapeNot])

Bases: object

ShEx grammar production: InlineShapeAnd ::= InlineShapeNot (‘AND’ InlineShapeNot)*.

class Builder(_inline_shape_not: 'InlineShapeNot' = None, _list_of_sequence: 'Sequence[InlineShapeNot]' = None)

Bases: object

build()

inline_shape_not(inline_shape_not)

list_of_sequence(list_of_sequence)

INLINE_SHAPE_NOT = Name(value='InlineShapeNot')

LIST_OF_SEQUENCE = Name(value='listOfSequence')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeAnd')

static builder()

inline_shape_not: InlineShapeNot

list_of_sequence: Sequence[InlineShapeNot]

with_inline_shape_not(inline_shape_not)

with_list_of_sequence(list_of_sequence)

class hydra.shex.syntax.InlineShapeAtom

Bases: object

InlineShapeAtomSeq | InlineShapeAtomSeq2 | InlineShapeAtomSequence3 | InlineShapeAtomPeriod

PERIOD = Name(value='Period')

SEQ = Name(value='seq')

SEQ2 = Name(value='seq2')

SEQUENCE3 = Name(value='sequence3')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeAtom')

class hydra.shex.syntax.InlineShapeAtomPeriod

Bases: object

class hydra.shex.syntax.InlineShapeAtomSeq(value: T)

Bases: Node[InlineShapeAtomSequence]

class hydra.shex.syntax.InlineShapeAtomSeq2(value: T)

Bases: Node[InlineShapeAtomSequence2]

class hydra.shex.syntax.InlineShapeAtomSequence(node_constraint: NodeConstraint, inline_shape_or_ref: object)

Bases: object

A synthetic Hydra type representing a sequence within the ShEx InlineShapeAtom production.

class Builder(_node_constraint: 'NodeConstraint' = None, _inline_shape_or_ref: 'Optional[InlineShapeOrRef]' = None)

Bases: object

build()

inline_shape_or_ref(inline_shape_or_ref)

node_constraint(node_constraint)

INLINE_SHAPE_OR_REF = Name(value='InlineShapeOrRef')

NODE_CONSTRAINT = Name(value='NodeConstraint')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeAtomSequence')

static builder()

inline_shape_or_ref: object

node_constraint: NodeConstraint

with_inline_shape_or_ref(inline_shape_or_ref)

with_node_constraint(node_constraint)

class hydra.shex.syntax.InlineShapeAtomSequence2(inline_shape_or_ref: InlineShapeOrRef, node_constraint: object)

Bases: object

A synthetic Hydra type representing a secondary sequence within the ShEx InlineShapeAtom production.

class Builder(_inline_shape_or_ref: 'InlineShapeOrRef' = None, _node_constraint: 'Optional[NodeConstraint]' = None)

Bases: object

build()

inline_shape_or_ref(inline_shape_or_ref)

node_constraint(node_constraint)

INLINE_SHAPE_OR_REF = Name(value='InlineShapeOrRef')

NODE_CONSTRAINT = Name(value='NodeConstraint')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeAtomSequence2')

static builder()

inline_shape_or_ref: InlineShapeOrRef

node_constraint: object

with_inline_shape_or_ref(inline_shape_or_ref)

with_node_constraint(node_constraint)

class hydra.shex.syntax.InlineShapeAtomSequence3(value: T)

Bases: Node[ShapeExpression]

class hydra.shex.syntax.InlineShapeDefinition(list_of_alts: Sequence[InlineShapeDefinitionListOfAltsElmt], triple_expression: object)

Bases: object

A component of the ShEx InlineShapeDefinition production.

class Builder(_list_of_alts: 'Sequence[InlineShapeDefinitionListOfAltsElmt]' = None, _triple_expression: 'Optional[TripleExpression]' = None)

Bases: object

build()

list_of_alts(list_of_alts)

triple_expression(triple_expression)

LIST_OF_ALTS = Name(value='listOfAlts')

TRIPLE_EXPRESSION = Name(value='TripleExpression')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeDefinition')

static builder()

list_of_alts: Sequence[InlineShapeDefinitionListOfAltsElmt]

triple_expression: object

with_list_of_alts(list_of_alts)

with_triple_expression(triple_expression)

class hydra.shex.syntax.InlineShapeDefinitionListOfAltsElmt

Bases: object

InlineShapeDefinitionListOfAltsElmtIncludeSet | InlineShapeDefinitionListOfAltsElmtExtraPropertySet | InlineShapeDefinitionListOfAltsElmtCLOSED

C_L_O_S_E_D = Name(value='CLOSED')

EXTRA_PROPERTY_SET = Name(value='ExtraPropertySet')

INCLUDE_SET = Name(value='IncludeSet')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeDefinitionListOfAltsElmt')

class hydra.shex.syntax.InlineShapeDefinitionListOfAltsElmtCLOSED

Bases: object

class hydra.shex.syntax.InlineShapeDefinitionListOfAltsElmtExtraPropertySet(value: T)

Bases: Node[ExtraPropertySet]

class hydra.shex.syntax.InlineShapeDefinitionListOfAltsElmtIncludeSet(value: T)

Bases: Node[IncludeSet]

class hydra.shex.syntax.InlineShapeExpression(value: T)

Bases: Node[InlineShapeOr]

ShEx grammar production: InlineShapeExpression ::= InlineShapeOr.

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeExpression')

class hydra.shex.syntax.InlineShapeNot(n_o_t: object, inline_shape_atom: InlineShapeAtom)

Bases: object

ShEx grammar production: InlineShapeNot ::= ‘NOT’? InlineShapeAtom.

class Builder(_n_o_t: 'Optional[None]' = None, _inline_shape_atom: 'InlineShapeAtom' = None)

Bases: object

build()

inline_shape_atom(inline_shape_atom)

n_o_t(n_o_t)

INLINE_SHAPE_ATOM = Name(value='InlineShapeAtom')

N_O_T = Name(value='NOT')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeNot')

static builder()

inline_shape_atom: InlineShapeAtom

n_o_t: object

with_inline_shape_atom(inline_shape_atom)

with_n_o_t(n_o_t)

class hydra.shex.syntax.InlineShapeOr(shape_and: ShapeAnd, list_of_sequence: Sequence[InlineShapeAnd])

Bases: object

ShEx grammar production: InlineShapeOr ::= InlineShapeAnd (‘OR’ InlineShapeAnd)*.

class Builder(_shape_and: 'ShapeAnd' = None, _list_of_sequence: 'Sequence[InlineShapeAnd]' = None)

Bases: object

build()

list_of_sequence(list_of_sequence)

shape_and(shape_and)

LIST_OF_SEQUENCE = Name(value='listOfSequence')

SHAPE_AND = Name(value='ShapeAnd')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeOr')

static builder()

list_of_sequence: Sequence[InlineShapeAnd]

shape_and: ShapeAnd

with_list_of_sequence(list_of_sequence)

with_shape_and(shape_and)

class hydra.shex.syntax.InlineShapeOrRef

Bases: object

InlineShapeOrRefInlineShapeDefinition | InlineShapeOrRefAtpNameLn | InlineShapeOrRefAtpNameNs | InlineShapeOrRefSequence

ATP_NAME_LN = Name(value='AtpNameLn')

ATP_NAME_NS = Name(value='AtpNameNs')

INLINE_SHAPE_DEFINITION = Name(value='InlineShapeDefinition')

SEQUENCE = Name(value='sequence')

TYPE_ = Name(value='hydra.shex.syntax.InlineShapeOrRef')

class hydra.shex.syntax.InlineShapeOrRefAtpNameLn(value: T)

Bases: Node[AtpNameLn]

class hydra.shex.syntax.InlineShapeOrRefAtpNameNs(value: T)

Bases: Node[AtpNameNs]

class hydra.shex.syntax.InlineShapeOrRefInlineShapeDefinition(value: T)

Bases: Node[InlineShapeDefinition]

class hydra.shex.syntax.InlineShapeOrRefSequence(value: T)

Bases: Node[ShapeExprLabel]

class hydra.shex.syntax.InnerTripleExpr

Bases: object

InnerTripleExprMultiElementGroup | InnerTripleExprMultiElementOneOf

MULTI_ELEMENT_GROUP = Name(value='MultiElementGroup')

MULTI_ELEMENT_ONE_OF = Name(value='MultiElementOneOf')

TYPE_ = Name(value='hydra.shex.syntax.InnerTripleExpr')

class hydra.shex.syntax.InnerTripleExprMultiElementGroup(value: T)

Bases: Node[MultiElementGroup]

class hydra.shex.syntax.InnerTripleExprMultiElementOneOf(value: T)

Bases: Node[MultiElementOneOf]

class hydra.shex.syntax.Integer(value: T)

Bases: Node[str]

A component of the ShEx Integer production.

TYPE_ = Name(value='hydra.shex.syntax.Integer')

class hydra.shex.syntax.Iri

Bases: object

IriIriRef | IriPrefixedName

IRI_REF = Name(value='IriRef')

PREFIXED_NAME = Name(value='PrefixedName')

TYPE_ = Name(value='hydra.shex.syntax.Iri')

class hydra.shex.syntax.IriIriRef(value: T)

Bases: Node[IriRef]

class hydra.shex.syntax.IriPrefixedName(value: T)

Bases: Node[PrefixedName]

class hydra.shex.syntax.IriRange

Bases: object

IriRangeSeq | IriRangeSequence2

SEQ = Name(value='seq')

SEQUENCE2 = Name(value='sequence2')

TYPE_ = Name(value='hydra.shex.syntax.IriRange')

class hydra.shex.syntax.IriRangeSeq(value: T)

Bases: Node[IriRangeSequence]

class hydra.shex.syntax.IriRangeSequence(iri: Iri, sequence: object)

Bases: object

A synthetic Hydra type representing a sequence within the ShEx IriRange production.

class Builder(_iri: 'Iri' = None, _sequence: 'Optional[Sequence[Exclusion]]' = None)

Bases: object

build()

iri(iri)

sequence(sequence)

IRI = Name(value='Iri')

SEQUENCE = Name(value='Sequence')

TYPE_ = Name(value='hydra.shex.syntax.IriRangeSequence')

static builder()

iri: Iri

sequence: object

with_iri(iri)

with_sequence(sequence)

class hydra.shex.syntax.IriRangeSequence2(value: T)

Bases: Node[Sequence[Exclusion]]

class hydra.shex.syntax.IriRef(value: T)

Bases: Node[Sequence[IriRefElmt]]

A component of the ShEx IriRef production.

TYPE_ = Name(value='hydra.shex.syntax.IriRef')

class hydra.shex.syntax.IriRefElmt

Bases: object

IriRefElmtRegex | IriRefElmtUchar

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.IriRefElmt')

UCHAR = Name(value='Uchar')

class hydra.shex.syntax.IriRefElmtRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.IriRefElmtUchar(value: T)

Bases: Node[Uchar]

class hydra.shex.syntax.LangTag(value: T)

Bases: Node[str]

A component of the ShEx LangTag production.

TYPE_ = Name(value='hydra.shex.syntax.LangTag')

class hydra.shex.syntax.Literal

Bases: object

LiteralRdfLiteral | LiteralNumericLiteral | LiteralBooleanLiteral

BOOLEAN_LITERAL = Name(value='BooleanLiteral')

NUMERIC_LITERAL = Name(value='NumericLiteral')

RDF_LITERAL = Name(value='RdfLiteral')

TYPE_ = Name(value='hydra.shex.syntax.Literal')

class hydra.shex.syntax.LiteralBooleanLiteral(value: T)

Bases: Node[BooleanLiteral]

class hydra.shex.syntax.LiteralNumericLiteral(value: T)

Bases: Node[NumericLiteral]

class hydra.shex.syntax.LiteralRdfLiteral(value: T)

Bases: Node[RdfLiteral]

class hydra.shex.syntax.MultiElementGroup(unary_triple_expr: UnaryTripleExpr, list_of_sequence: Sequence[UnaryTripleExpr], semi: object)

Bases: object

ShEx grammar production: MultiElementGroup ::= UnaryTripleExpr (‘;’ UnaryTripleExpr)+ ‘;’?.

class Builder(_unary_triple_expr: 'UnaryTripleExpr' = None, _list_of_sequence: 'Sequence[UnaryTripleExpr]' = None, _semi: 'Optional[None]' = None)

Bases: object

build()

list_of_sequence(list_of_sequence)

semi(semi)

unary_triple_expr(unary_triple_expr)

LIST_OF_SEQUENCE = Name(value='listOfSequence')

SEMI = Name(value='Semi')

TYPE_ = Name(value='hydra.shex.syntax.MultiElementGroup')

UNARY_TRIPLE_EXPR = Name(value='UnaryTripleExpr')

static builder()

list_of_sequence: Sequence[UnaryTripleExpr]

semi: object

unary_triple_expr: UnaryTripleExpr

with_list_of_sequence(list_of_sequence)

with_semi(semi)

with_unary_triple_expr(unary_triple_expr)

class hydra.shex.syntax.MultiElementOneOf(group_triple_expr: GroupTripleExpr, list_of_sequence: Sequence[GroupTripleExpr])

Bases: object

ShEx grammar production: MultiElementOneOf ::= GroupTripleExpr (‘|’ GroupTripleExpr)+.

class Builder(_group_triple_expr: 'GroupTripleExpr' = None, _list_of_sequence: 'Sequence[GroupTripleExpr]' = None)

Bases: object

build()

group_triple_expr(group_triple_expr)

list_of_sequence(list_of_sequence)

GROUP_TRIPLE_EXPR = Name(value='GroupTripleExpr')

LIST_OF_SEQUENCE = Name(value='listOfSequence')

TYPE_ = Name(value='hydra.shex.syntax.MultiElementOneOf')

static builder()

group_triple_expr: GroupTripleExpr

list_of_sequence: Sequence[GroupTripleExpr]

with_group_triple_expr(group_triple_expr)

with_list_of_sequence(list_of_sequence)

class hydra.shex.syntax.NodeConstraint

Bases: object

NodeConstraintSequence | NodeConstraintSeq2 | NodeConstraintSeq3 | NodeConstraintSeq4 | NodeConstraintSeq5 | NodeConstraintListOfXsFacet

LIST_OF_XS_FACET = Name(value='listOfXsFacet')

SEQ2 = Name(value='seq2')

SEQ3 = Name(value='seq3')

SEQ4 = Name(value='seq4')

SEQ5 = Name(value='seq5')

SEQUENCE = Name(value='sequence')

TYPE_ = Name(value='hydra.shex.syntax.NodeConstraint')

class hydra.shex.syntax.NodeConstraintListOfXsFacet(value: T)

Bases: Node[Sequence[XsFacet]]

class hydra.shex.syntax.NodeConstraintSeq2(value: T)

Bases: Node[NodeConstraintSequence2]

class hydra.shex.syntax.NodeConstraintSeq3(value: T)

Bases: Node[NodeConstraintSequence3]

class hydra.shex.syntax.NodeConstraintSeq4(value: T)

Bases: Node[NodeConstraintSequence4]

class hydra.shex.syntax.NodeConstraintSeq5(value: T)

Bases: Node[NodeConstraintSequence5]

class hydra.shex.syntax.NodeConstraintSequence(value: T)

Bases: Node[Sequence[XsFacet]]

class hydra.shex.syntax.NodeConstraintSequence2(non_literal_kind: NonLiteralKind, list_of_string_facet: Sequence[StringFacet])

Bases: object

A synthetic Hydra type representing a secondary sequence within the ShEx NodeConstraint production.

class Builder(_non_literal_kind: 'NonLiteralKind' = None, _list_of_string_facet: 'Sequence[StringFacet]' = None)

Bases: object

build()

list_of_string_facet(list_of_string_facet)

non_literal_kind(non_literal_kind)

LIST_OF_STRING_FACET = Name(value='listOfStringFacet')

NON_LITERAL_KIND = Name(value='NonLiteralKind')

TYPE_ = Name(value='hydra.shex.syntax.NodeConstraintSequence2')

static builder()

list_of_string_facet: Sequence[StringFacet]

non_literal_kind: NonLiteralKind

with_list_of_string_facet(list_of_string_facet)

with_non_literal_kind(non_literal_kind)

class hydra.shex.syntax.NodeConstraintSequence3(datatype: Datatype, list_of_xs_facet: Sequence[XsFacet])

Bases: object

A synthetic Hydra type representing a tertiary sequence within the ShEx NodeConstraint production.

class Builder(_datatype: 'Datatype' = None, _list_of_xs_facet: 'Sequence[XsFacet]' = None)

Bases: object

build()

datatype(datatype)

list_of_xs_facet(list_of_xs_facet)

DATATYPE = Name(value='Datatype')

LIST_OF_XS_FACET = Name(value='listOfXsFacet')

TYPE_ = Name(value='hydra.shex.syntax.NodeConstraintSequence3')

static builder()

datatype: Datatype

list_of_xs_facet: Sequence[XsFacet]

with_datatype(datatype)

with_list_of_xs_facet(list_of_xs_facet)

class hydra.shex.syntax.NodeConstraintSequence4(value_set: ValueSet, list_of_xs_facet: Sequence[XsFacet])

Bases: object

A synthetic Hydra type representing a quaternary sequence within the ShEx NodeConstraint production.

class Builder(_value_set: 'ValueSet' = None, _list_of_xs_facet: 'Sequence[XsFacet]' = None)

Bases: object

build()

list_of_xs_facet(list_of_xs_facet)

value_set(value_set)

LIST_OF_XS_FACET = Name(value='listOfXsFacet')

TYPE_ = Name(value='hydra.shex.syntax.NodeConstraintSequence4')

VALUE_SET = Name(value='ValueSet')

static builder()

list_of_xs_facet: Sequence[XsFacet]

value_set: ValueSet

with_list_of_xs_facet(list_of_xs_facet)

with_value_set(value_set)

class hydra.shex.syntax.NodeConstraintSequence5(value_set: ValueSet, list_of_xs_facet: Sequence[XsFacet])

Bases: object

A synthetic Hydra type representing a quinary sequence within the ShEx NodeConstraint production.

class Builder(_value_set: 'ValueSet' = None, _list_of_xs_facet: 'Sequence[XsFacet]' = None)

Bases: object

build()

list_of_xs_facet(list_of_xs_facet)

value_set(value_set)

LIST_OF_XS_FACET = Name(value='listOfXsFacet')

TYPE_ = Name(value='hydra.shex.syntax.NodeConstraintSequence5')

VALUE_SET = Name(value='ValueSet')

static builder()

list_of_xs_facet: Sequence[XsFacet]

value_set: ValueSet

with_list_of_xs_facet(list_of_xs_facet)

with_value_set(value_set)

class hydra.shex.syntax.NonLiteralKind(*values)

Bases: Enum

ShEx grammar production: NonLiteralKind ::= ‘IRI’ | ‘BNODE’ | ‘NONLITERAL’.

B_N_O_D_E = Name(value='BNODE')

I_R_I = Name(value='IRI')

N_O_N_L_I_T_E_R_A_L = Name(value='NONLITERAL')

TYPE_ = Name(value='hydra.shex.syntax.NonLiteralKind')

class hydra.shex.syntax.NotStartAction

Bases: object

NotStartActionStart | NotStartActionDeclaration

DECLARATION = Name(value='declaration')

START = Name(value='start')

TYPE_ = Name(value='hydra.shex.syntax.NotStartAction')

class hydra.shex.syntax.NotStartActionDeclaration(value: T)

Bases: Node[NotStartActionShapeExprDecl]

class hydra.shex.syntax.NotStartActionShapeExprDecl(shape_expr_label: ShapeExprLabel, alts: NotStartActionShapeExprDeclAlts)

Bases: object

A component of the ShEx NotStartActionShapeExprDecl production.

ALTS = Name(value='alts')

class Builder(_shape_expr_label: 'ShapeExprLabel' = None, _alts: 'NotStartActionShapeExprDeclAlts' = None)

Bases: object

alts(alts)

build()

shape_expr_label(shape_expr_label)

SHAPE_EXPR_LABEL = Name(value='ShapeExprLabel')

TYPE_ = Name(value='hydra.shex.syntax.NotStartActionShapeExprDecl')

alts: NotStartActionShapeExprDeclAlts

static builder()

shape_expr_label: ShapeExprLabel

with_alts(alts)

with_shape_expr_label(shape_expr_label)

class hydra.shex.syntax.NotStartActionShapeExprDeclAlts

Bases: object

NotStartActionShapeExprDeclAltsShapeExpression | NotStartActionShapeExprDeclAltsEXTERNAL

E_X_T_E_R_N_A_L = Name(value='EXTERNAL')

SHAPE_EXPRESSION = Name(value='ShapeExpression')

TYPE_ = Name(value='hydra.shex.syntax.NotStartActionShapeExprDeclAlts')

class hydra.shex.syntax.NotStartActionShapeExprDeclAltsEXTERNAL

Bases: object

class hydra.shex.syntax.NotStartActionShapeExprDeclAltsShapeExpression(value: T)

Bases: Node[ShapeExpression]

class hydra.shex.syntax.NotStartActionStart(value: T)

Bases: Node[ShapeExpression]

class hydra.shex.syntax.NumericFacet

Bases: object

NumericFacetSeq | NumericFacetSeq2

SEQ = Name(value='seq')

SEQ2 = Name(value='seq2')

TYPE_ = Name(value='hydra.shex.syntax.NumericFacet')

class hydra.shex.syntax.NumericFacetSeq(value: T)

Bases: Node[NumericFacetSequence]

class hydra.shex.syntax.NumericFacetSeq2(value: T)

Bases: Node[NumericFacetSequence2]

class hydra.shex.syntax.NumericFacetSequence(numeric_range: NumericRange, numeric_literal: NumericLiteral)

Bases: object

A synthetic Hydra type representing a sequence within the ShEx NumericFacet production.

class Builder(_numeric_range: 'NumericRange' = None, _numeric_literal: 'NumericLiteral' = None)

Bases: object

build()

numeric_literal(numeric_literal)

numeric_range(numeric_range)

NUMERIC_LITERAL = Name(value='NumericLiteral')

NUMERIC_RANGE = Name(value='NumericRange')

TYPE_ = Name(value='hydra.shex.syntax.NumericFacetSequence')

static builder()

numeric_literal: NumericLiteral

numeric_range: NumericRange

with_numeric_literal(numeric_literal)

with_numeric_range(numeric_range)

class hydra.shex.syntax.NumericFacetSequence2(numeric_length: NumericLength, integer: Integer)

Bases: object

A synthetic Hydra type representing a secondary sequence within the ShEx NumericFacet production.

class Builder(_numeric_length: 'NumericLength' = None, _integer: 'Integer' = None)

Bases: object

build()

integer(integer)

numeric_length(numeric_length)

INTEGER = Name(value='Integer')

NUMERIC_LENGTH = Name(value='NumericLength')

TYPE_ = Name(value='hydra.shex.syntax.NumericFacetSequence2')

static builder()

integer: Integer

numeric_length: NumericLength

with_integer(integer)

with_numeric_length(numeric_length)

class hydra.shex.syntax.NumericLength(*values)

Bases: Enum

A component of the ShEx NumericLength production.

F_R_A_C_T_I_O_N_D_I_G_I_T_S = Name(value='FRACTIONDIGITS')

TYPE_ = Name(value='hydra.shex.syntax.NumericLength')

T_O_T_A_L_D_I_G_I_T_S = Name(value='TOTALDIGITS')

class hydra.shex.syntax.NumericLiteral

Bases: object

NumericLiteralInteger | NumericLiteralDecimal | NumericLiteralDouble

DECIMAL = Name(value='Decimal')

DOUBLE = Name(value='Double')

INTEGER = Name(value='Integer')

TYPE_ = Name(value='hydra.shex.syntax.NumericLiteral')

class hydra.shex.syntax.NumericLiteralDecimal(value: T)

Bases: Node[Decimal]

class hydra.shex.syntax.NumericLiteralDouble(value: T)

Bases: Node[Double]

class hydra.shex.syntax.NumericLiteralInteger(value: T)

Bases: Node[Integer]

class hydra.shex.syntax.NumericRange(*values)

Bases: Enum

A component of the ShEx NumericRange production.

M_A_X_E_X_C_L_U_S_I_V_E = Name(value='MAXEXCLUSIVE')

M_A_X_I_N_C_L_U_S_I_V_E = Name(value='MAXINCLUSIVE')

M_I_N_E_X_C_L_U_S_I_V_E = Name(value='MINEXCLUSIVE')

M_I_N_I_N_C_L_U_S_I_V_E = Name(value='MININCLUSIVE')

TYPE_ = Name(value='hydra.shex.syntax.NumericRange')

class hydra.shex.syntax.OneOfTripleExpr

Bases: object

OneOfTripleExprGroupTripleExpr | OneOfTripleExprMultiElementOneOf

GROUP_TRIPLE_EXPR = Name(value='GroupTripleExpr')

MULTI_ELEMENT_ONE_OF = Name(value='MultiElementOneOf')

TYPE_ = Name(value='hydra.shex.syntax.OneOfTripleExpr')

class hydra.shex.syntax.OneOfTripleExprGroupTripleExpr(value: T)

Bases: Node[GroupTripleExpr]

class hydra.shex.syntax.OneOfTripleExprMultiElementOneOf(value: T)

Bases: Node[MultiElementOneOf]

class hydra.shex.syntax.Percent(hex: Hex, hex2: Hex)

Bases: object

ShEx grammar production: Percent ::= ‘%’ Hex Hex.

class Builder(_hex: 'Hex' = None, _hex2: 'Hex' = None)

Bases: object

build()

hex(hex)

hex2(hex2)

HEX = Name(value='Hex')

HEX2 = Name(value='Hex2')

TYPE_ = Name(value='hydra.shex.syntax.Percent')

static builder()

hex: Hex

hex2: Hex

with_hex(hex)

with_hex2(hex2)

class hydra.shex.syntax.Plx

Bases: object

PlxPercent | PlxPnLocalEsc

PERCENT = Name(value='Percent')

PN_LOCAL_ESC = Name(value='PnLocalEsc')

TYPE_ = Name(value='hydra.shex.syntax.Plx')

class hydra.shex.syntax.PlxPercent(value: T)

Bases: Node[Percent]

class hydra.shex.syntax.PlxPnLocalEsc(value: T)

Bases: Node[PnLocalEsc]

class hydra.shex.syntax.PnChars

Bases: object

PnCharsPnCharsU | PnCharsMinus | PnCharsRegex

MINUS = Name(value='Minus')

PN_CHARS_U = Name(value='PnCharsU')

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.PnChars')

class hydra.shex.syntax.PnCharsBase

Bases: object

PnCharsBaseRegex | PnCharsBaseRegex2

REGEX = Name(value='regex')

REGEX2 = Name(value='regex2')

TYPE_ = Name(value='hydra.shex.syntax.PnCharsBase')

class hydra.shex.syntax.PnCharsBaseRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.PnCharsBaseRegex2(value: T)

Bases: Node[str]

class hydra.shex.syntax.PnCharsMinus

Bases: object

class hydra.shex.syntax.PnCharsPnCharsU(value: T)

Bases: Node[PnCharsU]

class hydra.shex.syntax.PnCharsRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.PnCharsU

Bases: object

PnCharsUPnCharsBase | PnCharsULowbar

LOWBAR = Name(value='Lowbar')

PN_CHARS_BASE = Name(value='PnCharsBase')

TYPE_ = Name(value='hydra.shex.syntax.PnCharsU')

class hydra.shex.syntax.PnCharsULowbar

Bases: object

class hydra.shex.syntax.PnCharsUPnCharsBase(value: T)

Bases: Node[PnCharsBase]

class hydra.shex.syntax.PnLocal(alts: PnLocalAlts, sequence: object)

Bases: object

A component of the ShEx PnLocal production.

ALTS = Name(value='alts')

class Builder(_alts: 'PnLocalAlts' = None, _sequence: 'Optional[PnLocalSequenceOption]' = None)

Bases: object

alts(alts)

build()

sequence(sequence)

SEQUENCE = Name(value='Sequence')

TYPE_ = Name(value='hydra.shex.syntax.PnLocal')

alts: PnLocalAlts

static builder()

sequence: object

with_alts(alts)

with_sequence(sequence)

class hydra.shex.syntax.PnLocalAlts

Bases: object

PnLocalAltsPnCharsU | PnLocalAltsColon | PnLocalAltsRegex | PnLocalAltsPlx

COLON = Name(value='Colon')

PLX = Name(value='Plx')

PN_CHARS_U = Name(value='PnCharsU')

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.PnLocalAlts')

class hydra.shex.syntax.PnLocalAltsColon

Bases: object

class hydra.shex.syntax.PnLocalAltsPlx(value: T)

Bases: Node[Plx]

class hydra.shex.syntax.PnLocalAltsPnCharsU(value: T)

Bases: Node[PnCharsU]

class hydra.shex.syntax.PnLocalAltsRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.PnLocalEsc(value: T)

Bases: Node[str]

A component of the ShEx PnLocalEsc production.

TYPE_ = Name(value='hydra.shex.syntax.PnLocalEsc')

class hydra.shex.syntax.PnLocalSequenceOption(list_of_alts: Sequence[PnLocalSequenceOptionListOfAltsElmt], alts: PnLocalSequenceOptionAlts)

Bases: object

A synthetic Hydra type representing an optional group within the ShEx PnLocal production.

ALTS = Name(value='alts')

class Builder(_list_of_alts: 'Sequence[PnLocalSequenceOptionListOfAltsElmt]' = None, _alts: 'PnLocalSequenceOptionAlts' = None)

Bases: object

alts(alts)

build()

list_of_alts(list_of_alts)

LIST_OF_ALTS = Name(value='listOfAlts')

TYPE_ = Name(value='hydra.shex.syntax.PnLocalSequenceOption')

alts: PnLocalSequenceOptionAlts

static builder()

list_of_alts: Sequence[PnLocalSequenceOptionListOfAltsElmt]

with_alts(alts)

with_list_of_alts(list_of_alts)

class hydra.shex.syntax.PnLocalSequenceOptionAlts

Bases: object

PnLocalSequenceOptionAltsPnChars | PnLocalSequenceOptionAltsColon | PnLocalSequenceOptionAltsPlx

COLON = Name(value='Colon')

PLX = Name(value='Plx')

PN_CHARS = Name(value='PnChars')

TYPE_ = Name(value='hydra.shex.syntax.PnLocalSequenceOptionAlts')

class hydra.shex.syntax.PnLocalSequenceOptionAltsColon

Bases: object

class hydra.shex.syntax.PnLocalSequenceOptionAltsPlx(value: T)

Bases: Node[Plx]

class hydra.shex.syntax.PnLocalSequenceOptionAltsPnChars(value: T)

Bases: Node[PnChars]

class hydra.shex.syntax.PnLocalSequenceOptionListOfAltsElmt

Bases: object

PnLocalSequenceOptionListOfAltsElmtPnChars | PnLocalSequenceOptionListOfAltsElmtPeriod | PnLocalSequenceOptionListOfAltsElmtColon | PnLocalSequenceOptionListOfAltsElmtPlx

COLON = Name(value='Colon')

PERIOD = Name(value='Period')

PLX = Name(value='Plx')

PN_CHARS = Name(value='PnChars')

TYPE_ = Name(value='hydra.shex.syntax.PnLocalSequenceOptionListOfAltsElmt')

class hydra.shex.syntax.PnLocalSequenceOptionListOfAltsElmtColon

Bases: object

class hydra.shex.syntax.PnLocalSequenceOptionListOfAltsElmtPeriod

Bases: object

class hydra.shex.syntax.PnLocalSequenceOptionListOfAltsElmtPlx(value: T)

Bases: Node[Plx]

class hydra.shex.syntax.PnLocalSequenceOptionListOfAltsElmtPnChars(value: T)

Bases: Node[PnChars]

class hydra.shex.syntax.PnPrefix(pn_chars_base: PnCharsBase, sequence: object)

Bases: object

A component of the ShEx PnPrefix production.

class Builder(_pn_chars_base: 'PnCharsBase' = None, _sequence: 'Optional[PnPrefixSequenceOption]' = None)

Bases: object

build()

pn_chars_base(pn_chars_base)

sequence(sequence)

PN_CHARS_BASE = Name(value='PnCharsBase')

SEQUENCE = Name(value='Sequence')

TYPE_ = Name(value='hydra.shex.syntax.PnPrefix')

static builder()

pn_chars_base: PnCharsBase

sequence: object

with_pn_chars_base(pn_chars_base)

with_sequence(sequence)

class hydra.shex.syntax.PnPrefixSequenceOption(alts: PnPrefixSequenceOptionAlts, pn_chars: PnChars)

Bases: object

A synthetic Hydra type representing an optional group within the ShEx PnPrefix production.

ALTS = Name(value='alts')

class Builder(_alts: 'PnPrefixSequenceOptionAlts' = None, _pn_chars: 'PnChars' = None)

Bases: object

alts(alts)

build()

pn_chars(pn_chars)

PN_CHARS = Name(value='PnChars')

TYPE_ = Name(value='hydra.shex.syntax.PnPrefixSequenceOption')

alts: PnPrefixSequenceOptionAlts

static builder()

pn_chars: PnChars

with_alts(alts)

with_pn_chars(pn_chars)

class hydra.shex.syntax.PnPrefixSequenceOptionAlts

Bases: object

PnPrefixSequenceOptionAltsPnChars | PnPrefixSequenceOptionAltsPeriod

PERIOD = Name(value='Period')

PN_CHARS = Name(value='PnChars')

TYPE_ = Name(value='hydra.shex.syntax.PnPrefixSequenceOptionAlts')

class hydra.shex.syntax.PnPrefixSequenceOptionAltsPeriod

Bases: object

class hydra.shex.syntax.PnPrefixSequenceOptionAltsPnChars(value: T)

Bases: Node[PnChars]

class hydra.shex.syntax.PnameLn(pname_ns: PnameNs, pn_local: PnLocal)

Bases: object

ShEx grammar production: PnameLn ::= PnameNs PnLocal.

class Builder(_pname_ns: 'PnameNs' = None, _pn_local: 'PnLocal' = None)

Bases: object

build()

pn_local(pn_local)

pname_ns(pname_ns)

PNAME_NS = Name(value='PnameNs')

PN_LOCAL = Name(value='PnLocal')

TYPE_ = Name(value='hydra.shex.syntax.PnameLn')

static builder()

pn_local: PnLocal

pname_ns: PnameNs

with_pn_local(pn_local)

with_pname_ns(pname_ns)

class hydra.shex.syntax.PnameNs(value: T)

Bases: Node[Optional[PnPrefix]]

ShEx grammar production: PnameNs ::= PnPrefix? ‘:’.

TYPE_ = Name(value='hydra.shex.syntax.PnameNs')

class hydra.shex.syntax.Predicate

Bases: object

PredicateIri | PredicateRdfType

IRI = Name(value='Iri')

RDF_TYPE = Name(value='RdfType')

TYPE_ = Name(value='hydra.shex.syntax.Predicate')

class hydra.shex.syntax.PredicateIri(value: T)

Bases: Node[Iri]

class hydra.shex.syntax.PredicateRdfType(value: T)

Bases: Node[RdfType]

class hydra.shex.syntax.PrefixDecl(pname_ns: PnameNs, iri_ref: IriRef)

Bases: object

ShEx grammar production: PrefixDecl ::= ‘PREFIX’ PnameNs IriRef.

class Builder(_pname_ns: 'PnameNs' = None, _iri_ref: 'IriRef' = None)

Bases: object

build()

iri_ref(iri_ref)

pname_ns(pname_ns)

IRI_REF = Name(value='IriRef')

PNAME_NS = Name(value='PnameNs')

TYPE_ = Name(value='hydra.shex.syntax.PrefixDecl')

static builder()

iri_ref: IriRef

pname_ns: PnameNs

with_iri_ref(iri_ref)

with_pname_ns(pname_ns)

class hydra.shex.syntax.PrefixedName

Bases: object

PrefixedNamePnameLn | PrefixedNamePnameNs

PNAME_LN = Name(value='PnameLn')

PNAME_NS = Name(value='PnameNs')

TYPE_ = Name(value='hydra.shex.syntax.PrefixedName')

class hydra.shex.syntax.PrefixedNamePnameLn(value: T)

Bases: Node[PnameLn]

class hydra.shex.syntax.PrefixedNamePnameNs(value: T)

Bases: Node[PnameNs]

class hydra.shex.syntax.RdfLiteral(string: String, alts: object)

Bases: object

ShEx grammar production: RdfLiteral ::= String (LangTag | ‘^^’ Datatype)?.

ALTS = Name(value='Alts')

class Builder(_string: 'String' = None, _alts: 'Optional[RdfLiteralAltsOption]' = None)

Bases: object

alts(alts)

build()

string(string)

STRING = Name(value='String')

TYPE_ = Name(value='hydra.shex.syntax.RdfLiteral')

alts: object

static builder()

string: String

with_alts(alts)

with_string(string)

class hydra.shex.syntax.RdfLiteralAltsOption

Bases: object

RdfLiteralAltsOptionLangTag | RdfLiteralAltsOptionSequence

LANG_TAG = Name(value='LangTag')

SEQUENCE = Name(value='sequence')

TYPE_ = Name(value='hydra.shex.syntax.RdfLiteralAltsOption')

class hydra.shex.syntax.RdfLiteralAltsOptionLangTag(value: T)

Bases: Node[LangTag]

class hydra.shex.syntax.RdfLiteralAltsOptionSequence(value: T)

Bases: Node[Datatype]

class hydra.shex.syntax.RdfType(value: T)

Bases: Node[None]

ShEx grammar production: RdfType ::= ‘a’.

TYPE_ = Name(value='hydra.shex.syntax.RdfType')

class hydra.shex.syntax.Regexp(list_of_alts: Sequence[RegexpListOfAltsElmt], list_of_regex: Sequence[str])

Bases: object

A component of the ShEx Regexp production.

class Builder(_list_of_alts: 'Sequence[RegexpListOfAltsElmt]' = None, _list_of_regex: 'Sequence[str]' = None)

Bases: object

build()

list_of_alts(list_of_alts)

list_of_regex(list_of_regex)

LIST_OF_ALTS = Name(value='listOfAlts')

LIST_OF_REGEX = Name(value='listOfRegex')

TYPE_ = Name(value='hydra.shex.syntax.Regexp')

static builder()

list_of_alts: Sequence[RegexpListOfAltsElmt]

list_of_regex: Sequence[str]

with_list_of_alts(list_of_alts)

with_list_of_regex(list_of_regex)

class hydra.shex.syntax.RegexpListOfAltsElmt

Bases: object

RegexpListOfAltsElmtRegex | RegexpListOfAltsElmtSequence | RegexpListOfAltsElmtUchar

REGEX = Name(value='regex')

SEQUENCE = Name(value='sequence')

TYPE_ = Name(value='hydra.shex.syntax.RegexpListOfAltsElmt')

UCHAR = Name(value='Uchar')

class hydra.shex.syntax.RegexpListOfAltsElmtRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.RegexpListOfAltsElmtSequence(value: T)

Bases: Node[str]

class hydra.shex.syntax.RegexpListOfAltsElmtUchar(value: T)

Bases: Node[Uchar]

class hydra.shex.syntax.RepeatRange(integer: Integer, sequence: object)

Bases: object

A component of the ShEx RepeatRange production.

class Builder(_integer: 'Integer' = None, _sequence: 'Optional[Optional[Optional[RepeatRangeSequenceOptionOptionOption]]]' = None)

Bases: object

build()

integer(integer)

sequence(sequence)

INTEGER = Name(value='Integer')

SEQUENCE = Name(value='Sequence')

TYPE_ = Name(value='hydra.shex.syntax.RepeatRange')

static builder()

integer: Integer

sequence: object

with_integer(integer)

with_sequence(sequence)

class hydra.shex.syntax.RepeatRangeSequenceOptionOptionOption

Bases: object

RepeatRangeSequenceOptionOptionOptionInteger | RepeatRangeSequenceOptionOptionOptionAst

AST = Name(value='Ast')

INTEGER = Name(value='Integer')

TYPE_ = Name(value='hydra.shex.syntax.RepeatRangeSequenceOptionOptionOption')

class hydra.shex.syntax.RepeatRangeSequenceOptionOptionOptionAst

Bases: object

class hydra.shex.syntax.RepeatRangeSequenceOptionOptionOptionInteger(value: T)

Bases: Node[Integer]

class hydra.shex.syntax.SemanticActions(value: T)

Bases: Node[Sequence[CodeDecl]]

ShEx grammar production: SemanticActions ::= CodeDecl*.

TYPE_ = Name(value='hydra.shex.syntax.SemanticActions')

class hydra.shex.syntax.SenseFlags(value: T)

Bases: Node[None]

ShEx grammar production: SenseFlags ::= ‘^’.

TYPE_ = Name(value='hydra.shex.syntax.SenseFlags')

class hydra.shex.syntax.ShapeAnd(shape_not: ShapeNot, list_of_sequence: Sequence[ShapeNot])

Bases: object

ShEx grammar production: ShapeAnd ::= ShapeNot (‘AND’ ShapeNot)*.

class Builder(_shape_not: 'ShapeNot' = None, _list_of_sequence: 'Sequence[ShapeNot]' = None)

Bases: object

build()

list_of_sequence(list_of_sequence)

shape_not(shape_not)

LIST_OF_SEQUENCE = Name(value='listOfSequence')

SHAPE_NOT = Name(value='ShapeNot')

TYPE_ = Name(value='hydra.shex.syntax.ShapeAnd')

static builder()

list_of_sequence: Sequence[ShapeNot]

shape_not: ShapeNot

with_list_of_sequence(list_of_sequence)

with_shape_not(shape_not)

class hydra.shex.syntax.ShapeAtom

Bases: object

ShapeAtomSeq | ShapeAtomShapeOrRef | ShapeAtomSequence2 | ShapeAtomPeriod

PERIOD = Name(value='Period')

SEQ = Name(value='seq')

SEQUENCE2 = Name(value='sequence2')

SHAPE_OR_REF = Name(value='ShapeOrRef')

TYPE_ = Name(value='hydra.shex.syntax.ShapeAtom')

class hydra.shex.syntax.ShapeAtomPeriod

Bases: object

class hydra.shex.syntax.ShapeAtomSeq(value: T)

Bases: Node[ShapeAtomSequence]

class hydra.shex.syntax.ShapeAtomSequence(node_constraint: NodeConstraint, shape_or_ref: object)

Bases: object

A synthetic Hydra type representing a sequence within the ShEx ShapeAtom production.

class Builder(_node_constraint: 'NodeConstraint' = None, _shape_or_ref: 'Optional[ShapeOrRef]' = None)

Bases: object

build()

node_constraint(node_constraint)

shape_or_ref(shape_or_ref)

NODE_CONSTRAINT = Name(value='NodeConstraint')

SHAPE_OR_REF = Name(value='ShapeOrRef')

TYPE_ = Name(value='hydra.shex.syntax.ShapeAtomSequence')

static builder()

node_constraint: NodeConstraint

shape_or_ref: object

with_node_constraint(node_constraint)

with_shape_or_ref(shape_or_ref)

class hydra.shex.syntax.ShapeAtomSequence2(value: T)

Bases: Node[ShapeExpression]

class hydra.shex.syntax.ShapeAtomShapeOrRef(value: T)

Bases: Node[ShapeOrRef]

class hydra.shex.syntax.ShapeDefinition(list_of_alts: Sequence[ShapeDefinitionListOfAltsElmt], triple_expression: object, list_of_annotation: Sequence[Annotation], semantic_actions: SemanticActions)

Bases: object

A component of the ShEx ShapeDefinition production.

class Builder(_list_of_alts: 'Sequence[ShapeDefinitionListOfAltsElmt]' = None, _triple_expression: 'Optional[TripleExpression]' = None, _list_of_annotation: 'Sequence[Annotation]' = None, _semantic_actions: 'SemanticActions' = None)

Bases: object

build()

list_of_alts(list_of_alts)

list_of_annotation(list_of_annotation)

semantic_actions(semantic_actions)

triple_expression(triple_expression)

LIST_OF_ALTS = Name(value='listOfAlts')

LIST_OF_ANNOTATION = Name(value='listOfAnnotation')

SEMANTIC_ACTIONS = Name(value='SemanticActions')

TRIPLE_EXPRESSION = Name(value='TripleExpression')

TYPE_ = Name(value='hydra.shex.syntax.ShapeDefinition')

static builder()

list_of_alts: Sequence[ShapeDefinitionListOfAltsElmt]

list_of_annotation: Sequence[Annotation]

semantic_actions: SemanticActions

triple_expression: object

with_list_of_alts(list_of_alts)

with_list_of_annotation(list_of_annotation)

with_semantic_actions(semantic_actions)

with_triple_expression(triple_expression)

class hydra.shex.syntax.ShapeDefinitionListOfAltsElmt

Bases: object

ShapeDefinitionListOfAltsElmtIncludeSet | ShapeDefinitionListOfAltsElmtExtraPropertySet | ShapeDefinitionListOfAltsElmtCLOSED

C_L_O_S_E_D = Name(value='CLOSED')

EXTRA_PROPERTY_SET = Name(value='ExtraPropertySet')

INCLUDE_SET = Name(value='IncludeSet')

TYPE_ = Name(value='hydra.shex.syntax.ShapeDefinitionListOfAltsElmt')

class hydra.shex.syntax.ShapeDefinitionListOfAltsElmtCLOSED

Bases: object

class hydra.shex.syntax.ShapeDefinitionListOfAltsElmtExtraPropertySet(value: T)

Bases: Node[ExtraPropertySet]

class hydra.shex.syntax.ShapeDefinitionListOfAltsElmtIncludeSet(value: T)

Bases: Node[IncludeSet]

class hydra.shex.syntax.ShapeExprLabel

Bases: object

ShapeExprLabelIri | ShapeExprLabelBlankNode

BLANK_NODE = Name(value='BlankNode')

IRI = Name(value='Iri')

TYPE_ = Name(value='hydra.shex.syntax.ShapeExprLabel')

class hydra.shex.syntax.ShapeExprLabelBlankNode(value: T)

Bases: Node[BlankNode]

class hydra.shex.syntax.ShapeExprLabelIri(value: T)

Bases: Node[Iri]

class hydra.shex.syntax.ShapeExpression(value: T)

Bases: Node[ShapeOr]

ShEx grammar production: ShapeExpression ::= ShapeOr.

TYPE_ = Name(value='hydra.shex.syntax.ShapeExpression')

class hydra.shex.syntax.ShapeNot(n_o_t: object, shape_atom: ShapeAtom)

Bases: object

ShEx grammar production: ShapeNot ::= ‘NOT’? ShapeAtom.

class Builder(_n_o_t: 'Optional[None]' = None, _shape_atom: 'ShapeAtom' = None)

Bases: object

build()

n_o_t(n_o_t)

shape_atom(shape_atom)

N_O_T = Name(value='NOT')

SHAPE_ATOM = Name(value='ShapeAtom')

TYPE_ = Name(value='hydra.shex.syntax.ShapeNot')

static builder()

n_o_t: object

shape_atom: ShapeAtom

with_n_o_t(n_o_t)

with_shape_atom(shape_atom)

class hydra.shex.syntax.ShapeOr(shape_and: ShapeAnd, list_of_sequence: Sequence[ShapeAnd])

Bases: object

ShEx grammar production: ShapeOr ::= ShapeAnd (‘OR’ ShapeAnd)*.

class Builder(_shape_and: 'ShapeAnd' = None, _list_of_sequence: 'Sequence[ShapeAnd]' = None)

Bases: object

build()

list_of_sequence(list_of_sequence)

shape_and(shape_and)

LIST_OF_SEQUENCE = Name(value='listOfSequence')

SHAPE_AND = Name(value='ShapeAnd')

TYPE_ = Name(value='hydra.shex.syntax.ShapeOr')

static builder()

list_of_sequence: Sequence[ShapeAnd]

shape_and: ShapeAnd

with_list_of_sequence(list_of_sequence)

with_shape_and(shape_and)

class hydra.shex.syntax.ShapeOrRef

Bases: object

ShapeOrRefShapeDefinition | ShapeOrRefAtpNameLn | ShapeOrRefAtpNameNs | ShapeOrRefSequence

ATP_NAME_LN = Name(value='AtpNameLn')

ATP_NAME_NS = Name(value='AtpNameNs')

SEQUENCE = Name(value='sequence')

SHAPE_DEFINITION = Name(value='ShapeDefinition')

TYPE_ = Name(value='hydra.shex.syntax.ShapeOrRef')

class hydra.shex.syntax.ShapeOrRefAtpNameLn(value: T)

Bases: Node[AtpNameLn]

class hydra.shex.syntax.ShapeOrRefAtpNameNs(value: T)

Bases: Node[AtpNameNs]

class hydra.shex.syntax.ShapeOrRefSequence(value: T)

Bases: Node[ShapeExprLabel]

class hydra.shex.syntax.ShapeOrRefShapeDefinition(value: T)

Bases: Node[ShapeDefinition]

class hydra.shex.syntax.ShexDoc(list_of_directive: Sequence[Directive], sequence: object, prefix_decl: PrefixDecl)

Bases: object

ShEx grammar production: ShexDoc ::= Directive* ((NotStartAction | StartActions) Statement*)?.

class Builder(_list_of_directive: 'Sequence[Directive]' = None, _sequence: 'Optional[ShexDocSequenceOption]' = None, _prefix_decl: 'PrefixDecl' = None)

Bases: object

build()

list_of_directive(list_of_directive)

prefix_decl(prefix_decl)

sequence(sequence)

LIST_OF_DIRECTIVE = Name(value='listOfDirective')

PREFIX_DECL = Name(value='PrefixDecl')

SEQUENCE = Name(value='Sequence')

TYPE_ = Name(value='hydra.shex.syntax.ShexDoc')

static builder()

list_of_directive: Sequence[Directive]

prefix_decl: PrefixDecl

sequence: object

with_list_of_directive(list_of_directive)

with_prefix_decl(prefix_decl)

with_sequence(sequence)

class hydra.shex.syntax.ShexDocSequenceOption(alts: ShexDocSequenceOptionAlts, list_of_statement: Sequence[Statement])

Bases: object

A synthetic Hydra type representing an optional group within the ShEx ShexDoc production.

ALTS = Name(value='alts')

class Builder(_alts: 'ShexDocSequenceOptionAlts' = None, _list_of_statement: 'Sequence[Statement]' = None)

Bases: object

alts(alts)

build()

list_of_statement(list_of_statement)

LIST_OF_STATEMENT = Name(value='listOfStatement')

TYPE_ = Name(value='hydra.shex.syntax.ShexDocSequenceOption')

alts: ShexDocSequenceOptionAlts

static builder()

list_of_statement: Sequence[Statement]

with_alts(alts)

with_list_of_statement(list_of_statement)

class hydra.shex.syntax.ShexDocSequenceOptionAlts

Bases: object

ShexDocSequenceOptionAltsNotStartAction | ShexDocSequenceOptionAltsStartActions

NOT_START_ACTION = Name(value='NotStartAction')

START_ACTIONS = Name(value='StartActions')

TYPE_ = Name(value='hydra.shex.syntax.ShexDocSequenceOptionAlts')

class hydra.shex.syntax.ShexDocSequenceOptionAltsNotStartAction(value: T)

Bases: Node[NotStartAction]

class hydra.shex.syntax.ShexDocSequenceOptionAltsStartActions(value: T)

Bases: Node[StartActions]

class hydra.shex.syntax.SingleElementGroup(unary_triple_expr: UnaryTripleExpr, semi: object)

Bases: object

ShEx grammar production: SingleElementGroup ::= UnaryTripleExpr ‘;’?.

class Builder(_unary_triple_expr: 'UnaryTripleExpr' = None, _semi: 'Optional[None]' = None)

Bases: object

build()

semi(semi)

unary_triple_expr(unary_triple_expr)

SEMI = Name(value='Semi')

TYPE_ = Name(value='hydra.shex.syntax.SingleElementGroup')

UNARY_TRIPLE_EXPR = Name(value='UnaryTripleExpr')

static builder()

semi: object

unary_triple_expr: UnaryTripleExpr

with_semi(semi)

with_unary_triple_expr(unary_triple_expr)

class hydra.shex.syntax.StartActions(value: T)

Bases: Node[Sequence[CodeDecl]]

ShEx grammar production: StartActions ::= CodeDecl+.

TYPE_ = Name(value='hydra.shex.syntax.StartActions')

class hydra.shex.syntax.Statement

Bases: object

StatementDirective | StatementNotStartAction

DIRECTIVE = Name(value='Directive')

NOT_START_ACTION = Name(value='NotStartAction')

TYPE_ = Name(value='hydra.shex.syntax.Statement')

class hydra.shex.syntax.StatementDirective(value: T)

Bases: Node[Directive]

class hydra.shex.syntax.StatementNotStartAction(value: T)

Bases: Node[NotStartAction]

class hydra.shex.syntax.String

Bases: object

StringStringLiteral1 | StringStringLiteralLong1 | StringStringLiteral2 | StringStringLiteralLong2

STRING_LITERAL1 = Name(value='StringLiteral1')

STRING_LITERAL2 = Name(value='StringLiteral2')

STRING_LITERAL_LONG1 = Name(value='StringLiteralLong1')

STRING_LITERAL_LONG2 = Name(value='StringLiteralLong2')

TYPE_ = Name(value='hydra.shex.syntax.String')

class hydra.shex.syntax.StringFacet

Bases: object

StringFacetSeq | StringFacetRegexp

REGEXP = Name(value='Regexp')

SEQ = Name(value='seq')

TYPE_ = Name(value='hydra.shex.syntax.StringFacet')

class hydra.shex.syntax.StringFacetRegexp(value: T)

Bases: Node[Regexp]

class hydra.shex.syntax.StringFacetSeq(value: T)

Bases: Node[StringFacetSequence]

class hydra.shex.syntax.StringFacetSequence(string_length: StringLength, integer: Integer)

Bases: object

A synthetic Hydra type representing a sequence within the ShEx StringFacet production.

class Builder(_string_length: 'StringLength' = None, _integer: 'Integer' = None)

Bases: object

build()

integer(integer)

string_length(string_length)

INTEGER = Name(value='Integer')

STRING_LENGTH = Name(value='StringLength')

TYPE_ = Name(value='hydra.shex.syntax.StringFacetSequence')

static builder()

integer: Integer

string_length: StringLength

with_integer(integer)

with_string_length(string_length)

class hydra.shex.syntax.StringLength(*values)

Bases: Enum

ShEx grammar production: StringLength ::= ‘LENGTH’ | ‘MINLENGTH’ | ‘MAXLENGTH’.

L_E_N_G_T_H = Name(value='LENGTH')

M_A_X_L_E_N_G_T_H = Name(value='MAXLENGTH')

M_I_N_L_E_N_G_T_H = Name(value='MINLENGTH')

TYPE_ = Name(value='hydra.shex.syntax.StringLength')

class hydra.shex.syntax.StringLiteral1(value: T)

Bases: Node[Sequence[StringLiteral1Elmt]]

A component of the ShEx StringLiteral1 production.

TYPE_ = Name(value='hydra.shex.syntax.StringLiteral1')

class hydra.shex.syntax.StringLiteral1Elmt

Bases: object

StringLiteral1ElmtRegex | StringLiteral1ElmtEchar | StringLiteral1ElmtUchar

ECHAR = Name(value='Echar')

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteral1Elmt')

UCHAR = Name(value='Uchar')

class hydra.shex.syntax.StringLiteral1ElmtEchar(value: T)

Bases: Node[Echar]

class hydra.shex.syntax.StringLiteral1ElmtRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.StringLiteral1ElmtUchar(value: T)

Bases: Node[Uchar]

class hydra.shex.syntax.StringLiteral2(value: T)

Bases: Node[Sequence[StringLiteral2Elmt]]

A component of the ShEx StringLiteral2 production.

TYPE_ = Name(value='hydra.shex.syntax.StringLiteral2')

class hydra.shex.syntax.StringLiteral2Elmt

Bases: object

StringLiteral2ElmtRegex | StringLiteral2ElmtEchar | StringLiteral2ElmtUchar

ECHAR = Name(value='Echar')

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteral2Elmt')

UCHAR = Name(value='Uchar')

class hydra.shex.syntax.StringLiteral2ElmtEchar(value: T)

Bases: Node[Echar]

class hydra.shex.syntax.StringLiteral2ElmtRegex(value: T)

Bases: Node[str]

class hydra.shex.syntax.StringLiteral2ElmtUchar(value: T)

Bases: Node[Uchar]

class hydra.shex.syntax.StringLiteralLong1(value: T)

Bases: Node[Sequence[StringLiteralLong1Elmt]]

A component of the ShEx StringLiteralLong1 production.

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong1')

class hydra.shex.syntax.StringLiteralLong1Elmt

Bases: object

StringLiteralLong1ElmtSeq | StringLiteralLong1ElmtEchar | StringLiteralLong1ElmtUchar

ECHAR = Name(value='Echar')

SEQ = Name(value='seq')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong1Elmt')

UCHAR = Name(value='Uchar')

class hydra.shex.syntax.StringLiteralLong1ElmtEchar(value: T)

Bases: Node[Echar]

class hydra.shex.syntax.StringLiteralLong1ElmtSeq(value: T)

Bases: Node[StringLiteralLong1ElmtSequence]

class hydra.shex.syntax.StringLiteralLong1ElmtSequence(alts: object, regex: str)

Bases: object

A synthetic Hydra type representing a sequence within an element of the ShEx StringLiteralLong1 production.

ALTS = Name(value='Alts')

class Builder(_alts: 'Optional[StringLiteralLong1ElmtSequenceAltsOption]' = None, _regex: 'str' = None)

Bases: object

alts(alts)

build()

regex(regex)

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong1ElmtSequence')

alts: object

static builder()

regex: str

with_alts(alts)

with_regex(regex)

class hydra.shex.syntax.StringLiteralLong1ElmtSequenceAltsOption

Bases: object

StringLiteralLong1ElmtSequenceAltsOptionApos | StringLiteralLong1ElmtSequenceAltsOptionSeq

APOS = Name(value='Apos')

SEQ = Name(value='seq')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong1ElmtSequenceAltsOption')

class hydra.shex.syntax.StringLiteralLong1ElmtSequenceAltsOptionApos

Bases: object

class hydra.shex.syntax.StringLiteralLong1ElmtSequenceAltsOptionSeq(value: T)

Bases: Node[StringLiteralLong1ElmtSequenceAltsOptionSequence]

class hydra.shex.syntax.StringLiteralLong1ElmtUchar(value: T)

Bases: Node[Uchar]

class hydra.shex.syntax.StringLiteralLong2(value: T)

Bases: Node[Sequence[StringLiteralLong2Elmt]]

A component of the ShEx StringLiteralLong2 production.

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong2')

class hydra.shex.syntax.StringLiteralLong2Elmt

Bases: object

StringLiteralLong2ElmtSeq | StringLiteralLong2ElmtEchar | StringLiteralLong2ElmtUchar

ECHAR = Name(value='Echar')

SEQ = Name(value='seq')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong2Elmt')

UCHAR = Name(value='Uchar')

class hydra.shex.syntax.StringLiteralLong2ElmtEchar(value: T)

Bases: Node[Echar]

class hydra.shex.syntax.StringLiteralLong2ElmtSeq(value: T)

Bases: Node[StringLiteralLong2ElmtSequence]

class hydra.shex.syntax.StringLiteralLong2ElmtSequence(alts: object, regex: str)

Bases: object

A synthetic Hydra type representing a sequence within an element of the ShEx StringLiteralLong2 production.

ALTS = Name(value='Alts')

class Builder(_alts: 'Optional[StringLiteralLong2ElmtSequenceAltsOption]' = None, _regex: 'str' = None)

Bases: object

alts(alts)

build()

regex(regex)

REGEX = Name(value='regex')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong2ElmtSequence')

alts: object

static builder()

regex: str

with_alts(alts)

with_regex(regex)

class hydra.shex.syntax.StringLiteralLong2ElmtSequenceAltsOption

Bases: object

StringLiteralLong2ElmtSequenceAltsOptionQuot | StringLiteralLong2ElmtSequenceAltsOptionSeq

QUOT = Name(value='Quot')

SEQ = Name(value='seq')

TYPE_ = Name(value='hydra.shex.syntax.StringLiteralLong2ElmtSequenceAltsOption')

class hydra.shex.syntax.StringLiteralLong2ElmtSequenceAltsOptionQuot

Bases: object

class hydra.shex.syntax.StringLiteralLong2ElmtSequenceAltsOptionSeq(value: T)

Bases: Node[StringLiteralLong2ElmtSequenceAltsOptionSequence]

class hydra.shex.syntax.StringLiteralLong2ElmtUchar(value: T)

Bases: Node[Uchar]

class hydra.shex.syntax.StringStringLiteral1(value: T)

Bases: Node[StringLiteral1]

class hydra.shex.syntax.StringStringLiteral2(value: T)

Bases: Node[StringLiteral2]

class hydra.shex.syntax.StringStringLiteralLong1(value: T)

Bases: Node[StringLiteralLong1]

class hydra.shex.syntax.StringStringLiteralLong2(value: T)

Bases: Node[StringLiteralLong2]

class hydra.shex.syntax.TripleConstraint(sense_flags: object, predicate: Predicate, inline_shape_expression: InlineShapeExpression, cardinality: object, list_of_annotation: Sequence[Annotation], semantic_actions: SemanticActions)

Bases: object

A component of the ShEx TripleConstraint production.

class Builder(_sense_flags: 'Optional[SenseFlags]' = None, _predicate: 'Predicate' = None, _inline_shape_expression: 'InlineShapeExpression' = None, _cardinality: 'Optional[Cardinality]' = None, _list_of_annotation: 'Sequence[Annotation]' = None, _semantic_actions: 'SemanticActions' = None)

Bases: object

build()

cardinality(cardinality)

inline_shape_expression(inline_shape_expression)

list_of_annotation(list_of_annotation)

predicate(predicate)

semantic_actions(semantic_actions)

sense_flags(sense_flags)

CARDINALITY = Name(value='Cardinality')

INLINE_SHAPE_EXPRESSION = Name(value='InlineShapeExpression')

LIST_OF_ANNOTATION = Name(value='listOfAnnotation')

PREDICATE = Name(value='Predicate')

SEMANTIC_ACTIONS = Name(value='SemanticActions')

SENSE_FLAGS = Name(value='SenseFlags')

TYPE_ = Name(value='hydra.shex.syntax.TripleConstraint')

static builder()

cardinality: object

inline_shape_expression: InlineShapeExpression

list_of_annotation: Sequence[Annotation]

predicate: Predicate

semantic_actions: SemanticActions

sense_flags: object

with_cardinality(cardinality)

with_inline_shape_expression(inline_shape_expression)

with_list_of_annotation(list_of_annotation)

with_predicate(predicate)

with_semantic_actions(semantic_actions)

with_sense_flags(sense_flags)

class hydra.shex.syntax.TripleExprLabel

Bases: object

TripleExprLabelIri | TripleExprLabelBlankNode

BLANK_NODE = Name(value='BlankNode')

IRI = Name(value='Iri')

TYPE_ = Name(value='hydra.shex.syntax.TripleExprLabel')

class hydra.shex.syntax.TripleExprLabelBlankNode(value: T)

Bases: Node[BlankNode]

class hydra.shex.syntax.TripleExprLabelIri(value: T)

Bases: Node[Iri]

class hydra.shex.syntax.TripleExpression(value: T)

Bases: Node[OneOfTripleExpr]

ShEx grammar production: TripleExpression ::= OneOfTripleExpr.

TYPE_ = Name(value='hydra.shex.syntax.TripleExpression')

class hydra.shex.syntax.Uchar

Bases: object

UcharSeq | UcharSeq2

SEQ = Name(value='seq')

SEQ2 = Name(value='seq2')

TYPE_ = Name(value='hydra.shex.syntax.Uchar')

class hydra.shex.syntax.UcharSeq(value: T)

Bases: Node[UcharSequence]

class hydra.shex.syntax.UcharSeq2(value: T)

Bases: Node[UcharSequence2]

class hydra.shex.syntax.UcharSequence(hex: Hex, hex2: Hex, hex3: Hex, hex4: Hex)

Bases: object

A synthetic Hydra type representing a sequence within the ShEx Uchar production.

class Builder(_hex: 'Hex' = None, _hex2: 'Hex' = None, _hex3: 'Hex' = None, _hex4: 'Hex' = None)

Bases: object

build()

hex(hex)

hex2(hex2)

hex3(hex3)

hex4(hex4)

HEX = Name(value='Hex')

HEX2 = Name(value='Hex2')

HEX3 = Name(value='Hex3')

HEX4 = Name(value='Hex4')

TYPE_ = Name(value='hydra.shex.syntax.UcharSequence')

static builder()

hex: Hex

hex2: Hex

hex3: Hex

hex4: Hex

with_hex(hex)

with_hex2(hex2)

with_hex3(hex3)

with_hex4(hex4)

class hydra.shex.syntax.UcharSequence2(hex: Hex, hex2: Hex, hex3: Hex, hex4: Hex, hex5: Hex, hex6: Hex, hex7: Hex, hex8: Hex)

Bases: object

A synthetic Hydra type representing a secondary sequence within the ShEx Uchar production.

class Builder(_hex: 'Hex' = None, _hex2: 'Hex' = None, _hex3: 'Hex' = None, _hex4: 'Hex' = None, _hex5: 'Hex' = None, _hex6: 'Hex' = None, _hex7: 'Hex' = None, _hex8: 'Hex' = None)

Bases: object

build()

hex(hex)

hex2(hex2)

hex3(hex3)

hex4(hex4)

hex5(hex5)

hex6(hex6)

hex7(hex7)

hex8(hex8)

HEX = Name(value='Hex')

HEX2 = Name(value='Hex2')

HEX3 = Name(value='Hex3')

HEX4 = Name(value='Hex4')

HEX5 = Name(value='Hex5')

HEX6 = Name(value='Hex6')

HEX7 = Name(value='Hex7')

HEX8 = Name(value='Hex8')

TYPE_ = Name(value='hydra.shex.syntax.UcharSequence2')

static builder()

hex: Hex

hex2: Hex

hex3: Hex

hex4: Hex

hex5: Hex

hex6: Hex

hex7: Hex

hex8: Hex

with_hex(hex)

with_hex2(hex2)

with_hex3(hex3)

with_hex4(hex4)

with_hex5(hex5)

with_hex6(hex6)

with_hex7(hex7)

with_hex8(hex8)

class hydra.shex.syntax.UnaryTripleExpr

Bases: object

UnaryTripleExprSeq | UnaryTripleExprInclude

INCLUDE = Name(value='Include')

SEQ = Name(value='seq')

TYPE_ = Name(value='hydra.shex.syntax.UnaryTripleExpr')

class hydra.shex.syntax.UnaryTripleExprInclude(value: T)

Bases: Node[Include]

class hydra.shex.syntax.UnaryTripleExprSeq(value: T)

Bases: Node[UnaryTripleExprSequence]

class hydra.shex.syntax.UnaryTripleExprSequence(sequence: object, alts: UnaryTripleExprSequenceAlts)

Bases: object

A synthetic Hydra type representing a sequence within the ShEx UnaryTripleExpr production.

ALTS = Name(value='alts')

class Builder(_sequence: 'Optional[TripleExprLabel]' = None, _alts: 'UnaryTripleExprSequenceAlts' = None)

Bases: object

alts(alts)

build()

sequence(sequence)

SEQUENCE = Name(value='Sequence')

TYPE_ = Name(value='hydra.shex.syntax.UnaryTripleExprSequence')

alts: UnaryTripleExprSequenceAlts

static builder()

sequence: object

with_alts(alts)

with_sequence(sequence)

class hydra.shex.syntax.UnaryTripleExprSequenceAlts

Bases: object

UnaryTripleExprSequenceAltsTripleConstraint | UnaryTripleExprSequenceAltsBracketedTripleExpr

BRACKETED_TRIPLE_EXPR = Name(value='BracketedTripleExpr')

TRIPLE_CONSTRAINT = Name(value='TripleConstraint')

TYPE_ = Name(value='hydra.shex.syntax.UnaryTripleExprSequenceAlts')

class hydra.shex.syntax.UnaryTripleExprSequenceAltsBracketedTripleExpr(value: T)

Bases: Node[BracketedTripleExpr]

class hydra.shex.syntax.UnaryTripleExprSequenceAltsTripleConstraint(value: T)

Bases: Node[TripleConstraint]

class hydra.shex.syntax.ValueSet(value: T)

Bases: Node[Sequence[ValueSetValue]]

ShEx grammar production: ValueSet ::= ‘[’ ValueSetValue* ‘]’.

TYPE_ = Name(value='hydra.shex.syntax.ValueSet')

class hydra.shex.syntax.ValueSetValue

Bases: object

ValueSetValueIriRange | ValueSetValueLiteral

IRI_RANGE = Name(value='IriRange')

LITERAL = Name(value='Literal')

TYPE_ = Name(value='hydra.shex.syntax.ValueSetValue')

class hydra.shex.syntax.ValueSetValueIriRange(value: T)

Bases: Node[IriRange]

class hydra.shex.syntax.ValueSetValueLiteral(value: T)

Bases: Node[Literal]

class hydra.shex.syntax.XsFacet

Bases: object

XsFacetStringFacet | XsFacetNumericFacet

NUMERIC_FACET = Name(value='NumericFacet')

STRING_FACET = Name(value='StringFacet')

TYPE_ = Name(value='hydra.shex.syntax.XsFacet')

class hydra.shex.syntax.XsFacetNumericFacet(value: T)

Bases: Node[NumericFacet]

class hydra.shex.syntax.XsFacetStringFacet(value: T)

Bases: Node[StringFacet]