This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
commit 4d6d974a3960be1d080bc889ed50f929e381a4b9
Merge: d029172 931a75d
Author: Stephen Mallette <stepm...@amazon.com>
AuthorDate: Fri Jan 8 08:26:37 2021 -0500
Merge branch '3.4-dev'
.../tinkerpop/gremlin/process/traversal/Traversal.java | 4 +++-
.../gremlin/process/traversal/dsl/graph/GraphTraversal.java | 13 +++++++++++++
.../src/Gremlin.Net/Process/Traversal/GraphTraversal.cs | 9 +++++++++
.../gremlin-javascript/lib/process/graph-traversal.js | 10 ++++++++++
.../main/python/gremlin_python/process/graph_traversal.py | 4 ++++
5 files changed, 39 insertions(+), 1 deletion(-)
diff --cc
gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
index 65f3b03,0000000..698056f
mode 100644,000000..100644
--- a/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
+++ b/gremlin-python/src/main/python/gremlin_python/process/graph_traversal.py
@@@ -1,1576 -1,0 +1,1580 @@@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+import sys
+import copy
+from .traversal import Traversal
+from .traversal import TraversalStrategies
+from .strategies import VertexProgramStrategy, OptionsStrategy
+from .traversal import Bytecode
+from ..driver.remote_connection import RemoteStrategy
+from .. import statics
+from ..statics import long
+
+
+class GraphTraversalSource(object):
+ def __init__(self, graph, traversal_strategies, bytecode=None):
+ self.graph = graph
+ self.traversal_strategies = traversal_strategies
+ if bytecode is None:
+ bytecode = Bytecode()
+ self.bytecode = bytecode
+ self.graph_traversal = GraphTraversal
+
+ def __repr__(self):
+ return "graphtraversalsource[" + str(self.graph) + "]"
+
+ def get_graph_traversal_source(self):
+ return self.__class__(self.graph,
TraversalStrategies(self.traversal_strategies), Bytecode(self.bytecode))
+
+ def get_graph_traversal(self):
+ return self.graph_traversal(self.graph, self.traversal_strategies,
Bytecode(self.bytecode))
+
+ def withBulk(self, *args):
+ source = self.get_graph_traversal_source()
+ source.bytecode.add_source("withBulk", *args)
+ return source
+
+ def withPath(self, *args):
+ source = self.get_graph_traversal_source()
+ source.bytecode.add_source("withPath", *args)
+ return source
+
+ def withSack(self, *args):
+ source = self.get_graph_traversal_source()
+ source.bytecode.add_source("withSack", *args)
+ return source
+
+ def withSideEffect(self, *args):
+ source = self.get_graph_traversal_source()
+ source.bytecode.add_source("withSideEffect", *args)
+ return source
+
+ def withStrategies(self, *args):
+ source = self.get_graph_traversal_source()
+ source.bytecode.add_source("withStrategies", *args)
+ return source
+
+ def withoutStrategies(self, *args):
+ source = self.get_graph_traversal_source()
+ source.bytecode.add_source("withoutStrategies", *args)
+ return source
+
+ def with_(self, k, v=None):
+ source = self.get_graph_traversal_source()
+ options_strategy = next((x for x in
source.bytecode.source_instructions
+ if x[0] == "withStrategies" and type(x[1]) is
OptionsStrategy), None)
+
+ val = True if v is None else v
+ if options_strategy is None:
+ options_strategy = OptionsStrategy({k: val})
+ source = self.withStrategies(options_strategy)
+ else:
+ options_strategy[1].configuration[k] = val
+
+ return source
+
+ def withRemote(self, remote_connection):
+ source = self.get_graph_traversal_source()
+
source.traversal_strategies.add_strategies([RemoteStrategy(remote_connection)])
+ return source
+
+ def withComputer(self, graph_computer=None, workers=None, result=None,
persist=None, vertices=None,
+ edges=None, configuration=None):
+ return self.withStrategies(VertexProgramStrategy(graph_computer,
workers, result, persist, vertices,
+ edges, configuration))
+
+ def E(self, *args):
+ traversal = self.get_graph_traversal()
+ traversal.bytecode.add_step("E", *args)
+ return traversal
+
+ def V(self, *args):
+ traversal = self.get_graph_traversal()
+ traversal.bytecode.add_step("V", *args)
+ return traversal
+
+ def addE(self, *args):
+ traversal = self.get_graph_traversal()
+ traversal.bytecode.add_step("addE", *args)
+ return traversal
+
+ def addV(self, *args):
+ traversal = self.get_graph_traversal()
+ traversal.bytecode.add_step("addV", *args)
+ return traversal
+
+ def inject(self, *args):
+ traversal = self.get_graph_traversal()
+ traversal.bytecode.add_step("inject", *args)
+ return traversal
+
+ def io(self, *args):
+ traversal = self.get_graph_traversal()
+ traversal.bytecode.add_step("io", *args)
+ return traversal
+
+
+class GraphTraversal(Traversal):
+ def __init__(self, graph, traversal_strategies, bytecode):
+ super(GraphTraversal, self).__init__(graph, traversal_strategies,
bytecode)
+
+ def __getitem__(self, index):
+ if isinstance(index, int):
+ return self.range(long(index), long(index + 1))
+ elif isinstance(index, slice):
+ low = long(0) if index.start is None else long(index.start)
+ high = long(sys.maxsize) if index.stop is None else
long(index.stop)
+ if low == long(0):
+ return self.limit(high)
+ else:
+ return self.range(low,high)
+ else:
+ raise TypeError("Index must be int or slice")
+
+ def __getattr__(self, key):
+ if key.startswith('__'):
+ raise AttributeError(
+ 'Python magic methods or keys starting with double underscore
cannot be used for Gremlin sugar - prefer values(' + key + ')')
+ return self.values(key)
+
+ def clone(self):
+ return GraphTraversal(self.graph, self.traversal_strategies,
copy.deepcopy(self.bytecode))
+
+ def V(self, *args):
+ self.bytecode.add_step("V", *args)
+ return self
+
+ def addE(self, *args):
+ self.bytecode.add_step("addE", *args)
+ return self
+
+ def addV(self, *args):
+ self.bytecode.add_step("addV", *args)
+ return self
+
+ def aggregate(self, *args):
+ self.bytecode.add_step("aggregate", *args)
+ return self
+
+ def and_(self, *args):
+ self.bytecode.add_step("and", *args)
+ return self
+
+ def as_(self, *args):
+ self.bytecode.add_step("as", *args)
+ return self
+
+ def barrier(self, *args):
+ self.bytecode.add_step("barrier", *args)
+ return self
+
+ def both(self, *args):
+ self.bytecode.add_step("both", *args)
+ return self
+
+ def bothE(self, *args):
+ self.bytecode.add_step("bothE", *args)
+ return self
+
+ def bothV(self, *args):
+ self.bytecode.add_step("bothV", *args)
+ return self
+
+ def branch(self, *args):
+ self.bytecode.add_step("branch", *args)
+ return self
+
+ def by(self, *args):
+ self.bytecode.add_step("by", *args)
+ return self
+
+ def cap(self, *args):
+ self.bytecode.add_step("cap", *args)
+ return self
+
+ def choose(self, *args):
+ self.bytecode.add_step("choose", *args)
+ return self
+
+ def coalesce(self, *args):
+ self.bytecode.add_step("coalesce", *args)
+ return self
+
+ def coin(self, *args):
+ self.bytecode.add_step("coin", *args)
+ return self
+
+ def connectedComponent(self, *args):
+ self.bytecode.add_step("connectedComponent", *args)
+ return self
+
+ def constant(self, *args):
+ self.bytecode.add_step("constant", *args)
+ return self
+
+ def count(self, *args):
+ self.bytecode.add_step("count", *args)
+ return self
+
+ def cyclicPath(self, *args):
+ self.bytecode.add_step("cyclicPath", *args)
+ return self
+
+ def dedup(self, *args):
+ self.bytecode.add_step("dedup", *args)
+ return self
+
+ def drop(self, *args):
+ self.bytecode.add_step("drop", *args)
+ return self
+
+ def elementMap(self, *args):
+ self.bytecode.add_step("elementMap", *args)
+ return self
+
+ def emit(self, *args):
+ self.bytecode.add_step("emit", *args)
+ return self
+
+ def filter_(self, *args):
+ self.bytecode.add_step("filter", *args)
+ return self
+
+ def flatMap(self, *args):
+ self.bytecode.add_step("flatMap", *args)
+ return self
+
+ def fold(self, *args):
+ self.bytecode.add_step("fold", *args)
+ return self
+
+ def from_(self, *args):
+ self.bytecode.add_step("from", *args)
+ return self
+
+ def group(self, *args):
+ self.bytecode.add_step("group", *args)
+ return self
+
+ def groupCount(self, *args):
+ self.bytecode.add_step("groupCount", *args)
+ return self
+
+ def has(self, *args):
+ self.bytecode.add_step("has", *args)
+ return self
+
+ def hasId(self, *args):
+ self.bytecode.add_step("hasId", *args)
+ return self
+
+ def hasKey(self, *args):
+ self.bytecode.add_step("hasKey", *args)
+ return self
+
+ def hasLabel(self, *args):
+ self.bytecode.add_step("hasLabel", *args)
+ return self
+
+ def hasNot(self, *args):
+ self.bytecode.add_step("hasNot", *args)
+ return self
+
+ def hasValue(self, *args):
+ self.bytecode.add_step("hasValue", *args)
+ return self
+
+ def id_(self, *args):
+ self.bytecode.add_step("id", *args)
+ return self
+
+ def identity(self, *args):
+ self.bytecode.add_step("identity", *args)
+ return self
+
+ def inE(self, *args):
+ self.bytecode.add_step("inE", *args)
+ return self
+
+ def inV(self, *args):
+ self.bytecode.add_step("inV", *args)
+ return self
+
+ def in_(self, *args):
+ self.bytecode.add_step("in", *args)
+ return self
+
+ def index(self, *args):
+ self.bytecode.add_step("index", *args)
+ return self
+
+ def inject(self, *args):
+ self.bytecode.add_step("inject", *args)
+ return self
+
+ def is_(self, *args):
+ self.bytecode.add_step("is", *args)
+ return self
+
+ def key(self, *args):
+ self.bytecode.add_step("key", *args)
+ return self
+
+ def label(self, *args):
+ self.bytecode.add_step("label", *args)
+ return self
+
+ def limit(self, *args):
+ self.bytecode.add_step("limit", *args)
+ return self
+
+ def local(self, *args):
+ self.bytecode.add_step("local", *args)
+ return self
+
+ def loops(self, *args):
+ self.bytecode.add_step("loops", *args)
+ return self
+
+ def map(self, *args):
+ self.bytecode.add_step("map", *args)
+ return self
+
+ def match(self, *args):
+ self.bytecode.add_step("match", *args)
+ return self
+
+ def math(self, *args):
+ self.bytecode.add_step("math", *args)
+ return self
+
+ def max_(self, *args):
+ self.bytecode.add_step("max", *args)
+ return self
+
+ def mean(self, *args):
+ self.bytecode.add_step("mean", *args)
+ return self
+
+ def min_(self, *args):
+ self.bytecode.add_step("min", *args)
+ return self
+
++ def none(self, *args):
++ self.bytecode.add_step("none", *args)
++ return self
++
+ def not_(self, *args):
+ self.bytecode.add_step("not", *args)
+ return self
+
+ def option(self, *args):
+ self.bytecode.add_step("option", *args)
+ return self
+
+ def optional(self, *args):
+ self.bytecode.add_step("optional", *args)
+ return self
+
+ def or_(self, *args):
+ self.bytecode.add_step("or", *args)
+ return self
+
+ def order(self, *args):
+ self.bytecode.add_step("order", *args)
+ return self
+
+ def otherV(self, *args):
+ self.bytecode.add_step("otherV", *args)
+ return self
+
+ def out(self, *args):
+ self.bytecode.add_step("out", *args)
+ return self
+
+ def outE(self, *args):
+ self.bytecode.add_step("outE", *args)
+ return self
+
+ def outV(self, *args):
+ self.bytecode.add_step("outV", *args)
+ return self
+
+ def pageRank(self, *args):
+ self.bytecode.add_step("pageRank", *args)
+ return self
+
+ def path(self, *args):
+ self.bytecode.add_step("path", *args)
+ return self
+
+ def peerPressure(self, *args):
+ self.bytecode.add_step("peerPressure", *args)
+ return self
+
+ def profile(self, *args):
+ self.bytecode.add_step("profile", *args)
+ return self
+
+ def program(self, *args):
+ self.bytecode.add_step("program", *args)
+ return self
+
+ def project(self, *args):
+ self.bytecode.add_step("project", *args)
+ return self
+
+ def properties(self, *args):
+ self.bytecode.add_step("properties", *args)
+ return self
+
+ def property(self, *args):
+ self.bytecode.add_step("property", *args)
+ return self
+
+ def propertyMap(self, *args):
+ self.bytecode.add_step("propertyMap", *args)
+ return self
+
+ def range_(self, *args):
+ self.bytecode.add_step("range", *args)
+ return self
+
+ def read(self, *args):
+ self.bytecode.add_step("read", *args)
+ return self
+
+ def repeat(self, *args):
+ self.bytecode.add_step("repeat", *args)
+ return self
+
+ def sack(self, *args):
+ self.bytecode.add_step("sack", *args)
+ return self
+
+ def sample(self, *args):
+ self.bytecode.add_step("sample", *args)
+ return self
+
+ def select(self, *args):
+ self.bytecode.add_step("select", *args)
+ return self
+
+ def shortestPath(self, *args):
+ self.bytecode.add_step("shortestPath", *args)
+ return self
+
+ def sideEffect(self, *args):
+ self.bytecode.add_step("sideEffect", *args)
+ return self
+
+ def simplePath(self, *args):
+ self.bytecode.add_step("simplePath", *args)
+ return self
+
+ def skip(self, *args):
+ self.bytecode.add_step("skip", *args)
+ return self
+
+ def store(self, *args):
+ self.bytecode.add_step("store", *args)
+ return self
+
+ def subgraph(self, *args):
+ self.bytecode.add_step("subgraph", *args)
+ return self
+
+ def sum_(self, *args):
+ self.bytecode.add_step("sum", *args)
+ return self
+
+ def tail(self, *args):
+ self.bytecode.add_step("tail", *args)
+ return self
+
+ def timeLimit(self, *args):
+ self.bytecode.add_step("timeLimit", *args)
+ return self
+
+ def times(self, *args):
+ self.bytecode.add_step("times", *args)
+ return self
+
+ def to(self, *args):
+ self.bytecode.add_step("to", *args)
+ return self
+
+ def toE(self, *args):
+ self.bytecode.add_step("toE", *args)
+ return self
+
+ def toV(self, *args):
+ self.bytecode.add_step("toV", *args)
+ return self
+
+ def tree(self, *args):
+ self.bytecode.add_step("tree", *args)
+ return self
+
+ def unfold(self, *args):
+ self.bytecode.add_step("unfold", *args)
+ return self
+
+ def union(self, *args):
+ self.bytecode.add_step("union", *args)
+ return self
+
+ def until(self, *args):
+ self.bytecode.add_step("until", *args)
+ return self
+
+ def value(self, *args):
+ self.bytecode.add_step("value", *args)
+ return self
+
+ def valueMap(self, *args):
+ self.bytecode.add_step("valueMap", *args)
+ return self
+
+ def values(self, *args):
+ self.bytecode.add_step("values", *args)
+ return self
+
+ def where(self, *args):
+ self.bytecode.add_step("where", *args)
+ return self
+
+ def with_(self, *args):
+ self.bytecode.add_step("with", *args)
+ return self
+
+ def write(self, *args):
+ self.bytecode.add_step("write", *args)
+ return self
+
+ # Deprecated - prefer the underscore suffixed versions e.g filter_()
+
+ def filter(self, *args):
+ self.bytecode.add_step("filter", *args)
+ return self
+
+ def id(self, *args):
+ self.bytecode.add_step("id", *args)
+ return self
+
+ def max(self, *args):
+ self.bytecode.add_step("max", *args)
+ return self
+
+ def min(self, *args):
+ self.bytecode.add_step("min", *args)
+ return self
+
+ def range(self, *args):
+ self.bytecode.add_step("range", *args)
+ return self
+
+ def sum(self, *args):
+ self.bytecode.add_step("sum", *args)
+ return self
+
+
+class MagicType(type):
+
+ def __getattr__(cls, k):
+ if k.startswith('__'):
+ raise AttributeError(
+ 'Python magic methods or keys starting with double underscore
cannot be used for Gremlin sugar - prefer values(' + k + ')')
+ return __.values(k)
+
+
+class __(object, metaclass=MagicType):
+ graph_traversal = GraphTraversal
+
+ @classmethod
+ def start(cls):
+ return GraphTraversal(None, None, Bytecode())
+
+ @classmethod
+ def __(cls, *args):
+ return __.inject(*args)
+
+ @classmethod
+ def V(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).V(*args)
+
+ @classmethod
+ def addE(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).addE(*args)
+
+ @classmethod
+ def addV(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).addV(*args)
+
+ @classmethod
+ def aggregate(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).aggregate(*args)
+
+ @classmethod
+ def and_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).and_(*args)
+
+ @classmethod
+ def as_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).as_(*args)
+
+ @classmethod
+ def barrier(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).barrier(*args)
+
+ @classmethod
+ def both(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).both(*args)
+
+ @classmethod
+ def bothE(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).bothE(*args)
+
+ @classmethod
+ def bothV(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).bothV(*args)
+
+ @classmethod
+ def branch(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).branch(*args)
+
+ @classmethod
+ def cap(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).cap(*args)
+
+ @classmethod
+ def choose(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).choose(*args)
+
+ @classmethod
+ def coalesce(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).coalesce(*args)
+
+ @classmethod
+ def coin(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).coin(*args)
+
+ @classmethod
+ def constant(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).constant(*args)
+
+ @classmethod
+ def count(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).count(*args)
+
+ @classmethod
+ def cyclicPath(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).cyclicPath(*args)
+
+ @classmethod
+ def dedup(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).dedup(*args)
+
+ @classmethod
+ def drop(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).drop(*args)
+
+ @classmethod
+ def elementMap(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).elementMap(*args)
+
+ @classmethod
+ def emit(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).emit(*args)
+
+ @classmethod
+ def filter_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).filter_(*args)
+
+ @classmethod
+ def flatMap(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).flatMap(*args)
+
+ @classmethod
+ def fold(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).fold(*args)
+
+ @classmethod
+ def group(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).group(*args)
+
+ @classmethod
+ def groupCount(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).groupCount(*args)
+
+ @classmethod
+ def has(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).has(*args)
+
+ @classmethod
+ def hasId(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).hasId(*args)
+
+ @classmethod
+ def hasKey(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).hasKey(*args)
+
+ @classmethod
+ def hasLabel(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).hasLabel(*args)
+
+ @classmethod
+ def hasNot(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).hasNot(*args)
+
+ @classmethod
+ def hasValue(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).hasValue(*args)
+
+ @classmethod
+ def id_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).id_(*args)
+
+ @classmethod
+ def identity(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).identity(*args)
+
+ @classmethod
+ def inE(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).inE(*args)
+
+ @classmethod
+ def inV(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).inV(*args)
+
+ @classmethod
+ def in_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).in_(*args)
+
+ @classmethod
+ def index(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).index(*args)
+
+ @classmethod
+ def inject(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).inject(*args)
+
+ @classmethod
+ def is_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).is_(*args)
+
+ @classmethod
+ def key(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).key(*args)
+
+ @classmethod
+ def label(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).label(*args)
+
+ @classmethod
+ def limit(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).limit(*args)
+
+ @classmethod
+ def local(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).local(*args)
+
+ @classmethod
+ def loops(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).loops(*args)
+
+ @classmethod
+ def map(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).map(*args)
+
+ @classmethod
+ def match(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).match(*args)
+
+ @classmethod
+ def math(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).math(*args)
+
+ @classmethod
+ def max_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).max_(*args)
+
+ @classmethod
+ def mean(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).mean(*args)
+
+ @classmethod
+ def min_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).min_(*args)
+
+ @classmethod
+ def not_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).not_(*args)
+
+ @classmethod
+ def optional(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).optional(*args)
+
+ @classmethod
+ def or_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).or_(*args)
+
+ @classmethod
+ def order(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).order(*args)
+
+ @classmethod
+ def otherV(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).otherV(*args)
+
+ @classmethod
+ def out(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).out(*args)
+
+ @classmethod
+ def outE(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).outE(*args)
+
+ @classmethod
+ def outV(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).outV(*args)
+
+ @classmethod
+ def path(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).path(*args)
+
+ @classmethod
+ def project(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).project(*args)
+
+ @classmethod
+ def properties(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).properties(*args)
+
+ @classmethod
+ def property(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).property(*args)
+
+ @classmethod
+ def propertyMap(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).propertyMap(*args)
+
+ @classmethod
+ def range_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).range_(*args)
+
+ @classmethod
+ def repeat(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).repeat(*args)
+
+ @classmethod
+ def sack(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).sack(*args)
+
+ @classmethod
+ def sample(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).sample(*args)
+
+ @classmethod
+ def select(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).select(*args)
+
+ @classmethod
+ def sideEffect(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).sideEffect(*args)
+
+ @classmethod
+ def simplePath(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).simplePath(*args)
+
+ @classmethod
+ def skip(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).skip(*args)
+
+ @classmethod
+ def store(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).store(*args)
+
+ @classmethod
+ def subgraph(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).subgraph(*args)
+
+ @classmethod
+ def sum_(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).sum_(*args)
+
+ @classmethod
+ def tail(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).tail(*args)
+
+ @classmethod
+ def timeLimit(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).timeLimit(*args)
+
+ @classmethod
+ def times(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).times(*args)
+
+ @classmethod
+ def to(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).to(*args)
+
+ @classmethod
+ def toE(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).toE(*args)
+
+ @classmethod
+ def toV(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).toV(*args)
+
+ @classmethod
+ def tree(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).tree(*args)
+
+ @classmethod
+ def unfold(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).unfold(*args)
+
+ @classmethod
+ def union(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).union(*args)
+
+ @classmethod
+ def until(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).until(*args)
+
+ @classmethod
+ def value(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).value(*args)
+
+ @classmethod
+ def valueMap(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).valueMap(*args)
+
+ @classmethod
+ def values(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).values(*args)
+
+ @classmethod
+ def where(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).where(*args)
+
+ # Deprecated - prefer the underscore suffixed versions e.g filter_()
+
+ @classmethod
+ def filter(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).filter_(*args)
+
+ @classmethod
+ def id(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).id_(*args)
+
+ @classmethod
+ def max(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).max_(*args)
+
+ @classmethod
+ def min(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).min_(*args)
+
+ @classmethod
+ def range(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).range_(*args)
+
+ @classmethod
+ def sum(cls, *args):
+ return cls.graph_traversal(None, None, Bytecode()).sum_(*args)
+
+
+def V(*args):
+ return __.V(*args)
+
+
+def addE(*args):
+ return __.addE(*args)
+
+
+def addV(*args):
+ return __.addV(*args)
+
+
+def aggregate(*args):
+ return __.aggregate(*args)
+
+
+def and_(*args):
+ return __.and_(*args)
+
+
+def as_(*args):
+ return __.as_(*args)
+
+
+def barrier(*args):
+ return __.barrier(*args)
+
+
+def both(*args):
+ return __.both(*args)
+
+
+def bothE(*args):
+ return __.bothE(*args)
+
+
+def bothV(*args):
+ return __.bothV(*args)
+
+
+def branch(*args):
+ return __.branch(*args)
+
+
+def cap(*args):
+ return __.cap(*args)
+
+
+def choose(*args):
+ return __.choose(*args)
+
+
+def coalesce(*args):
+ return __.coalesce(*args)
+
+
+def coin(*args):
+ return __.coin(*args)
+
+
+def constant(*args):
+ return __.constant(*args)
+
+
+def count(*args):
+ return __.count(*args)
+
+
+def cyclicPath(*args):
+ return __.cyclicPath(*args)
+
+
+def dedup(*args):
+ return __.dedup(*args)
+
+
+def drop(*args):
+ return __.drop(*args)
+
+
+def elementMap(*args):
+ return __.elementMap(*args)
+
+
+def emit(*args):
+ return __.emit(*args)
+
+
+def filter_(*args):
+ return __.filter_(*args)
+
+
+def flatMap(*args):
+ return __.flatMap(*args)
+
+
+def fold(*args):
+ return __.fold(*args)
+
+
+def group(*args):
+ return __.group(*args)
+
+
+def groupCount(*args):
+ return __.groupCount(*args)
+
+
+def has(*args):
+ return __.has(*args)
+
+
+def hasId(*args):
+ return __.hasId(*args)
+
+
+def hasKey(*args):
+ return __.hasKey(*args)
+
+
+def hasLabel(*args):
+ return __.hasLabel(*args)
+
+
+def hasNot(*args):
+ return __.hasNot(*args)
+
+
+def hasValue(*args):
+ return __.hasValue(*args)
+
+
+def id_(*args):
+ return __.id_(*args)
+
+
+def identity(*args):
+ return __.identity(*args)
+
+
+def inE(*args):
+ return __.inE(*args)
+
+
+def inV(*args):
+ return __.inV(*args)
+
+
+def in_(*args):
+ return __.in_(*args)
+
+
+def index(*args):
+ return __.index(*args)
+
+
+def inject(*args):
+ return __.inject(*args)
+
+
+def is_(*args):
+ return __.is_(*args)
+
+
+def key(*args):
+ return __.key(*args)
+
+
+def label(*args):
+ return __.label(*args)
+
+
+def limit(*args):
+ return __.limit(*args)
+
+
+def local(*args):
+ return __.local(*args)
+
+
+def loops(*args):
+ return __.loops(*args)
+
+
+def map(*args):
+ return __.map(*args)
+
+
+def match(*args):
+ return __.match(*args)
+
+
+def math(*args):
+ return __.math(*args)
+
+
+def max_(*args):
+ return __.max_(*args)
+
+
+def mean(*args):
+ return __.mean(*args)
+
+
+def min_(*args):
+ return __.min_(*args)
+
+
+def not_(*args):
+ return __.not_(*args)
+
+
+def optional(*args):
+ return __.optional(*args)
+
+
+def or_(*args):
+ return __.or_(*args)
+
+
+def order(*args):
+ return __.order(*args)
+
+
+def otherV(*args):
+ return __.otherV(*args)
+
+
+def out(*args):
+ return __.out(*args)
+
+
+def outE(*args):
+ return __.outE(*args)
+
+
+def outV(*args):
+ return __.outV(*args)
+
+
+def path(*args):
+ return __.path(*args)
+
+
+def project(*args):
+ return __.project(*args)
+
+
+def properties(*args):
+ return __.properties(*args)
+
+
+def property(*args):
+ return __.property(*args)
+
+
+def propertyMap(*args):
+ return __.propertyMap(*args)
+
+
+def range_(*args):
+ return __.range_(*args)
+
+
+def repeat(*args):
+ return __.repeat(*args)
+
+
+def sack(*args):
+ return __.sack(*args)
+
+
+def sample(*args):
+ return __.sample(*args)
+
+
+def select(*args):
+ return __.select(*args)
+
+
+def sideEffect(*args):
+ return __.sideEffect(*args)
+
+
+def simplePath(*args):
+ return __.simplePath(*args)
+
+
+def skip(*args):
+ return __.skip(*args)
+
+
+def store(*args):
+ return __.store(*args)
+
+
+def subgraph(*args):
+ return __.subgraph(*args)
+
+
+def sum_(*args):
+ return __.sum_(*args)
+
+
+def tail(*args):
+ return __.tail(*args)
+
+
+def timeLimit(*args):
+ return __.timeLimit(*args)
+
+
+def times(*args):
+ return __.times(*args)
+
+
+def to(*args):
+ return __.to(*args)
+
+
+def toE(*args):
+ return __.toE(*args)
+
+
+def toV(*args):
+ return __.toV(*args)
+
+
+def tree(*args):
+ return __.tree(*args)
+
+
+def unfold(*args):
+ return __.unfold(*args)
+
+
+def union(*args):
+ return __.union(*args)
+
+
+def until(*args):
+ return __.until(*args)
+
+
+def value(*args):
+ return __.value(*args)
+
+
+def valueMap(*args):
+ return __.valueMap(*args)
+
+
+def values(*args):
+ return __.values(*args)
+
+
+def where(*args):
+ return __.where(*args)
+
+
+# Deprecated - prefer the underscore suffixed versions e.g filter_()
+
+def filter(*args):
+ return __.filter_(*args)
+
+
+def id(*args):
+ return __.id_(*args)
+
+
+def max(*args):
+ return __.max_(*args)
+
+
+def min(*args):
+ return __.min_(*args)
+
+
+def range(*args):
+ return __.range_(*args)
+
+
+def sum(*args):
+ return __.sum_(*args)
+
+
+statics.add_static('V', V)
+
+statics.add_static('addE', addE)
+
+statics.add_static('addV', addV)
+
+statics.add_static('aggregate', aggregate)
+
+statics.add_static('and_', and_)
+
+statics.add_static('as_', as_)
+
+statics.add_static('barrier', barrier)
+
+statics.add_static('both', both)
+
+statics.add_static('bothE', bothE)
+
+statics.add_static('bothV', bothV)
+
+statics.add_static('branch', branch)
+
+statics.add_static('cap', cap)
+
+statics.add_static('choose', choose)
+
+statics.add_static('coalesce', coalesce)
+
+statics.add_static('coin', coin)
+
+statics.add_static('constant', constant)
+
+statics.add_static('count', count)
+
+statics.add_static('cyclicPath', cyclicPath)
+
+statics.add_static('dedup', dedup)
+
+statics.add_static('drop', drop)
+
+statics.add_static('elementMap', elementMap)
+
+statics.add_static('emit', emit)
+
+statics.add_static('filter_', filter_)
+
+statics.add_static('flatMap', flatMap)
+
+statics.add_static('fold', fold)
+
+statics.add_static('group', group)
+
+statics.add_static('groupCount', groupCount)
+
+statics.add_static('has', has)
+
+statics.add_static('hasId', hasId)
+
+statics.add_static('hasKey', hasKey)
+
+statics.add_static('hasLabel', hasLabel)
+
+statics.add_static('hasNot', hasNot)
+
+statics.add_static('hasValue', hasValue)
+
+statics.add_static('id_', id_)
+
+statics.add_static('identity', identity)
+
+statics.add_static('inE', inE)
+
+statics.add_static('inV', inV)
+
+statics.add_static('in_', in_)
+
+statics.add_static('index', index)
+
+statics.add_static('inject', inject)
+
+statics.add_static('is_', is_)
+
+statics.add_static('key', key)
+
+statics.add_static('label', label)
+
+statics.add_static('limit', limit)
+
+statics.add_static('local', local)
+
+statics.add_static('loops', loops)
+
+statics.add_static('map', map)
+
+statics.add_static('match', match)
+
+statics.add_static('math', math)
+
+statics.add_static('max_', max_)
+
+statics.add_static('mean', mean)
+
+statics.add_static('min_', min_)
+
+statics.add_static('not_', not_)
+
+statics.add_static('optional', optional)
+
+statics.add_static('or_', or_)
+
+statics.add_static('order', order)
+
+statics.add_static('otherV', otherV)
+
+statics.add_static('out', out)
+
+statics.add_static('outE', outE)
+
+statics.add_static('outV', outV)
+
+statics.add_static('path', path)
+
+statics.add_static('project', project)
+
+statics.add_static('properties', properties)
+
+statics.add_static('property', property)
+
+statics.add_static('propertyMap', propertyMap)
+
+statics.add_static('range_', range_)
+
+statics.add_static('repeat', repeat)
+
+statics.add_static('sack', sack)
+
+statics.add_static('sample', sample)
+
+statics.add_static('select', select)
+
+statics.add_static('sideEffect', sideEffect)
+
+statics.add_static('simplePath', simplePath)
+
+statics.add_static('skip', skip)
+
+statics.add_static('store', store)
+
+statics.add_static('subgraph', subgraph)
+
+statics.add_static('sum_', sum_)
+
+statics.add_static('tail', tail)
+
+statics.add_static('timeLimit', timeLimit)
+
+statics.add_static('times', times)
+
+statics.add_static('to', to)
+
+statics.add_static('toE', toE)
+
+statics.add_static('toV', toV)
+
+statics.add_static('tree', tree)
+
+statics.add_static('unfold', unfold)
+
+statics.add_static('union', union)
+
+statics.add_static('until', until)
+
+statics.add_static('value', value)
+
+statics.add_static('valueMap', valueMap)
+
+statics.add_static('values', values)
+
+statics.add_static('where', where)
+
+
+# Deprecated - prefer the underscore suffixed versions e.g filter_()
+
+statics.add_static('filter', filter)
+statics.add_static('id', id)
+statics.add_static('max', max)
+statics.add_static('min', min)
+statics.add_static('range', range)
+statics.add_static('sum', sum)
