hydra.tinkerpop.gremlin module

A Gremlin model, based on the Apache TinkerPop Gremlin ANTLR grammar (version 3.8.1). This is a streamlined model: it preserves the semantics of the grammar (steps, predicates, arguments, literals) while collapsing pure parser-production artifacts (single-use ‘XAndY’/’XOrY’ glue types and left-recursion ‘rest’ continuations) so that the representation maps cleanly onto TinkerPop’s native traversal model.

class hydra.tinkerpop.gremlin.AsArgs(first: StringArgument, rest: Sequence[StringNullableArgument])

Bases: object

The arguments of a Gremlin as() step.

class Builder(_first: 'StringArgument' = None, _rest: 'Sequence[StringNullableArgument]' = None)

Bases: object

build()

first(first)

rest(rest)

FIRST = Name(value='first')

REST = Name(value='rest')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.AsArgs')

static builder()

first: StringArgument

rest: Sequence[StringNullableArgument]

with_first(first)

with_rest(rest)

class hydra.tinkerpop.gremlin.BarrierArgs

Bases: object

BarrierArgsConsumer | BarrierArgsInt

CONSUMER = Name(value='consumer')

INT = Name(value='int')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.BarrierArgs')

class hydra.tinkerpop.gremlin.BarrierArgsConsumer(value: T): Bases: Node[TraversalSackMethodArgument]

class hydra.tinkerpop.gremlin.BarrierArgsInt(value: T): Bases: Node[IntegerArgument]

class hydra.tinkerpop.gremlin.BooleanArgument

Bases: object

BooleanArgumentValue | BooleanArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.BooleanArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.BooleanArgumentValue(value: T): Bases: Node[bool]

class hydra.tinkerpop.gremlin.BooleanArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.ByArgs

Bases: object

ByArgsOrder | ByArgsToken | ByArgsOther

ORDER = Name(value='order')

OTHER = Name(value='other')

TOKEN = Name(value='token')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ByArgs')

class hydra.tinkerpop.gremlin.ByArgsOrder(value: T): Bases: Node[TraversalOrderArgument]

class hydra.tinkerpop.gremlin.ByArgsOther(value: T): Bases: Node[ByOtherArgs]

class hydra.tinkerpop.gremlin.ByArgsToken(value: T): Bases: Node[TraversalTokenArgument]

class hydra.tinkerpop.gremlin.ByOtherArgs

Bases: object

ByOtherArgsComparator | ByOtherArgsFunction | ByOtherArgsString | ByOtherArgsTraversal

COMPARATOR = Name(value='comparator')

FUNCTION = Name(value='function')

STRING = Name(value='string')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ByOtherArgs')

class hydra.tinkerpop.gremlin.ByOtherArgsComparator(value: T): Bases: Node[Optional[TraversalComparatorArgument]]

class hydra.tinkerpop.gremlin.ByOtherArgsFunction(value: T): Bases: Node[TraversalFunctionArgument]

class hydra.tinkerpop.gremlin.ByOtherArgsString(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.ByOtherArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.CardinalityAndMap(cardinality: TraversalCardinalityArgument, object: GenericLiteralMapNullableArgument)

Bases: object

A cardinality value together with a property map, as used in a merge step.

class Builder(_cardinality: 'TraversalCardinalityArgument' = None, _object: 'GenericLiteralMapNullableArgument' = None)

Bases: object

build()

cardinality(cardinality)

object(object)

CARDINALITY = Name(value='cardinality')

OBJECT = Name(value='object')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.CardinalityAndMap')

static builder()

cardinality: TraversalCardinalityArgument

object: GenericLiteralMapNullableArgument

with_cardinality(cardinality)

with_object(object)

class hydra.tinkerpop.gremlin.CardinalityAndObjects(cardinality: TraversalCardinalityArgument, objects: Sequence[GenericLiteralArgument])

Bases: object

A cardinality value together with key-value object pairs, as used in a property() step.

class Builder(_cardinality: 'TraversalCardinalityArgument' = None, _objects: 'Sequence[GenericLiteralArgument]' = None)

Bases: object

build()

cardinality(cardinality)

objects(objects)

CARDINALITY = Name(value='cardinality')

OBJECTS = Name(value='objects')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.CardinalityAndObjects')

static builder()

cardinality: TraversalCardinalityArgument

objects: Sequence[GenericLiteralArgument]

with_cardinality(cardinality)

with_objects(objects)

class hydra.tinkerpop.gremlin.ChainedTraversal(value: T)

Bases: Node[Sequence[TraversalMethod]]

A Gremlin traversal expressed as a chain of method calls.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ChainedTraversal')

class hydra.tinkerpop.gremlin.ChooseArgs

Bases: object

ChooseArgsFunction | ChooseArgsPredicateTraversal | ChooseArgsTraversal

FUNCTION = Name(value='function')

PREDICATE_TRAVERSAL = Name(value='predicateTraversal')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ChooseArgs')

class hydra.tinkerpop.gremlin.ChooseArgsFunction(value: T): Bases: Node[TraversalFunctionArgument]

class hydra.tinkerpop.gremlin.ChooseArgsPredicateTraversal(value: T): Bases: Node[PredicateOrTraversalChoice]

class hydra.tinkerpop.gremlin.ChooseArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.ConcatArgs

Bases: object

ConcatArgsTraversal | ConcatArgsString

STRING = Name(value='string')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ConcatArgs')

class hydra.tinkerpop.gremlin.ConcatArgsString(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.ConcatArgsTraversal(value: T): Bases: Node[Sequence[NestedTraversal]]

class hydra.tinkerpop.gremlin.Configuration(key: KeywordOrIdentifier, value: GenericLiteralArgument)

Bases: object

A Gremlin configuration map.

class Builder(_key: 'KeywordOrIdentifier' = None, _value: 'GenericLiteralArgument' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.Configuration')

VALUE = Name(value='value')

static builder()

key: KeywordOrIdentifier

value: GenericLiteralArgument

with_key(key)

with_value(value)

class hydra.tinkerpop.gremlin.ConnectedComponentConstants(*values)

Bases: Enum

The named constants used by the Gremlin connectedComponent() step.

COMPONENT = Name(value='component')

EDGES = Name(value='edges')

PROPERTY_NAME = Name(value='propertyName')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ConnectedComponentConstants')

class hydra.tinkerpop.gremlin.DateAddArgs(unit: TraversalDTArgument, duration: IntegerArgument)

Bases: object

The arguments of a Gremlin dateAdd() step.

class Builder(_unit: 'TraversalDTArgument' = None, _duration: 'IntegerArgument' = None)

Bases: object

build()

duration(duration)

unit(unit)

DURATION = Name(value='duration')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.DateAddArgs')

UNIT = Name(value='unit')

static builder()

duration: IntegerArgument

unit: TraversalDTArgument

with_duration(duration)

with_unit(unit)

class hydra.tinkerpop.gremlin.DateArgument

Bases: object

DateArgumentValue | DateArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.DateArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.DateArgumentValue(value: T): Bases: Node[DateLiteral]

class hydra.tinkerpop.gremlin.DateArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.DateDiffArgs

Bases: object

DateDiffArgsTraversal | DateDiffArgsDate

DATE = Name(value='date')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.DateDiffArgs')

class hydra.tinkerpop.gremlin.DateDiffArgsDate(value: T): Bases: Node[DateArgument]

class hydra.tinkerpop.gremlin.DateDiffArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.DateLiteral(value: T)

Bases: Node[Optional[StringArgument]]

A Gremlin date literal.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.DateLiteral')

class hydra.tinkerpop.gremlin.DedupArgs

Bases: object

DedupArgsScopeString | DedupArgsString

SCOPE_STRING = Name(value='scopeString')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.DedupArgs')

class hydra.tinkerpop.gremlin.DedupArgsScopeString(value: T): Bases: Node[ScopeStringArgs]

class hydra.tinkerpop.gremlin.DedupArgsString(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.DirectionAndVarargs(direction: TraversalDirectionArgument, varargs: Sequence[StringNullableArgument])

Bases: object

A direction argument together with a variadic list of further arguments.

class Builder(_direction: 'TraversalDirectionArgument' = None, _varargs: 'Sequence[StringNullableArgument]' = None)

Bases: object

build()

direction(direction)

varargs(varargs)

DIRECTION = Name(value='direction')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.DirectionAndVarargs')

VARARGS = Name(value='varargs')

static builder()

direction: TraversalDirectionArgument

varargs: Sequence[StringNullableArgument]

with_direction(direction)

with_varargs(varargs)

class hydra.tinkerpop.gremlin.FloatArgument

Bases: object

FloatArgumentValue | FloatArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.FloatArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.FloatArgumentValue(value: T): Bases: Node[FloatLiteral]

class hydra.tinkerpop.gremlin.FloatArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.FloatLiteral

Bases: object

FloatLiteralFloat | FloatLiteralDouble | FloatLiteralBig

BIG = Name(value='big')

DOUBLE = Name(value='double')

FLOAT = Name(value='float')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.FloatLiteral')

class hydra.tinkerpop.gremlin.FloatLiteralBig(value: T): Bases: Node[Decimal]

class hydra.tinkerpop.gremlin.FloatLiteralDouble(value: T): Bases: Node[float]

class hydra.tinkerpop.gremlin.FloatLiteralFloat(value: T): Bases: Node[float]

class hydra.tinkerpop.gremlin.FoldArgs(seed: GenericLiteralArgument, bi_function: TraversalBiFunctionArgument)

Bases: object

The arguments of a Gremlin fold() step.

BI_FUNCTION = Name(value='biFunction')

class Builder(_seed: 'GenericLiteralArgument' = None, _bi_function: 'TraversalBiFunctionArgument' = None)

Bases: object

bi_function(bi_function)

build()

seed(seed)

SEED = Name(value='seed')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.FoldArgs')

bi_function: TraversalBiFunctionArgument

static builder()

seed: GenericLiteralArgument

with_bi_function(bi_function)

with_seed(seed)

class hydra.tinkerpop.gremlin.FromArgs

Bases: object

FromArgsString | FromArgsVertex | FromArgsTraversal

STRING = Name(value='string')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.FromArgs')

VERTEX = Name(value='vertex')

class hydra.tinkerpop.gremlin.FromArgsString(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.FromArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.FromArgsVertex(value: T): Bases: Node[StructureVertexArgument]

class hydra.tinkerpop.gremlin.GenericLiteral

Bases: object

BOOLEAN = Name(value='boolean')

DATE = Name(value='date')

GENERIC_LITERAL_COLLECTION = Name(value='genericLiteralCollection')

GENERIC_LITERAL_MAP = Name(value='genericLiteralMap')

GENERIC_LITERAL_RANGE = Name(value='genericLiteralRange')

GENERIC_LITERAL_SET = Name(value='genericLiteralSet')

INF = Name(value='inf')

NAN = Name(value='nan')

NESTED_TRAVERSAL = Name(value='nestedTraversal')

NULL = Name(value='null')

NUMERIC = Name(value='numeric')

STRING = Name(value='string')

STRUCTURE_VERTEX = Name(value='structureVertex')

TERMINATED_TRAVERSAL = Name(value='terminatedTraversal')

TRAVERSAL_CARDINALITY = Name(value='traversalCardinality')

TRAVERSAL_DIRECTION = Name(value='traversalDirection')

TRAVERSAL_D_T = Name(value='traversalDT')

TRAVERSAL_G_TYPE = Name(value='traversalGType')

TRAVERSAL_MERGE = Name(value='traversalMerge')

TRAVERSAL_PICK = Name(value='traversalPick')

TRAVERSAL_TOKEN = Name(value='traversalToken')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteral')

class hydra.tinkerpop.gremlin.GenericLiteralArgument

Bases: object

GenericLiteralArgumentValue | GenericLiteralArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.GenericLiteralArgumentValue(value: T): Bases: Node[GenericLiteral]

class hydra.tinkerpop.gremlin.GenericLiteralArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.GenericLiteralBoolean(value: T): Bases: Node[bool]

class hydra.tinkerpop.gremlin.GenericLiteralCollection(value: T)

Bases: Node[Sequence[GenericLiteral]]

A Gremlin literal collection: a list, set, or map literal.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralCollection')

class hydra.tinkerpop.gremlin.GenericLiteralDate(value: T): Bases: Node[DateLiteral]

class hydra.tinkerpop.gremlin.GenericLiteralGenericLiteralCollection(value: T): Bases: Node[GenericLiteralCollection]

class hydra.tinkerpop.gremlin.GenericLiteralGenericLiteralMap(value: T): Bases: Node[GenericLiteralMap]

class hydra.tinkerpop.gremlin.GenericLiteralGenericLiteralRange(value: T): Bases: Node[GenericLiteralRange]

class hydra.tinkerpop.gremlin.GenericLiteralGenericLiteralSet(value: T): Bases: Node[GenericLiteralSet]

class hydra.tinkerpop.gremlin.GenericLiteralInf: Bases: object

class hydra.tinkerpop.gremlin.GenericLiteralList(value: T)

Bases: Node[Sequence[GenericLiteral]]

A Gremlin list literal.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralList')

class hydra.tinkerpop.gremlin.GenericLiteralListArgument

Bases: object

GenericLiteralListArgumentValue | GenericLiteralListArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralListArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.GenericLiteralListArgumentValue(value: T): Bases: Node[GenericLiteralList]

class hydra.tinkerpop.gremlin.GenericLiteralListArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.GenericLiteralMap(value: T)

Bases: Node[Sequence[MapEntry]]

A Gremlin map literal.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralMap')

class hydra.tinkerpop.gremlin.GenericLiteralMapArgument

Bases: object

GenericLiteralMapArgumentValue | GenericLiteralMapArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralMapArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.GenericLiteralMapArgumentValue(value: T): Bases: Node[GenericLiteralMap]

class hydra.tinkerpop.gremlin.GenericLiteralMapArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.GenericLiteralMapNullableArgument

Bases: object

GenericLiteralMapNullableArgumentValue | GenericLiteralMapNullableArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralMapNullableArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.GenericLiteralMapNullableArgumentValue(value: T): Bases: Node[Optional[GenericLiteralMap]]

class hydra.tinkerpop.gremlin.GenericLiteralMapNullableArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.GenericLiteralNan: Bases: object

class hydra.tinkerpop.gremlin.GenericLiteralNestedTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.GenericLiteralNull: Bases: object

class hydra.tinkerpop.gremlin.GenericLiteralNumeric(value: T): Bases: Node[NumericLiteral]

class hydra.tinkerpop.gremlin.GenericLiteralRange

Bases: object

GenericLiteralRangeInteger | GenericLiteralRangeString

INTEGER = Name(value='integer')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralRange')

class hydra.tinkerpop.gremlin.GenericLiteralRangeInteger(value: T): Bases: Node[IntegerRange]

class hydra.tinkerpop.gremlin.GenericLiteralRangeString(value: T): Bases: Node[StringRange]

class hydra.tinkerpop.gremlin.GenericLiteralSet(value: T)

Bases: Node[Sequence[GenericLiteral]]

A Gremlin set literal.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.GenericLiteralSet')

class hydra.tinkerpop.gremlin.GenericLiteralString(value: T): Bases: Node[str]

class hydra.tinkerpop.gremlin.GenericLiteralStructureVertex(value: T): Bases: Node[StructureVertex]

class hydra.tinkerpop.gremlin.GenericLiteralTerminatedTraversal(value: T): Bases: Node[TerminatedTraversal]

class hydra.tinkerpop.gremlin.GenericLiteralTraversalCardinality(value: T): Bases: Node[TraversalCardinality]

class hydra.tinkerpop.gremlin.GenericLiteralTraversalDT(value: T): Bases: Node[TraversalDT]

class hydra.tinkerpop.gremlin.GenericLiteralTraversalDirection(value: T): Bases: Node[TraversalDirection]

class hydra.tinkerpop.gremlin.GenericLiteralTraversalGType(value: T): Bases: Node[TraversalGType]

class hydra.tinkerpop.gremlin.GenericLiteralTraversalMerge(value: T): Bases: Node[TraversalMerge]

class hydra.tinkerpop.gremlin.GenericLiteralTraversalPick(value: T): Bases: Node[TraversalPick]

class hydra.tinkerpop.gremlin.GenericLiteralTraversalToken(value: T): Bases: Node[TraversalToken]

class hydra.tinkerpop.gremlin.HasArgs

Bases: object

HasArgsString | HasArgsTraversalToken

STRING = Name(value='string')

TRAVERSAL_TOKEN = Name(value='traversalToken')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.HasArgs')

class hydra.tinkerpop.gremlin.HasArgsString(value: T): Bases: Node[HasArgsWithKey]

class hydra.tinkerpop.gremlin.HasArgsTraversalToken(value: T): Bases: Node[HasArgsWithToken]

class hydra.tinkerpop.gremlin.HasArgsWithKey(key: StringNullableArgument, value: object)

Bases: object

The arguments of a Gremlin has() step qualified by a property key.

class Builder(_key: 'StringNullableArgument' = None, _value: 'Optional[HasValueClause]' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.HasArgsWithKey')

VALUE = Name(value='value')

static builder()

key: StringNullableArgument

value: object

with_key(key)

with_value(value)

class hydra.tinkerpop.gremlin.HasArgsWithToken(token: TraversalTokenArgument, value: HasValueClause)

Bases: object

The arguments of a Gremlin has() step qualified by a traversal token.

class Builder(_token: 'TraversalTokenArgument' = None, _value: 'HasValueClause' = None)

Bases: object

build()

token(token)

value(value)

TOKEN = Name(value='token')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.HasArgsWithToken')

VALUE = Name(value='value')

static builder()

token: TraversalTokenArgument

value: HasValueClause

with_token(token)

with_value(value)

class hydra.tinkerpop.gremlin.HasValueClause

Bases: object

HasValueClauseObject | HasValueClausePredicate | HasValueClauseTraversal | HasValueClauseKeyObject | HasValueClauseKeyPredicate

KEY_OBJECT = Name(value='keyObject')

KEY_PREDICATE = Name(value='keyPredicate')

OBJECT = Name(value='object')

PREDICATE = Name(value='predicate')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.HasValueClause')

class hydra.tinkerpop.gremlin.HasValueClauseKeyObject(value: T): Bases: Node[StringKeyAndObject]

class hydra.tinkerpop.gremlin.HasValueClauseKeyPredicate(value: T): Bases: Node[StringKeyAndPredicate]

class hydra.tinkerpop.gremlin.HasValueClauseObject(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.HasValueClausePredicate(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.HasValueClauseTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.Identifier(value: T)

Bases: Node[str]

A Gremlin identifier.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.Identifier')

class hydra.tinkerpop.gremlin.IntegerArgument

Bases: object

IntegerArgumentValue | IntegerArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.IntegerArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.IntegerArgumentValue(value: T): Bases: Node[IntegerLiteral]

class hydra.tinkerpop.gremlin.IntegerArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.IntegerLiteral

Bases: object

IntegerLiteralByte | IntegerLiteralShort | IntegerLiteralInt | IntegerLiteralLong | IntegerLiteralBig

BIG = Name(value='big')

BYTE = Name(value='byte')

INT = Name(value='int')

LONG = Name(value='long')

SHORT = Name(value='short')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.IntegerLiteral')

class hydra.tinkerpop.gremlin.IntegerLiteralBig(value: T): Bases: Node[int]

class hydra.tinkerpop.gremlin.IntegerLiteralByte(value: T): Bases: Node[int]

class hydra.tinkerpop.gremlin.IntegerLiteralInt(value: T): Bases: Node[int]

class hydra.tinkerpop.gremlin.IntegerLiteralLong(value: T): Bases: Node[int]

class hydra.tinkerpop.gremlin.IntegerLiteralShort(value: T): Bases: Node[int]

class hydra.tinkerpop.gremlin.IntegerRange(left: IntegerLiteral, right: IntegerLiteral)

Bases: object

A Gremlin integer range expression.

class Builder(_left: 'IntegerLiteral' = None, _right: 'IntegerLiteral' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.IntegerRange')

static builder()

left: IntegerLiteral

right: IntegerLiteral

with_left(left)

with_right(right)

class hydra.tinkerpop.gremlin.IoOptionsKeys(*values)

Bases: Enum

The named keys accepted by a Gremlin io() step’s options.

READER = Name(value='reader')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.IoOptionsKeys')

WRITER = Name(value='writer')

class hydra.tinkerpop.gremlin.IoOptionsValues(*values)

Bases: Enum

The named values accepted by a Gremlin io() step’s options.

GRAPHML = Name(value='graphml')

GRAPHSON = Name(value='graphson')

GRYO = Name(value='gryo')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.IoOptionsValues')

class hydra.tinkerpop.gremlin.Keyword(*values)

Bases: Enum

A reserved Gremlin keyword.

EDGES = Name(value='edges')

KEYS = Name(value='keys')

NEW = Name(value='new')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.Keyword')

VALUES = Name(value='values')

class hydra.tinkerpop.gremlin.KeywordOrIdentifier

Bases: object

KeywordOrIdentifierKeyword | KeywordOrIdentifierIdentifier

IDENTIFIER = Name(value='identifier')

KEYWORD = Name(value='keyword')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.KeywordOrIdentifier')

class hydra.tinkerpop.gremlin.KeywordOrIdentifierIdentifier(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.KeywordOrIdentifierKeyword(value: T): Bases: Node[Keyword]

class hydra.tinkerpop.gremlin.MapEntry

Bases: object

MapEntryKey | MapEntryValue

KEY = Name(value='key')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.MapEntry')

VALUE = Name(value='value')

class hydra.tinkerpop.gremlin.MapEntryKey(value: T): Bases: Node[MapKey]

class hydra.tinkerpop.gremlin.MapEntryValue(value: T): Bases: Node[GenericLiteral]

class hydra.tinkerpop.gremlin.MapKey

Bases: object

COLLECTION = Name(value='collection')

IDENTIFIER = Name(value='identifier')

KEYWORD = Name(value='keyword')

MAP = Name(value='map')

NUMERIC = Name(value='numeric')

SET = Name(value='set')

STRING = Name(value='string')

TRAVERSAL_DIRECTION = Name(value='traversalDirection')

TRAVERSAL_TOKEN = Name(value='traversalToken')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.MapKey')

class hydra.tinkerpop.gremlin.MapKeyCollection(value: T): Bases: Node[GenericLiteralCollection]

class hydra.tinkerpop.gremlin.MapKeyIdentifier(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.MapKeyKeyword(value: T): Bases: Node[Keyword]

class hydra.tinkerpop.gremlin.MapKeyMap(value: T): Bases: Node[GenericLiteralMap]

class hydra.tinkerpop.gremlin.MapKeyNumeric(value: T): Bases: Node[NumericLiteral]

class hydra.tinkerpop.gremlin.MapKeySet(value: T): Bases: Node[GenericLiteralSet]

class hydra.tinkerpop.gremlin.MapKeyString(value: T): Bases: Node[str]

class hydra.tinkerpop.gremlin.MapKeyTraversalDirection(value: T): Bases: Node[TraversalDirection]

class hydra.tinkerpop.gremlin.MapKeyTraversalToken(value: T): Bases: Node[TraversalToken]

class hydra.tinkerpop.gremlin.MergeArgs

Bases: object

MergeArgsMap | MergeArgsTraversal

MAP = Name(value='map')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.MergeArgs')

class hydra.tinkerpop.gremlin.MergeArgsMap(value: T): Bases: Node[GenericLiteralMapNullableArgument]

class hydra.tinkerpop.gremlin.MergeArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.MergeMapOption(merge: TraversalMergeArgument, map: GenericLiteralMapNullableArgument, cardinality: object)

Bases: object

A merge option expressed as a map.

class Builder(_merge: 'TraversalMergeArgument' = None, _map: 'GenericLiteralMapNullableArgument' = None, _cardinality: 'Optional[TraversalCardinality]' = None)

Bases: object

build()

cardinality(cardinality)

map(map)

merge(merge)

CARDINALITY = Name(value='cardinality')

MAP = Name(value='map')

MERGE = Name(value='merge')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.MergeMapOption')

static builder()

cardinality: object

map: GenericLiteralMapNullableArgument

merge: TraversalMergeArgument

with_cardinality(cardinality)

with_map(map)

with_merge(merge)

class hydra.tinkerpop.gremlin.MergeTraversalOption(merge: TraversalMergeArgument, traversal: NestedTraversal)

Bases: object

A merge option expressed as a nested traversal.

class Builder(_merge: 'TraversalMergeArgument' = None, _traversal: 'NestedTraversal' = None)

Bases: object

build()

merge(merge)

traversal(traversal)

MERGE = Name(value='merge')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.MergeTraversalOption')

static builder()

merge: TraversalMergeArgument

traversal: NestedTraversal

with_merge(merge)

with_traversal(traversal)

class hydra.tinkerpop.gremlin.NestedTraversal

Bases: object

NestedTraversalRoot | NestedTraversalChained | NestedTraversalAnonymous

ANONYMOUS = Name(value='anonymous')

CHAINED = Name(value='chained')

ROOT = Name(value='root')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.NestedTraversal')

class hydra.tinkerpop.gremlin.NestedTraversalAnonymous(value: T): Bases: Node[ChainedTraversal]

class hydra.tinkerpop.gremlin.NestedTraversalChained(value: T): Bases: Node[ChainedTraversal]

class hydra.tinkerpop.gremlin.NestedTraversalRoot(value: T): Bases: Node[RootTraversal]

class hydra.tinkerpop.gremlin.NumericArgument

Bases: object

NumericArgumentValue | NumericArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.NumericArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.NumericArgumentValue(value: T): Bases: Node[NumericLiteral]

class hydra.tinkerpop.gremlin.NumericArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.NumericLiteral

Bases: object

NumericLiteralInteger | NumericLiteralFloat

FLOAT = Name(value='float')

INTEGER = Name(value='integer')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.NumericLiteral')

class hydra.tinkerpop.gremlin.NumericLiteralFloat(value: T): Bases: Node[FloatLiteral]

class hydra.tinkerpop.gremlin.NumericLiteralInteger(value: T): Bases: Node[IntegerLiteral]

class hydra.tinkerpop.gremlin.ObjectAndTraversal(object: GenericLiteralArgument, traversal: NestedTraversal)

Bases: object

An object argument together with a nested traversal.

class Builder(_object: 'GenericLiteralArgument' = None, _traversal: 'NestedTraversal' = None)

Bases: object

build()

object(object)

traversal(traversal)

OBJECT = Name(value='object')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ObjectAndTraversal')

static builder()

object: GenericLiteralArgument

traversal: NestedTraversal

with_object(object)

with_traversal(traversal)

class hydra.tinkerpop.gremlin.OptionArgs

Bases: object

OptionArgsPredicateTraversal | OptionArgsMergeMap | OptionArgsMergeTraversal | OptionArgsObjectTraversal | OptionArgsTraversal

MERGE_MAP = Name(value='mergeMap')

MERGE_TRAVERSAL = Name(value='mergeTraversal')

OBJECT_TRAVERSAL = Name(value='objectTraversal')

PREDICATE_TRAVERSAL = Name(value='predicateTraversal')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.OptionArgs')

class hydra.tinkerpop.gremlin.OptionArgsMergeMap(value: T): Bases: Node[MergeMapOption]

class hydra.tinkerpop.gremlin.OptionArgsMergeTraversal(value: T): Bases: Node[MergeTraversalOption]

class hydra.tinkerpop.gremlin.OptionArgsObjectTraversal(value: T): Bases: Node[ObjectAndTraversal]

class hydra.tinkerpop.gremlin.OptionArgsPredicateTraversal(value: T): Bases: Node[PredicateAndTraversal]

class hydra.tinkerpop.gremlin.OptionArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.PageRankConstants(*values)

Bases: Enum

The named constants used by the Gremlin pageRank() step.

EDGES = Name(value='edges')

PROPERTY_NAME = Name(value='propertyName')

TIMES = Name(value='times')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PageRankConstants')

class hydra.tinkerpop.gremlin.PeerPressureConstants(*values)

Bases: Enum

The named constants used by the Gremlin peerPressure() step.

EDGES = Name(value='edges')

PROPERTY_NAME = Name(value='propertyName')

TIMES = Name(value='times')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PeerPressureConstants')

class hydra.tinkerpop.gremlin.PopAndTraversal(pop: TraversalPopArgument, traversal: NestedTraversal)

Bases: object

A Pop value together with a nested traversal.

class Builder(_pop: 'TraversalPopArgument' = None, _traversal: 'NestedTraversal' = None)

Bases: object

build()

pop(pop)

traversal(traversal)

POP = Name(value='pop')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PopAndTraversal')

static builder()

pop: TraversalPopArgument

traversal: NestedTraversal

with_pop(pop)

with_traversal(traversal)

class hydra.tinkerpop.gremlin.PredicateAndTraversal(predicate: TraversalPredicate, traversal: NestedTraversal)

Bases: object

A predicate together with a nested traversal.

class Builder(_predicate: 'TraversalPredicate' = None, _traversal: 'NestedTraversal' = None)

Bases: object

build()

predicate(predicate)

traversal(traversal)

PREDICATE = Name(value='predicate')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PredicateAndTraversal')

static builder()

predicate: TraversalPredicate

traversal: NestedTraversal

with_predicate(predicate)

with_traversal(traversal)

class hydra.tinkerpop.gremlin.PredicateOrObject

Bases: object

PredicateOrObjectPredicate | PredicateOrObjectObject

OBJECT = Name(value='object')

PREDICATE = Name(value='predicate')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PredicateOrObject')

class hydra.tinkerpop.gremlin.PredicateOrObjectObject(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.PredicateOrObjectPredicate(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.PredicateOrObjects

Bases: object

PredicateOrObjectsPredicate | PredicateOrObjectsObjects

OBJECTS = Name(value='objects')

PREDICATE = Name(value='predicate')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PredicateOrObjects')

class hydra.tinkerpop.gremlin.PredicateOrObjectsObjects(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.PredicateOrObjectsPredicate(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.PredicateOrStrings

Bases: object

PredicateOrStringsPredicate | PredicateOrStringsStrings

PREDICATE = Name(value='predicate')

STRINGS = Name(value='strings')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PredicateOrStrings')

class hydra.tinkerpop.gremlin.PredicateOrStringsPredicate(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.PredicateOrStringsStrings(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.PredicateOrTraversal

Bases: object

PredicateOrTraversalPredicate | PredicateOrTraversalTraversal

PREDICATE = Name(value='predicate')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PredicateOrTraversal')

class hydra.tinkerpop.gremlin.PredicateOrTraversalChoice(predicate: TraversalPredicate, true: NestedTraversal, false: object)

Bases: object

A choice between a traversal predicate and a nested traversal, used in filter steps.

class Builder(_predicate: 'TraversalPredicate' = None, _true: 'NestedTraversal' = None, _false: 'Optional[NestedTraversal]' = None)

Bases: object

build()

false(false)

predicate(predicate)

true(true)

FALSE = Name(value='false')

PREDICATE = Name(value='predicate')

TRUE = Name(value='true')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PredicateOrTraversalChoice')

static builder()

false: object

predicate: TraversalPredicate

true: NestedTraversal

with_false(false)

with_predicate(predicate)

with_true(true)

class hydra.tinkerpop.gremlin.PredicateOrTraversalPredicate(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.PredicateOrTraversalTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.PropertyArgs

Bases: object

PropertyArgsCardinalityObjects | PropertyArgsObjects | PropertyArgsObject | PropertyArgsCardinalityObject

CARDINALITY_OBJECT = Name(value='cardinalityObject')

CARDINALITY_OBJECTS = Name(value='cardinalityObjects')

OBJECT = Name(value='object')

OBJECTS = Name(value='objects')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.PropertyArgs')

class hydra.tinkerpop.gremlin.PropertyArgsCardinalityObject(value: T): Bases: Node[CardinalityAndMap]

class hydra.tinkerpop.gremlin.PropertyArgsCardinalityObjects(value: T): Bases: Node[CardinalityAndObjects]

class hydra.tinkerpop.gremlin.PropertyArgsObject(value: T): Bases: Node[GenericLiteralMapNullableArgument]

class hydra.tinkerpop.gremlin.PropertyArgsObjects(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.Query

Bases: object

QueryTraversalSource | QueryRootTraversal | QueryToString | QueryEmpty

EMPTY = Name(value='empty')

ROOT_TRAVERSAL = Name(value='rootTraversal')

TO_STRING = Name(value='toString')

TRAVERSAL_SOURCE = Name(value='traversalSource')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.Query')

class hydra.tinkerpop.gremlin.QueryEmpty: Bases: object

class hydra.tinkerpop.gremlin.QueryList(value: T)

Bases: Node[Sequence[Query]]

A sequence of Gremlin queries.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.QueryList')

class hydra.tinkerpop.gremlin.QueryRootTraversal(value: T): Bases: Node[RootTraversalQuery]

class hydra.tinkerpop.gremlin.QueryToString: Bases: object

class hydra.tinkerpop.gremlin.QueryTraversalSource(value: T): Bases: Node[TraversalSourceQuery]

class hydra.tinkerpop.gremlin.RangeArgs(scope: object, min: IntegerArgument, max: IntegerArgument)

Bases: object

The arguments of a Gremlin range() step.

class Builder(_scope: 'Optional[TraversalScopeArgument]' = None, _min: 'IntegerArgument' = None, _max: 'IntegerArgument' = None)

Bases: object

build()

max(max)

min(min)

scope(scope)

MAX = Name(value='max')

MIN = Name(value='min')

SCOPE = Name(value='scope')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.RangeArgs')

static builder()

max: IntegerArgument

min: IntegerArgument

scope: object

with_max(max)

with_min(min)

with_scope(scope)

class hydra.tinkerpop.gremlin.RangeArgument(min: GenericLiteralArgument, max: GenericLiteralArgument)

Bases: object

A Gremlin range-valued argument.

class Builder(_min: 'GenericLiteralArgument' = None, _max: 'GenericLiteralArgument' = None)

Bases: object

build()

max(max)

min(min)

MAX = Name(value='max')

MIN = Name(value='min')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.RangeArgument')

static builder()

max: GenericLiteralArgument

min: GenericLiteralArgument

with_max(max)

with_min(min)

class hydra.tinkerpop.gremlin.RepeatArgs(string: object, traversal: NestedTraversal)

Bases: object

The arguments of a Gremlin repeat() step.

class Builder(_string: 'Optional[StringArgument]' = None, _traversal: 'NestedTraversal' = None)

Bases: object

build()

string(string)

traversal(traversal)

STRING = Name(value='string')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.RepeatArgs')

static builder()

string: object

traversal: NestedTraversal

with_string(string)

with_traversal(traversal)

class hydra.tinkerpop.gremlin.ReplaceArgs(scope: object, from_: StringNullableArgument, to: StringNullableArgument)

Bases: object

The arguments of a Gremlin replace() step.

class Builder(_scope: 'Optional[TraversalScopeArgument]' = None, _from_: 'StringNullableArgument' = None, _to: 'StringNullableArgument' = None)

Bases: object

build()

from_(from_)

scope(scope)

to(to)

FROM = Name(value='from')

SCOPE = Name(value='scope')

TO = Name(value='to')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ReplaceArgs')

static builder()

from_: StringNullableArgument

scope: object

to: StringNullableArgument

with_from_(from_)

with_scope(scope)

with_to(to)

class hydra.tinkerpop.gremlin.RootTraversal(source: TraversalSource, spawn_method: TraversalSourceSpawnMethod, chained: Sequence[TraversalMethod])

Bases: object

A Gremlin root-level traversal expression.

class Builder(_source: 'TraversalSource' = None, _spawn_method: 'TraversalSourceSpawnMethod' = None, _chained: 'Sequence[TraversalMethod]' = None)

Bases: object

build()

chained(chained)

source(source)

spawn_method(spawn_method)

CHAINED = Name(value='chained')

SOURCE = Name(value='source')

SPAWN_METHOD = Name(value='spawnMethod')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.RootTraversal')

static builder()

chained: Sequence[TraversalMethod]

source: TraversalSource

spawn_method: TraversalSourceSpawnMethod

with_chained(chained)

with_source(source)

with_spawn_method(spawn_method)

class hydra.tinkerpop.gremlin.RootTraversalQuery(root: RootTraversal, terminal_method: object)

Bases: object

A query rooted at a Gremlin traversal source.

class Builder(_root: 'RootTraversal' = None, _terminal_method: 'Optional[TraversalTerminalMethod]' = None)

Bases: object

build()

root(root)

terminal_method(terminal_method)

ROOT = Name(value='root')

TERMINAL_METHOD = Name(value='terminalMethod')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.RootTraversalQuery')

static builder()

root: RootTraversal

terminal_method: object

with_root(root)

with_terminal_method(terminal_method)

class hydra.tinkerpop.gremlin.SampleByScope(scope: object, integer: IntegerArgument)

Bases: object

The scope argument of a Gremlin sample() step.

class Builder(_scope: 'Optional[TraversalScopeArgument]' = None, _integer: 'IntegerArgument' = None)

Bases: object

build()

integer(integer)

scope(scope)

INTEGER = Name(value='integer')

SCOPE = Name(value='scope')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.SampleByScope')

static builder()

integer: IntegerArgument

scope: object

with_integer(integer)

with_scope(scope)

class hydra.tinkerpop.gremlin.ScopeAndInteger(scope: object, integer: IntegerArgument)

Bases: object

A Scope value together with an integer argument.

class Builder(_scope: 'Optional[TraversalScopeArgument]' = None, _integer: 'IntegerArgument' = None)

Bases: object

build()

integer(integer)

scope(scope)

INTEGER = Name(value='integer')

SCOPE = Name(value='scope')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ScopeAndInteger')

static builder()

integer: IntegerArgument

scope: object

with_integer(integer)

with_scope(scope)

class hydra.tinkerpop.gremlin.ScopeStringArgs(scope: TraversalScopeArgument, strings: Sequence[StringNullableArgument])

Bases: object

A Scope value together with string arguments.

class Builder(_scope: 'TraversalScopeArgument' = None, _strings: 'Sequence[StringNullableArgument]' = None)

Bases: object

build()

scope(scope)

strings(strings)

SCOPE = Name(value='scope')

STRINGS = Name(value='strings')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ScopeStringArgs')

static builder()

scope: TraversalScopeArgument

strings: Sequence[StringNullableArgument]

with_scope(scope)

with_strings(strings)

class hydra.tinkerpop.gremlin.SelectArgs

Bases: object

SelectArgsColumn | SelectArgsPopStrings | SelectArgsPopTraversal | SelectArgsStrings | SelectArgsTraversal

COLUMN = Name(value='column')

POP_STRINGS = Name(value='popStrings')

POP_TRAVERSAL = Name(value='popTraversal')

STRINGS = Name(value='strings')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.SelectArgs')

class hydra.tinkerpop.gremlin.SelectArgsColumn(value: T): Bases: Node[TraversalColumnArgument]

class hydra.tinkerpop.gremlin.SelectArgsPopStrings(value: T): Bases: Node[SelectByKeys]

class hydra.tinkerpop.gremlin.SelectArgsPopTraversal(value: T): Bases: Node[PopAndTraversal]

class hydra.tinkerpop.gremlin.SelectArgsStrings(value: T): Bases: Node[Sequence[StringArgument]]

class hydra.tinkerpop.gremlin.SelectArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.SelectByKeys(pop: TraversalPopArgument, keys: Sequence[StringArgument])

Bases: object

The keys selected by a Gremlin select() step.

class Builder(_pop: 'TraversalPopArgument' = None, _keys: 'Sequence[StringArgument]' = None)

Bases: object

build()

keys(keys)

pop(pop)

KEYS = Name(value='keys')

POP = Name(value='pop')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.SelectByKeys')

static builder()

keys: Sequence[StringArgument]

pop: TraversalPopArgument

with_keys(keys)

with_pop(pop)

class hydra.tinkerpop.gremlin.ServiceArguments

Bases: object

ServiceArgumentsMap | ServiceArgumentsTraversal

MAP = Name(value='map')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ServiceArguments')

class hydra.tinkerpop.gremlin.ServiceArgumentsMap(value: T): Bases: Node[Optional[GenericLiteralMapArgument]]

class hydra.tinkerpop.gremlin.ServiceArgumentsTraversal(value: T): Bases: Node[Optional[NestedTraversal]]

class hydra.tinkerpop.gremlin.ServiceCall(service: StringArgument, arguments: ServiceArguments)

Bases: object

A Gremlin call() service invocation.

ARGUMENTS = Name(value='arguments')

class Builder(_service: 'StringArgument' = None, _arguments: 'ServiceArguments' = None)

Bases: object

arguments(arguments)

build()

service(service)

SERVICE = Name(value='service')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ServiceCall')

arguments: ServiceArguments

static builder()

service: StringArgument

with_arguments(arguments)

with_service(service)

class hydra.tinkerpop.gremlin.ShortestPathConstants(*values)

Bases: Enum

The named constants used by the Gremlin shortestPath() step.

DISTANCE = Name(value='distance')

EDGES = Name(value='edges')

INCLUDE_EDGES = Name(value='includeEdges')

MAX_DISTANCE = Name(value='maxDistance')

TARGET = Name(value='target')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ShortestPathConstants')

class hydra.tinkerpop.gremlin.SplitArgs(scope: object, delimiter: StringNullableArgument)

Bases: object

The arguments of a Gremlin split() step.

class Builder(_scope: 'Optional[TraversalScopeArgument]' = None, _delimiter: 'StringNullableArgument' = None)

Bases: object

build()

delimiter(delimiter)

scope(scope)

DELIMITER = Name(value='delimiter')

SCOPE = Name(value='scope')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.SplitArgs')

static builder()

delimiter: StringNullableArgument

scope: object

with_delimiter(delimiter)

with_scope(scope)

class hydra.tinkerpop.gremlin.StringAndObject(key: StringArgument, value: GenericLiteralArgument)

Bases: object

A string argument together with an object argument.

class Builder(_key: 'StringArgument' = None, _value: 'GenericLiteralArgument' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringAndObject')

VALUE = Name(value='value')

static builder()

key: StringArgument

value: GenericLiteralArgument

with_key(key)

with_value(value)

class hydra.tinkerpop.gremlin.StringAndOptionalObject(key: StringArgument, value: object)

Bases: object

A string argument together with an optional object argument.

class Builder(_key: 'StringArgument' = None, _value: 'Optional[GenericLiteralArgument]' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringAndOptionalObject')

VALUE = Name(value='value')

static builder()

key: StringArgument

value: object

with_key(key)

with_value(value)

class hydra.tinkerpop.gremlin.StringArgument

Bases: object

StringArgumentValue | StringArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.StringArgumentOrNestedTraversal

Bases: object

StringArgumentOrNestedTraversalString | StringArgumentOrNestedTraversalTraversal

STRING = Name(value='string')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringArgumentOrNestedTraversal')

class hydra.tinkerpop.gremlin.StringArgumentOrNestedTraversalString(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.StringArgumentOrNestedTraversalTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.StringArgumentValue(value: T): Bases: Node[str]

class hydra.tinkerpop.gremlin.StringArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.StringKeyAndObject(key: StringNullableArgument, object: GenericLiteralArgument)

Bases: object

A string key together with an object value.

class Builder(_key: 'StringNullableArgument' = None, _object: 'GenericLiteralArgument' = None)

Bases: object

build()

key(key)

object(object)

KEY = Name(value='key')

OBJECT = Name(value='object')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringKeyAndObject')

static builder()

key: StringNullableArgument

object: GenericLiteralArgument

with_key(key)

with_object(object)

class hydra.tinkerpop.gremlin.StringKeyAndPredicate(key: StringNullableArgument, predicate: TraversalPredicate)

Bases: object

A string key together with a traversal predicate.

class Builder(_key: 'StringNullableArgument' = None, _predicate: 'TraversalPredicate' = None)

Bases: object

build()

key(key)

predicate(predicate)

KEY = Name(value='key')

PREDICATE = Name(value='predicate')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringKeyAndPredicate')

static builder()

key: StringNullableArgument

predicate: TraversalPredicate

with_key(key)

with_predicate(predicate)

class hydra.tinkerpop.gremlin.StringNullableArgument

Bases: object

StringNullableArgumentValue | StringNullableArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringNullableArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.StringNullableArgumentValue(value: T): Bases: Node[object]

class hydra.tinkerpop.gremlin.StringNullableArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.StringRange(left: str, right: str)

Bases: object

A Gremlin string range expression.

class Builder(_left: 'str' = None, _right: 'str' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StringRange')

static builder()

left: str

right: str

with_left(left)

with_right(right)

class hydra.tinkerpop.gremlin.StructureVertex(new: bool, id: GenericLiteralArgument, label: StringArgument)

Bases: object

A Gremlin structure-level vertex reference.

class Builder(_new: 'bool' = None, _id: 'GenericLiteralArgument' = None, _label: 'StringArgument' = None)

Bases: object

build()

id(id)

label(label)

new(new)

ID = Name(value='id')

LABEL = Name(value='label')

NEW = Name(value='new')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StructureVertex')

static builder()

id: GenericLiteralArgument

label: StringArgument

new: bool

with_id(id)

with_label(label)

with_new(new)

class hydra.tinkerpop.gremlin.StructureVertexArgument

Bases: object

StructureVertexArgumentValue | StructureVertexArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.StructureVertexArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.StructureVertexArgumentValue(value: T): Bases: Node[StructureVertex]

class hydra.tinkerpop.gremlin.StructureVertexArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.SubstringArgs(scope: object, start: IntegerArgument, end: object)

Bases: object

The arguments of a Gremlin substring() step.

class Builder(_scope: 'Optional[TraversalScopeArgument]' = None, _start: 'IntegerArgument' = None, _end: 'Optional[IntegerArgument]' = None)

Bases: object

build()

end(end)

scope(scope)

start(start)

END = Name(value='end')

SCOPE = Name(value='scope')

START = Name(value='start')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.SubstringArgs')

static builder()

end: object

scope: object

start: IntegerArgument

with_end(end)

with_scope(scope)

with_start(start)

class hydra.tinkerpop.gremlin.TailArgs(scope: object, integer: object)

Bases: object

The arguments of a Gremlin tail() step.

class Builder(_scope: 'Optional[TraversalScopeArgument]' = None, _integer: 'Optional[IntegerArgument]' = None)

Bases: object

build()

integer(integer)

scope(scope)

INTEGER = Name(value='integer')

SCOPE = Name(value='scope')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TailArgs')

static builder()

integer: object

scope: object

with_integer(integer)

with_scope(scope)

class hydra.tinkerpop.gremlin.TerminatedTraversal(root: RootTraversal, terminal: TraversalTerminalMethod)

Bases: object

A Gremlin traversal terminated by a terminal method.

class Builder(_root: 'RootTraversal' = None, _terminal: 'TraversalTerminalMethod' = None)

Bases: object

build()

root(root)

terminal(terminal)

ROOT = Name(value='root')

TERMINAL = Name(value='terminal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TerminatedTraversal')

static builder()

root: RootTraversal

terminal: TraversalTerminalMethod

with_root(root)

with_terminal(terminal)

class hydra.tinkerpop.gremlin.ToArgs

Bases: object

ToArgsDirection | ToArgsString | ToArgsVertex | ToArgsTraversal

DIRECTION = Name(value='direction')

STRING = Name(value='string')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ToArgs')

VERTEX = Name(value='vertex')

class hydra.tinkerpop.gremlin.ToArgsDirection(value: T): Bases: Node[DirectionAndVarargs]

class hydra.tinkerpop.gremlin.ToArgsString(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.ToArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.ToArgsVertex(value: T): Bases: Node[StructureVertexArgument]

class hydra.tinkerpop.gremlin.TransactionPart(*values)

Bases: Enum

A single part of a Gremlin transaction statement.

BEGIN = Name(value='begin')

COMMIT = Name(value='commit')

ROLLBACK = Name(value='rollback')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TransactionPart')

class hydra.tinkerpop.gremlin.TraversalBiFunctionArgument

Bases: object

TraversalBiFunctionArgumentValue | TraversalBiFunctionArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalBiFunctionArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalBiFunctionArgumentValue(value: T): Bases: Node[TraversalOperator]

class hydra.tinkerpop.gremlin.TraversalBiFunctionArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalCardinality

Bases: object

TraversalCardinalitySingle | TraversalCardinalitySet | TraversalCardinalityList

LIST = Name(value='list')

SET = Name(value='set')

SINGLE = Name(value='single')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalCardinality')

class hydra.tinkerpop.gremlin.TraversalCardinalityArgument

Bases: object

TraversalCardinalityArgumentValue | TraversalCardinalityArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalCardinalityArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalCardinalityArgumentValue(value: T): Bases: Node[TraversalCardinality]

class hydra.tinkerpop.gremlin.TraversalCardinalityArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalCardinalityList(value: T): Bases: Node[GenericLiteral]

class hydra.tinkerpop.gremlin.TraversalCardinalitySet(value: T): Bases: Node[GenericLiteral]

class hydra.tinkerpop.gremlin.TraversalCardinalitySingle(value: T): Bases: Node[GenericLiteral]

class hydra.tinkerpop.gremlin.TraversalColumn(*values)

Bases: Enum

A Gremlin traversal column selector: keys or values.

KEYS = Name(value='keys')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalColumn')

VALUES = Name(value='values')

class hydra.tinkerpop.gremlin.TraversalColumnArgument

Bases: object

TraversalColumnArgumentValue | TraversalColumnArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalColumnArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalColumnArgumentValue(value: T): Bases: Node[TraversalColumn]

class hydra.tinkerpop.gremlin.TraversalColumnArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalComparatorArgument

Bases: object

TraversalComparatorArgumentValue | TraversalComparatorArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalComparatorArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalComparatorArgumentValue(value: T): Bases: Node[TraversalOrder]

class hydra.tinkerpop.gremlin.TraversalComparatorArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalDT(*values)

Bases: Enum

A Gremlin date/time unit.

DAY = Name(value='day')

HOUR = Name(value='hour')

MINUTE = Name(value='minute')

SECOND = Name(value='second')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalDT')

class hydra.tinkerpop.gremlin.TraversalDTArgument

Bases: object

TraversalDTArgumentValue | TraversalDTArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalDTArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalDTArgumentValue(value: T): Bases: Node[TraversalDT]

class hydra.tinkerpop.gremlin.TraversalDTArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalDirection(*values)

Bases: Enum

A Gremlin edge direction: in, out, or both.

BOTH = Name(value='both')

FROM = Name(value='from')

IN = Name(value='in')

OUT = Name(value='out')

TO = Name(value='to')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalDirection')

class hydra.tinkerpop.gremlin.TraversalDirectionArgument

Bases: object

TraversalDirectionArgumentValue | TraversalDirectionArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalDirectionArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalDirectionArgumentValue(value: T): Bases: Node[TraversalDirection]

class hydra.tinkerpop.gremlin.TraversalDirectionArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalFunction

Bases: object

TraversalFunctionToken | TraversalFunctionColumn

COLUMN = Name(value='column')

TOKEN = Name(value='token')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalFunction')

class hydra.tinkerpop.gremlin.TraversalFunctionArgument

Bases: object

TraversalFunctionArgumentValue | TraversalFunctionArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalFunctionArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalFunctionArgumentValue(value: T): Bases: Node[TraversalFunction]

class hydra.tinkerpop.gremlin.TraversalFunctionArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalFunctionColumn(value: T): Bases: Node[TraversalColumn]

class hydra.tinkerpop.gremlin.TraversalFunctionToken(value: T): Bases: Node[TraversalToken]

class hydra.tinkerpop.gremlin.TraversalGType(*values)

Bases: Enum

A Gremlin graph type constant.

BIG_DECIMAL = Name(value='bigDecimal')

BIG_DECIMAL_U = Name(value='bigDecimalU')

BIG_INT = Name(value='bigInt')

BIG_INT_U = Name(value='bigIntU')

BINARY = Name(value='binary')

BINARY_U = Name(value='binaryU')

BOOLEAN = Name(value='boolean')

BOOLEAN_U = Name(value='booleanU')

BYTE = Name(value='byte')

BYTE_U = Name(value='byteU')

CHAR = Name(value='char')

CHAR_U = Name(value='charU')

DATE_TIME = Name(value='dateTime')

DATE_TIME_U = Name(value='dateTimeU')

DOUBLE = Name(value='double')

DOUBLE_U = Name(value='doubleU')

DURATION = Name(value='duration')

DURATION_U = Name(value='durationU')

EDGE = Name(value='edge')

EDGE_U = Name(value='edgeU')

FLOAT = Name(value='float')

FLOAT_U = Name(value='floatU')

GRAPH = Name(value='graph')

GRAPH_U = Name(value='graphU')

INT = Name(value='int')

INT_U = Name(value='intU')

LIST = Name(value='list')

LIST_U = Name(value='listU')

LONG = Name(value='long')

LONG_U = Name(value='longU')

MAP = Name(value='map')

MAP_U = Name(value='mapU')

NULL = Name(value='null')

NULL_U = Name(value='nullU')

NUMBER = Name(value='number')

NUMBER_U = Name(value='numberU')

PATH = Name(value='path')

PATH_U = Name(value='pathU')

PROPERTY = Name(value='property')

PROPERTY_U = Name(value='propertyU')

SET = Name(value='set')

SET_U = Name(value='setU')

SHORT = Name(value='short')

SHORT_U = Name(value='shortU')

STRING = Name(value='string')

STRING_U = Name(value='stringU')

TREE = Name(value='tree')

TREE_U = Name(value='treeU')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalGType')

UUID = Name(value='uuid')

UUID_L = Name(value='uuidL')

VERTEX = Name(value='vertex')

VERTEX_U = Name(value='vertexU')

VPROPERTY = Name(value='vproperty')

VPROPERTY_U = Name(value='vpropertyU')

class hydra.tinkerpop.gremlin.TraversalGTypeArgument

Bases: object

TraversalGTypeArgumentValue | TraversalGTypeArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalGTypeArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalGTypeArgumentValue(value: T): Bases: Node[TraversalGType]

class hydra.tinkerpop.gremlin.TraversalGTypeArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalMerge(*values)

Bases: Enum

A Gremlin merge-option selector.

IN_V = Name(value='inV')

ON_CREATE = Name(value='onCreate')

ON_MATCH = Name(value='onMatch')

OUT_V = Name(value='outV')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalMerge')

class hydra.tinkerpop.gremlin.TraversalMergeArgument

Bases: object

TraversalMergeArgumentValue | TraversalMergeArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalMergeArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalMergeArgumentValue(value: T): Bases: Node[TraversalMerge]

class hydra.tinkerpop.gremlin.TraversalMergeArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalMethod

Bases: object

ADD_E = Name(value='addE')

ADD_V = Name(value='addV')

AGGREGATE = Name(value='aggregate')

ALL = Name(value='all')

AND = Name(value='and')

ANY = Name(value='any')

AS = Name(value='as')

AS_BOOL = Name(value='asBool')

AS_DATE = Name(value='asDate')

AS_NUMBER = Name(value='asNumber')

AS_STRING = Name(value='asString')

BARRIER = Name(value='barrier')

BOTH = Name(value='both')

BOTH_E = Name(value='bothE')

BOTH_V = Name(value='bothV')

BRANCH = Name(value='branch')

BY = Name(value='by')

CALL = Name(value='call')

CAP = Name(value='cap')

CHOOSE = Name(value='choose')

COALESCE = Name(value='coalesce')

COIN = Name(value='coin')

COMBINE = Name(value='combine')

CONCAT = Name(value='concat')

CONJOIN = Name(value='conjoin')

CONNECTED_COMPONENT = Name(value='connectedComponent')

CONSTANT = Name(value='constant')

COUNT = Name(value='count')

CYCLIC_PATH = Name(value='cyclicPath')

DATE_ADD = Name(value='dateAdd')

DATE_DIFF = Name(value='dateDiff')

DEDUP = Name(value='dedup')

DIFFERENCE = Name(value='difference')

DISCARD = Name(value='discard')

DISJUNCT = Name(value='disjunct')

DROP = Name(value='drop')

E = Name(value='e')

ELEMENT = Name(value='element')

ELEMENT_MAP = Name(value='elementMap')

EMIT = Name(value='emit')

FAIL = Name(value='fail')

FILTER = Name(value='filter')

FLAT_MAP = Name(value='flatMap')

FOLD = Name(value='fold')

FORMAT = Name(value='format')

FROM = Name(value='from')

GROUP = Name(value='group')

GROUP_COUNT = Name(value='groupCount')

HAS = Name(value='has')

HAS_ID = Name(value='hasId')

HAS_KEY = Name(value='hasKey')

HAS_LABEL = Name(value='hasLabel')

HAS_NOT = Name(value='hasNot')

HAS_VALUE = Name(value='hasValue')

ID = Name(value='id')

IDENTITY = Name(value='identity')

IN = Name(value='in')

INDEX = Name(value='index')

INJECT = Name(value='inject')

INTERSECT = Name(value='intersect')

IN_E = Name(value='inE')

IN_V = Name(value='inV')

IS = Name(value='is')

KEY = Name(value='key')

LABEL = Name(value='label')

LENGTH = Name(value='length')

LIMIT = Name(value='limit')

LOCAL = Name(value='local')

LOOPS = Name(value='loops')

L_TRIM = Name(value='lTrim')

MAP = Name(value='map')

MATCH = Name(value='match')

MATH = Name(value='math')

MAX = Name(value='max')

MEAN = Name(value='mean')

MERGE = Name(value='merge')

MERGE_E = Name(value='mergeE')

MERGE_V = Name(value='mergeV')

MIN = Name(value='min')

NONE = Name(value='none')

NOT = Name(value='not')

OPTION = Name(value='option')

OPTIONAL = Name(value='optional')

OR = Name(value='or')

ORDER = Name(value='order')

OTHER_V = Name(value='otherV')

OUT = Name(value='out')

OUT_E = Name(value='outE')

OUT_V = Name(value='outV')

PAGE_RANK = Name(value='pageRank')

PATH = Name(value='path')

PEER_PRESSURE = Name(value='peerPressure')

PRODUCT = Name(value='product')

PROFILE = Name(value='profile')

PROJECT = Name(value='project')

PROPERTIES = Name(value='properties')

PROPERTY = Name(value='property')

PROPERTY_MAP = Name(value='propertyMap')

RANGE = Name(value='range')

READ = Name(value='read')

REPEAT = Name(value='repeat')

REPLACE = Name(value='replace')

REVERSE = Name(value='reverse')

R_TRIM = Name(value='rTrim')

SACK = Name(value='sack')

SAMPLE = Name(value='sample')

SELECT = Name(value='select')

SHORTEST_PATH = Name(value='shortestPath')

SIDE_EFFECT = Name(value='sideEffect')

SIMPLE_PATH = Name(value='simplePath')

SKIP = Name(value='skip')

SPLIT = Name(value='split')

SUBGRAPH = Name(value='subgraph')

SUBSTRING = Name(value='substring')

SUM = Name(value='sum')

TAIL = Name(value='tail')

TIMES = Name(value='times')

TIME_LIMIT = Name(value='timeLimit')

TO = Name(value='to')

TO_E = Name(value='toE')

TO_LOWER = Name(value='toLower')

TO_UPPER = Name(value='toUpper')

TO_V = Name(value='toV')

TREE = Name(value='tree')

TRIM = Name(value='trim')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalMethod')

UNFOLD = Name(value='unfold')

UNION = Name(value='union')

UNTIL = Name(value='until')

V = Name(value='v')

VALUE = Name(value='value')

VALUES = Name(value='values')

VALUE_MAP = Name(value='valueMap')

WHERE = Name(value='where')

WITH = Name(value='with')

WRITE = Name(value='write')

class hydra.tinkerpop.gremlin.TraversalMethodAddE(value: T): Bases: Node[StringArgumentOrNestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodAddV(value: T): Bases: Node[Optional[StringArgumentOrNestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalMethodAggregate(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalMethodAll(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.TraversalMethodAnd(value: T): Bases: Node[Sequence[NestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalMethodAny(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.TraversalMethodAs(value: T): Bases: Node[AsArgs]

class hydra.tinkerpop.gremlin.TraversalMethodAsBool: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodAsDate: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodAsNumber(value: T): Bases: Node[Optional[TraversalGTypeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodAsString(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodBarrier(value: T): Bases: Node[Optional[BarrierArgs]]

class hydra.tinkerpop.gremlin.TraversalMethodBoth(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodBothE(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodBothV: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodBranch(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodBy(value: T): Bases: Node[ByArgs]

class hydra.tinkerpop.gremlin.TraversalMethodCall(value: T): Bases: Node[ServiceCall]

class hydra.tinkerpop.gremlin.TraversalMethodCap(value: T): Bases: Node[AsArgs]

class hydra.tinkerpop.gremlin.TraversalMethodChoose(value: T): Bases: Node[ChooseArgs]

class hydra.tinkerpop.gremlin.TraversalMethodCoalesce(value: T): Bases: Node[Sequence[NestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalMethodCoin(value: T): Bases: Node[NumericArgument]

class hydra.tinkerpop.gremlin.TraversalMethodCombine(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalMethodConcat(value: T): Bases: Node[ConcatArgs]

class hydra.tinkerpop.gremlin.TraversalMethodConjoin(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalMethodConnectedComponent: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodConstant(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalMethodCount(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodCyclicPath: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodDateAdd(value: T): Bases: Node[DateAddArgs]

class hydra.tinkerpop.gremlin.TraversalMethodDateDiff(value: T): Bases: Node[DateDiffArgs]

class hydra.tinkerpop.gremlin.TraversalMethodDedup(value: T): Bases: Node[DedupArgs]

class hydra.tinkerpop.gremlin.TraversalMethodDifference(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalMethodDiscard: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodDisjunct(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalMethodDrop: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodE(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodElement(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodElementMap(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodEmit(value: T): Bases: Node[Optional[PredicateOrTraversal]]

class hydra.tinkerpop.gremlin.TraversalMethodFail(value: T): Bases: Node[Optional[StringArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodFilter(value: T): Bases: Node[PredicateOrTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodFlatMap(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodFold(value: T): Bases: Node[Optional[FoldArgs]]

class hydra.tinkerpop.gremlin.TraversalMethodFormat(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalMethodFrom(value: T): Bases: Node[FromArgs]

class hydra.tinkerpop.gremlin.TraversalMethodGroup(value: T): Bases: Node[Optional[StringArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodGroupCount(value: T): Bases: Node[Optional[StringArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodHas(value: T): Bases: Node[HasArgs]

class hydra.tinkerpop.gremlin.TraversalMethodHasId(value: T): Bases: Node[PredicateOrObjects]

class hydra.tinkerpop.gremlin.TraversalMethodHasKey(value: T): Bases: Node[PredicateOrStrings]

class hydra.tinkerpop.gremlin.TraversalMethodHasLabel(value: T): Bases: Node[PredicateOrStrings]

class hydra.tinkerpop.gremlin.TraversalMethodHasNot(value: T): Bases: Node[StringNullableArgument]

class hydra.tinkerpop.gremlin.TraversalMethodHasValue(value: T): Bases: Node[PredicateOrObjects]

class hydra.tinkerpop.gremlin.TraversalMethodId: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodIdentity: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodIn(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodInE(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodInV: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodIndex: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodInject(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodIntersect(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalMethodIs(value: T): Bases: Node[PredicateOrObject]

class hydra.tinkerpop.gremlin.TraversalMethodKey: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodLTrim(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodLabel: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodLength(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodLimit(value: T): Bases: Node[ScopeAndInteger]

class hydra.tinkerpop.gremlin.TraversalMethodLocal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodLoops(value: T): Bases: Node[Optional[StringArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodMap(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodMatch(value: T): Bases: Node[Sequence[NestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalMethodMath(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalMethodMax(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodMean(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodMerge(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalMethodMergeE(value: T): Bases: Node[MergeArgs]

class hydra.tinkerpop.gremlin.TraversalMethodMergeV(value: T): Bases: Node[MergeArgs]

class hydra.tinkerpop.gremlin.TraversalMethodMin(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodNone(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.TraversalMethodNot(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodOption(value: T): Bases: Node[OptionArgs]

class hydra.tinkerpop.gremlin.TraversalMethodOptional(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodOr(value: T): Bases: Node[Sequence[NestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalMethodOrder(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodOtherV: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodOut(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodOutE(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodOutV: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodPageRank(value: T): Bases: Node[Optional[NumericArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodPath: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodPeerPressure: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodProduct(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalMethodProfile(value: T): Bases: Node[Optional[StringArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodProject(value: T): Bases: Node[AsArgs]

class hydra.tinkerpop.gremlin.TraversalMethodProperties(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodProperty(value: T): Bases: Node[PropertyArgs]

class hydra.tinkerpop.gremlin.TraversalMethodPropertyMap(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodRTrim(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodRange(value: T): Bases: Node[RangeArgs]

class hydra.tinkerpop.gremlin.TraversalMethodRead: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodRepeat(value: T): Bases: Node[RepeatArgs]

class hydra.tinkerpop.gremlin.TraversalMethodReplace(value: T): Bases: Node[ReplaceArgs]

class hydra.tinkerpop.gremlin.TraversalMethodReverse: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodSack(value: T): Bases: Node[Optional[TraversalBiFunctionArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodSample(value: T): Bases: Node[SampleByScope]

class hydra.tinkerpop.gremlin.TraversalMethodSelect(value: T): Bases: Node[SelectArgs]

class hydra.tinkerpop.gremlin.TraversalMethodShortestPath: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodSideEffect(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodSimplePath: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodSkip(value: T): Bases: Node[ScopeAndInteger]

class hydra.tinkerpop.gremlin.TraversalMethodSplit(value: T): Bases: Node[SplitArgs]

class hydra.tinkerpop.gremlin.TraversalMethodSubgraph(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalMethodSubstring(value: T): Bases: Node[SubstringArgs]

class hydra.tinkerpop.gremlin.TraversalMethodSum(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodTail(value: T): Bases: Node[Optional[TailArgs]]

class hydra.tinkerpop.gremlin.TraversalMethodTimeLimit(value: T): Bases: Node[IntegerArgument]

class hydra.tinkerpop.gremlin.TraversalMethodTimes(value: T): Bases: Node[IntegerArgument]

class hydra.tinkerpop.gremlin.TraversalMethodTo(value: T): Bases: Node[ToArgs]

class hydra.tinkerpop.gremlin.TraversalMethodToE(value: T): Bases: Node[DirectionAndVarargs]

class hydra.tinkerpop.gremlin.TraversalMethodToLower(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodToUpper(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodToV(value: T): Bases: Node[TraversalDirectionArgument]

class hydra.tinkerpop.gremlin.TraversalMethodTree(value: T): Bases: Node[Optional[StringArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodTrim(value: T): Bases: Node[Optional[TraversalScopeArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodUnfold: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodUnion(value: T): Bases: Node[Sequence[NestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalMethodUntil(value: T): Bases: Node[PredicateOrTraversal]

class hydra.tinkerpop.gremlin.TraversalMethodV(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodValue: Bases: object

class hydra.tinkerpop.gremlin.TraversalMethodValueMap(value: T): Bases: Node[ValueMapArgs]

class hydra.tinkerpop.gremlin.TraversalMethodValues(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.TraversalMethodWhere(value: T): Bases: Node[WhereArgs]

class hydra.tinkerpop.gremlin.TraversalMethodWith(value: T): Bases: Node[WithArgs]

class hydra.tinkerpop.gremlin.TraversalMethodWrite: Bases: object

class hydra.tinkerpop.gremlin.TraversalOperator(*values)

Bases: Enum

A Gremlin traversal operator.

ADD_ALL = Name(value='addAll')

AND = Name(value='and')

ASSIGN = Name(value='assign')

DIV = Name(value='div')

MAX = Name(value='max')

MIN = Name(value='min')

MINUS = Name(value='minus')

MULT = Name(value='mult')

OR = Name(value='or')

SUM = Name(value='sum')

SUM_LONG = Name(value='sumLong')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalOperator')

class hydra.tinkerpop.gremlin.TraversalOrder(*values)

Bases: Enum

A Gremlin sort order: ascending, descending, or shuffle.

ASC = Name(value='asc')

DESC = Name(value='desc')

SHUFFLE = Name(value='shuffle')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalOrder')

class hydra.tinkerpop.gremlin.TraversalOrderArgument

Bases: object

TraversalOrderArgumentValue | TraversalOrderArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalOrderArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalOrderArgumentValue(value: T): Bases: Node[TraversalOrder]

class hydra.tinkerpop.gremlin.TraversalOrderArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalPick(*values)

Bases: Enum

A Gremlin Pick selector: any or none.

ANY = Name(value='any')

NONE = Name(value='none')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalPick')

UNPRODUCTIVE = Name(value='unproductive')

class hydra.tinkerpop.gremlin.TraversalPop(*values)

Bases: Enum

A Gremlin Pop selector: first, last, all, or mixed.

ALL = Name(value='all')

FIRST = Name(value='first')

LAST = Name(value='last')

MIXED = Name(value='mixed')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalPop')

class hydra.tinkerpop.gremlin.TraversalPopArgument

Bases: object

TraversalPopArgumentValue | TraversalPopArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalPopArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalPopArgumentValue(value: T): Bases: Node[TraversalPop]

class hydra.tinkerpop.gremlin.TraversalPopArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalPredicate

Bases: object

AND = Name(value='and')

BETWEEN = Name(value='between')

CONTAINING = Name(value='containing')

ENDING_WITH = Name(value='endingWith')

EQ = Name(value='eq')

GT = Name(value='gt')

GTE = Name(value='gte')

INSIDE = Name(value='inside')

LT = Name(value='lt')

LTE = Name(value='lte')

NEGATE = Name(value='negate')

NEQ = Name(value='neq')

NOT = Name(value='not')

NOT_CONTAINING = Name(value='notContaining')

NOT_ENDING_WITH = Name(value='notEndingWith')

NOT_REGEX = Name(value='notRegex')

NOT_STARTING_WITH = Name(value='notStartingWith')

OR = Name(value='or')

OUTSIDE = Name(value='outside')

REGEX = Name(value='regex')

STARTING_WITH = Name(value='startingWith')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalPredicate')

TYPE_OF = Name(value='typeOf')

WITHIN = Name(value='within')

WITHOUT = Name(value='without')

class hydra.tinkerpop.gremlin.TraversalPredicateAnd(value: T): Bases: Node[TwoTraversalPredicates]

class hydra.tinkerpop.gremlin.TraversalPredicateBetween(value: T): Bases: Node[RangeArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateContaining(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateEndingWith(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateEq(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateGt(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateGte(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateInside(value: T): Bases: Node[RangeArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateLt(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateLte(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateNegate(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.TraversalPredicateNeq(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateNot(value: T): Bases: Node[TraversalPredicate]

class hydra.tinkerpop.gremlin.TraversalPredicateNotContaining(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateNotEndingWith(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateNotRegex(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateNotStartingWith(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateOr(value: T): Bases: Node[TwoTraversalPredicates]

class hydra.tinkerpop.gremlin.TraversalPredicateOutside(value: T): Bases: Node[RangeArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateRegex(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateStartingWith(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalPredicateTypeOf(value: T): Bases: Node[TypeOfArg]

class hydra.tinkerpop.gremlin.TraversalPredicateWithin(value: T): Bases: Node[Optional[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalPredicateWithout(value: T): Bases: Node[Optional[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalSackMethodArgument

Bases: object

TraversalSackMethodArgumentValue | TraversalSackMethodArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalSackMethodArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalSackMethodArgumentValue: Bases: object

class hydra.tinkerpop.gremlin.TraversalSackMethodArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalScope(*values)

Bases: Enum

A Gremlin traversal scope: local or global.

GLOBAL = Name(value='global')

LOCAL = Name(value='local')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalScope')

class hydra.tinkerpop.gremlin.TraversalScopeArgument

Bases: object

TraversalScopeArgumentValue | TraversalScopeArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalScopeArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalScopeArgumentValue(value: T): Bases: Node[TraversalScope]

class hydra.tinkerpop.gremlin.TraversalScopeArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TraversalSource(value: T)

Bases: Node[Sequence[TraversalSourceSelfMethod]]

A Gremlin traversal source: g, or a variable bound to one.

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalSource')

class hydra.tinkerpop.gremlin.TraversalSourceQuery(source: TraversalSource, transaction_part: object)

Bases: object

A query built from a Gremlin traversal source.

class Builder(_source: 'TraversalSource' = None, _transaction_part: 'Optional[TransactionPart]' = None)

Bases: object

build()

source(source)

transaction_part(transaction_part)

SOURCE = Name(value='source')

TRANSACTION_PART = Name(value='transactionPart')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalSourceQuery')

static builder()

source: TraversalSource

transaction_part: object

with_source(source)

with_transaction_part(transaction_part)

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethod

Bases: object

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalSourceSelfMethod')

WITH = Name(value='with')

WITHOUT_STRATEGIES = Name(value='withoutStrategies')

WITH_BULK = Name(value='withBulk')

WITH_PATH = Name(value='withPath')

WITH_SACK = Name(value='withSack')

WITH_SIDE_EFFECT = Name(value='withSideEffect')

WITH_STRATEGIES = Name(value='withStrategies')

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethodWith(value: T): Bases: Node[StringAndOptionalObject]

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethodWithBulk(value: T): Bases: Node[bool]

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethodWithPath: Bases: object

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethodWithSack(value: T): Bases: Node[WithSackArgs]

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethodWithSideEffect(value: T): Bases: Node[StringAndObject]

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethodWithStrategies(value: T): Bases: Node[Sequence[TraversalStrategy]]

class hydra.tinkerpop.gremlin.TraversalSourceSelfMethodWithoutStrategies(value: T): Bases: Node[Sequence[Identifier]]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethod

Bases: object

ADD_E = Name(value='addE')

ADD_V = Name(value='addV')

CALL = Name(value='call')

E = Name(value='e')

INJECT = Name(value='inject')

IO = Name(value='io')

MERGE_E = Name(value='mergeE')

MERGE_V = Name(value='mergeV')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalSourceSpawnMethod')

UNION = Name(value='union')

V = Name(value='v')

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodAddE(value: T): Bases: Node[StringArgumentOrNestedTraversal]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodAddV(value: T): Bases: Node[Optional[StringArgumentOrNestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodCall(value: T): Bases: Node[Optional[ServiceCall]]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodE(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodInject(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodIo(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodMergeE(value: T): Bases: Node[MergeArgs]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodMergeV(value: T): Bases: Node[MergeArgs]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodUnion(value: T): Bases: Node[Sequence[NestedTraversal]]

class hydra.tinkerpop.gremlin.TraversalSourceSpawnMethodV(value: T): Bases: Node[Sequence[GenericLiteralArgument]]

class hydra.tinkerpop.gremlin.TraversalStrategy(new: bool, class_: Identifier, configurations: Sequence[Configuration])

Bases: object

A Gremlin traversal strategy reference.

class Builder(_new: 'bool' = None, _class_: 'Identifier' = None, _configurations: 'Sequence[Configuration]' = None)

Bases: object

build()

class_(class_)

configurations(configurations)

new(new)

CLASS = Name(value='class')

CONFIGURATIONS = Name(value='configurations')

NEW = Name(value='new')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalStrategy')

static builder()

class_: Identifier

configurations: Sequence[Configuration]

new: bool

with_class_(class_)

with_configurations(configurations)

with_new(new)

class hydra.tinkerpop.gremlin.TraversalTerminalMethod

Bases: object

EXPLAIN = Name(value='explain')

HAS_NEXT = Name(value='hasNext')

ITERATE = Name(value='iterate')

NEXT = Name(value='next')

TO_BULK_SET = Name(value='toBulkSet')

TO_LIST = Name(value='toList')

TO_SET = Name(value='toSet')

TRY_NEXT = Name(value='tryNext')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalTerminalMethod')

class hydra.tinkerpop.gremlin.TraversalTerminalMethodExplain: Bases: object

class hydra.tinkerpop.gremlin.TraversalTerminalMethodHasNext: Bases: object

class hydra.tinkerpop.gremlin.TraversalTerminalMethodIterate: Bases: object

class hydra.tinkerpop.gremlin.TraversalTerminalMethodNext(value: T): Bases: Node[Optional[IntegerLiteral]]

class hydra.tinkerpop.gremlin.TraversalTerminalMethodToBulkSet: Bases: object

class hydra.tinkerpop.gremlin.TraversalTerminalMethodToList: Bases: object

class hydra.tinkerpop.gremlin.TraversalTerminalMethodToSet: Bases: object

class hydra.tinkerpop.gremlin.TraversalTerminalMethodTryNext: Bases: object

class hydra.tinkerpop.gremlin.TraversalToken(*values)

Bases: Enum

A Gremlin element token: id, label, key, or value.

ID = Name(value='id')

KEY = Name(value='key')

LABEL = Name(value='label')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalToken')

VALUE = Name(value='value')

class hydra.tinkerpop.gremlin.TraversalTokenArgument

Bases: object

TraversalTokenArgumentValue | TraversalTokenArgumentVariable

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TraversalTokenArgument')

VALUE = Name(value='value')

VARIABLE = Name(value='variable')

class hydra.tinkerpop.gremlin.TraversalTokenArgumentValue(value: T): Bases: Node[TraversalToken]

class hydra.tinkerpop.gremlin.TraversalTokenArgumentVariable(value: T): Bases: Node[Identifier]

class hydra.tinkerpop.gremlin.TwoTraversalPredicates(left: TraversalPredicate, right: TraversalPredicate)

Bases: object

A pair of traversal predicates, as used in a between-style filter.

class Builder(_left: 'TraversalPredicate' = None, _right: 'TraversalPredicate' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TwoTraversalPredicates')

static builder()

left: TraversalPredicate

right: TraversalPredicate

with_left(left)

with_right(right)

class hydra.tinkerpop.gremlin.TypeOfArg

Bases: object

TypeOfArgGType | TypeOfArgString

G_TYPE = Name(value='gType')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.TypeOfArg')

class hydra.tinkerpop.gremlin.TypeOfArgGType(value: T): Bases: Node[TraversalGType]

class hydra.tinkerpop.gremlin.TypeOfArgString(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.ValueMapArgs

Bases: object

ValueMapArgsString | ValueMapArgsBoolean

BOOLEAN = Name(value='boolean')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ValueMapArgs')

class hydra.tinkerpop.gremlin.ValueMapArgsBoolean(value: T): Bases: Node[ValueMapBooleanArgs]

class hydra.tinkerpop.gremlin.ValueMapArgsString(value: T): Bases: Node[Sequence[StringNullableArgument]]

class hydra.tinkerpop.gremlin.ValueMapBooleanArgs(value: BooleanArgument, keys: object)

Bases: object

The boolean-flag arguments of a Gremlin valueMap() step.

class Builder(_value: 'BooleanArgument' = None, _keys: 'Optional[Sequence[StringNullableArgument]]' = None)

Bases: object

build()

keys(keys)

value(value)

KEYS = Name(value='keys')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.ValueMapBooleanArgs')

VALUE = Name(value='value')

static builder()

keys: object

value: BooleanArgument

with_keys(keys)

with_value(value)

class hydra.tinkerpop.gremlin.WhereArgs

Bases: object

WhereArgsPredicate | WhereArgsString | WhereArgsTraversal

PREDICATE = Name(value='predicate')

STRING = Name(value='string')

TRAVERSAL = Name(value='traversal')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WhereArgs')

class hydra.tinkerpop.gremlin.WhereArgsPredicate(value: T): Bases: Node[WhereWithPredicateArgs]

class hydra.tinkerpop.gremlin.WhereArgsString(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.WhereArgsTraversal(value: T): Bases: Node[NestedTraversal]

class hydra.tinkerpop.gremlin.WhereWithPredicateArgs(left_arg: object, predicate: TraversalPredicate)

Bases: object

The arguments of a Gremlin where() step qualified by a predicate.

class Builder(_left_arg: 'Optional[StringArgument]' = None, _predicate: 'TraversalPredicate' = None)

Bases: object

build()

left_arg(left_arg)

predicate(predicate)

LEFT_ARG = Name(value='leftArg')

PREDICATE = Name(value='predicate')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WhereWithPredicateArgs')

static builder()

left_arg: object

predicate: TraversalPredicate

with_left_arg(left_arg)

with_predicate(predicate)

class hydra.tinkerpop.gremlin.WithArgs(keys: WithArgsKeys, values: object)

Bases: object

The arguments of a Gremlin with() modulator.

class Builder(_keys: 'WithArgsKeys' = None, _values: 'Optional[WithArgsValues]' = None)

Bases: object

build()

keys(keys)

values(values)

KEYS = Name(value='keys')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WithArgs')

VALUES = Name(value='values')

static builder()

keys: WithArgsKeys

values: object

with_keys(keys)

with_values(values)

class hydra.tinkerpop.gremlin.WithArgsKeys

Bases: object

WithArgsKeysWithOption | WithArgsKeysString

STRING = Name(value='string')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WithArgsKeys')

WITH_OPTION = Name(value='withOption')

class hydra.tinkerpop.gremlin.WithArgsKeysString(value: T): Bases: Node[StringArgument]

class hydra.tinkerpop.gremlin.WithArgsKeysWithOption(value: T): Bases: Node[WithOptionKeys]

class hydra.tinkerpop.gremlin.WithArgsValues

Bases: object

WithArgsValuesWithOptions | WithArgsValuesIo | WithArgsValuesObject

IO = Name(value='io')

OBJECT = Name(value='object')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WithArgsValues')

WITH_OPTIONS = Name(value='withOptions')

class hydra.tinkerpop.gremlin.WithArgsValuesIo(value: T): Bases: Node[IoOptionsValues]

class hydra.tinkerpop.gremlin.WithArgsValuesObject(value: T): Bases: Node[GenericLiteralArgument]

class hydra.tinkerpop.gremlin.WithArgsValuesWithOptions(value: T): Bases: Node[WithOptionsValues]

class hydra.tinkerpop.gremlin.WithOptionKeys

Bases: object

CONNECTED_COMPONENT = Name(value='connectedComponent')

IO = Name(value='io')

PAGE_RANK = Name(value='pageRank')

PEER_PRESSURE = Name(value='peerPressure')

SHORTEST_PATH = Name(value='shortestPath')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WithOptionKeys')

WITH_OPTIONS_INDEXER = Name(value='withOptionsIndexer')

WITH_OPTIONS_TOKENS = Name(value='withOptionsTokens')

class hydra.tinkerpop.gremlin.WithOptionKeysConnectedComponent(value: T): Bases: Node[ConnectedComponentConstants]

class hydra.tinkerpop.gremlin.WithOptionKeysIo(value: T): Bases: Node[IoOptionsKeys]

class hydra.tinkerpop.gremlin.WithOptionKeysPageRank(value: T): Bases: Node[PageRankConstants]

class hydra.tinkerpop.gremlin.WithOptionKeysPeerPressure(value: T): Bases: Node[PeerPressureConstants]

class hydra.tinkerpop.gremlin.WithOptionKeysShortestPath(value: T): Bases: Node[ShortestPathConstants]

class hydra.tinkerpop.gremlin.WithOptionKeysWithOptionsIndexer: Bases: object

class hydra.tinkerpop.gremlin.WithOptionKeysWithOptionsTokens: Bases: object

class hydra.tinkerpop.gremlin.WithOptionsValues(*values)

Bases: Enum

The named option values accepted by a Gremlin with() modulator.

ALL = Name(value='all')

IDS = Name(value='ids')

KEYS = Name(value='keys')

LABELS = Name(value='labels')

LIST = Name(value='list')

MAP = Name(value='map')

NONE = Name(value='none')

TOKENS = Name(value='tokens')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WithOptionsValues')

VALUES = Name(value='values')

class hydra.tinkerpop.gremlin.WithSackArgs(initial_value: GenericLiteralArgument, bi_function: object)

Bases: object

The arguments of a Gremlin withSack() step.

BI_FUNCTION = Name(value='biFunction')

class Builder(_initial_value: 'GenericLiteralArgument' = None, _bi_function: 'Optional[TraversalBiFunctionArgument]' = None)

Bases: object

bi_function(bi_function)

build()

initial_value(initial_value)

INITIAL_VALUE = Name(value='initialValue')

TYPE_ = Name(value='hydra.tinkerpop.gremlin.WithSackArgs')

bi_function: object

static builder()

initial_value: GenericLiteralArgument

with_bi_function(bi_function)

with_initial_value(initial_value)