You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by sp...@apache.org on 2021/01/08 13:27:00 UTC
[tinkerpop] branch master updated (d029172 -> 4d6d974)
This is an automated email from the ASF dual-hosted git repository.
spmallette pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git.
from d029172 Merge branch 'TINKERPOP-2473'
new 931a75d TINKERPOP-2500 Added none() to GLVs CTR
new 4d6d974 Merge branch '3.4-dev'
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../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(-)
[tinkerpop] 01/02: TINKERPOP-2500 Added none() to GLVs CTR
Posted by sp...@apache.org.
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 931a75d3ace5647adc670e7cdb57b760ae09b749
Author: Stephen Mallette <st...@amazon.com>
AuthorDate: Fri Jan 8 08:08:07 2021 -0500
TINKERPOP-2500 Added none() to GLVs CTR
---
.../gremlin/process/traversal/Traversal.java | 4 +++-
.../traversal/dsl/graph/GraphTraversal.java | 13 +++++++++++
gremlin-dotnet/glv/generate.groovy | 26 +++++++++++-----------
.../Process/Traversal/GraphTraversal.cs | 9 ++++++++
gremlin-javascript/glv/generate.groovy | 18 +++++++--------
.../lib/process/graph-traversal.js | 10 +++++++++
gremlin-python/glv/generate.groovy | 12 +++++-----
.../gremlin_python/process/graph_traversal.py | 4 ++++
8 files changed, 67 insertions(+), 29 deletions(-)
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/Traversal.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/Traversal.java
index 11c12c3..b1b45f3 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/Traversal.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/Traversal.java
@@ -217,7 +217,9 @@ public interface Traversal<S, E> extends Iterator<E>, Serializable, Cloneable, A
}
/**
- * Filter all traversers in the traversal.
+ * Filter all traversers in the traversal. This step has narrow use cases and is primarily intended for use as a
+ * signal to remote servers that {@link #iterate()} was called. While it may be directly used, it is often a sign
+ * that a traversal should be re-written in another form.
*
* @return the updated traversal with respective {@link NoneStep}.
*/
diff --git a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
index be465c9..ef541eb 100644
--- a/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
+++ b/gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java
@@ -59,6 +59,7 @@ import org.apache.tinkerpop.gremlin.process.traversal.step.filter.DropStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.HasStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.IsStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.LambdaFilterStep;
+import org.apache.tinkerpop.gremlin.process.traversal.step.filter.NoneStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.NotStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.OrStep;
import org.apache.tinkerpop.gremlin.process.traversal.step.filter.PathFilterStep;
@@ -2127,6 +2128,18 @@ public interface GraphTraversal<S, E> extends Traversal<S, E> {
}
/**
+ * Filter all traversers in the traversal. This step has narrow use cases and is primarily intended for use as a
+ * signal to remote servers that {@link #iterate()} was called. While it may be directly used, it is often a sign
+ * that a traversal should be re-written in another form.
+ *
+ * @return the updated traversal with respective {@link NoneStep}.
+ */
+ @Override
+ default GraphTraversal<S, E> none() {
+ return (GraphTraversal<S, E>) Traversal.super.none();
+ }
+
+ /**
* Sets a {@link Property} value and related meta properties if supplied, if supported by the {@link Graph}
* and if the {@link Element} is a {@link VertexProperty}. This method is the long-hand version of
* {@link #property(Object, Object, Object...)} with the difference that the {@link VertexProperty.Cardinality}
diff --git a/gremlin-dotnet/glv/generate.groovy b/gremlin-dotnet/glv/generate.groovy
index a951907..a921a29 100644
--- a/gremlin-dotnet/glv/generate.groovy
+++ b/gremlin-dotnet/glv/generate.groovy
@@ -107,7 +107,7 @@ def getCSharpGenericTypeParam = { typeName ->
def toCSharpType = { name ->
String typeName = toCSharpTypeMap.getOrDefault(name, name)
- if (typeName.equals(name) && (typeName.contains("? extends") || typeName.equals("Tree"))) {
+ if (typeName == name && (typeName.contains("? extends") || typeName == "Tree")) {
typeName = "E2"
}
return typeName
@@ -124,10 +124,10 @@ def getJavaGenericTypeParameterTypeNames = { method ->
return typeArguments.
collect { (it instanceof Class) ? ((Class)it).simpleName : it.typeName }.
collect { name ->
- if (name.equals("A")) {
+ if (name == "A") {
name = "object"
}
- else if (name.equals("B")) {
+ else if (name == "B") {
name = "E2"
}
name
@@ -253,12 +253,12 @@ def binding = ["pmethods": P.class.getMethods().
unique().
sort { a, b -> a <=> b },
"sourceStepMethods": GraphTraversalSource.getMethods(). // SOURCE STEPS
- findAll { GraphTraversalSource.class.equals(it.returnType) }.
+ findAll { (GraphTraversalSource.class == it.returnType) }.
findAll {
- !it.name.equals("clone") &&
- !it.name.equals(TraversalSource.Symbols.with) &&
- !it.name.equals(TraversalSource.Symbols.withRemote) &&
- !it.name.equals(TraversalSource.Symbols.withComputer)
+ it.name != "clone" &&
+ it.name != TraversalSource.Symbols.with &&
+ it.name != TraversalSource.Symbols.withRemote &&
+ it.name != TraversalSource.Symbols.withComputer
}.
// Select unique combination of C# parameter types and sort by Java parameter type combination
sort { a, b -> a.name <=> b.name ?: getJavaParamTypeString(a) <=> getJavaParamTypeString(b) }.
@@ -269,7 +269,7 @@ def binding = ["pmethods": P.class.getMethods().
return ["methodName": javaMethod.name, "parameters":parameters, "paramNames":paramNames]
},
"sourceSpawnMethods": GraphTraversalSource.getMethods(). // SPAWN STEPS
- findAll { GraphTraversal.class.equals(it.returnType) }.
+ findAll { (GraphTraversal.class == it.returnType) }.
// Select unique combination of C# parameter types and sort by Java parameter type combination
sort { a, b -> a.name <=> b.name ?: getJavaParamTypeString(a) <=> getJavaParamTypeString(b) }.
unique { a,b -> a.name <=> b.name ?: getCSharpParamTypeString(a) <=> getCSharpParamTypeString(b) }.
@@ -284,8 +284,8 @@ def binding = ["pmethods": P.class.getMethods().
return ["methodName": javaMethod.name, "t1":t1, "t2":t2, "tParam":tParam, "parameters":parameters, "paramNames":paramNames, "isArgsCastNecessary":isArgsCastNecessary]
},
"graphStepMethods": GraphTraversal.getMethods().
- findAll { GraphTraversal.class.equals(it.returnType) }.
- findAll { !it.name.equals("clone") && !it.name.equals("iterate") }.
+ findAll { (GraphTraversal.class == it.returnType) }.
+ findAll { it.name != "clone" && it.name != "iterate" }.
// Select unique combination of C# parameter types and sort by Java parameter type combination
sort { a, b -> a.name <=> b.name ?: getJavaParamTypeString(a) <=> getJavaParamTypeString(b) }.
unique { a,b -> a.name <=> b.name ?: getCSharpParamTypeString(a) <=> getCSharpParamTypeString(b) }.
@@ -305,9 +305,9 @@ def binding = ["pmethods": P.class.getMethods().
return ["methodName": javaMethod.name, "t1":t1, "t2":t2, "tParam":tParam, "parameters":parameters, "paramNames":paramNames, "isArgsCastNecessary":isArgsCastNecessary]
},
"anonStepMethods": __.class.getMethods().
- findAll { GraphTraversal.class.equals(it.returnType) }.
+ findAll { (GraphTraversal.class == it.returnType) }.
findAll { Modifier.isStatic(it.getModifiers()) }.
- findAll { !it.name.equals("__") && !it.name.equals("start") }.
+ findAll { it.name != "__" && it.name != "start" }.
// Select unique combination of C# parameter types and sort by Java parameter type combination
sort { a, b -> a.name <=> b.name ?: getJavaParamTypeString(a) <=> getJavaParamTypeString(b) }.
unique { a,b -> a.name <=> b.name ?: getCSharpParamTypeString(a) <=> getCSharpParamTypeString(b) }.
diff --git a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
index 7394fe8..b6d3a83 100644
--- a/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
+++ b/gremlin-dotnet/src/Gremlin.Net/Process/Traversal/GraphTraversal.cs
@@ -1054,6 +1054,15 @@ namespace Gremlin.Net.Process.Traversal
}
/// <summary>
+ /// Adds the none step to this <see cref="GraphTraversal{SType, EType}" />.
+ /// </summary>
+ public GraphTraversal<S, E> None ()
+ {
+ Bytecode.AddStep("none");
+ return Wrap<S, E>(this);
+ }
+
+ /// <summary>
/// Adds the not step to this <see cref="GraphTraversal{SType, EType}" />.
/// </summary>
public GraphTraversal<S, E> Not (ITraversal notTraversal)
diff --git a/gremlin-javascript/glv/generate.groovy b/gremlin-javascript/glv/generate.groovy
index cfd1be5..2d3e1a1 100644
--- a/gremlin-javascript/glv/generate.groovy
+++ b/gremlin-javascript/glv/generate.groovy
@@ -82,33 +82,33 @@ def binding = ["enums": CoreImports.getClassImports()
unique().
sort { a, b -> a <=> b },
"sourceStepMethods": GraphTraversalSource.getMethods(). // SOURCE STEPS
- findAll { GraphTraversalSource.class.equals(it.returnType) }.
+ findAll { (GraphTraversalSource.class == it.returnType) }.
findAll {
!it.name.equals("clone") &&
// Use hardcoded name to be for forward-compatibility
- !it.name.equals("withBindings") &&
- !it.name.equals(TraversalSource.Symbols.with) &&
- !it.name.equals(TraversalSource.Symbols.withRemote) &&
- !it.name.equals(TraversalSource.Symbols.withComputer)
+ it.name != "withBindings" &&
+ it.name != TraversalSource.Symbols.with &&
+ it.name != TraversalSource.Symbols.withRemote &&
+ it.name != TraversalSource.Symbols.withComputer
}.
collect { it.name }.
unique().
sort { a, b -> a <=> b },
"sourceSpawnMethods": GraphTraversalSource.getMethods(). // SPAWN STEPS
- findAll { GraphTraversal.class.equals(it.returnType) }.
+ findAll { (GraphTraversal.class == it.returnType) }.
collect { it.name }.
unique().
sort { a, b -> a <=> b },
"graphStepMethods": GraphTraversal.getMethods().
- findAll { GraphTraversal.class.equals(it.returnType) }.
+ findAll { (GraphTraversal.class == it.returnType) }.
findAll { !it.name.equals("clone") && !it.name.equals("iterate") }.
collect { it.name }.
unique().
sort { a, b -> a <=> b },
"anonStepMethods": __.class.getMethods().
- findAll { GraphTraversal.class.equals(it.returnType) }.
+ findAll { (GraphTraversal.class == it.returnType) }.
findAll { Modifier.isStatic(it.getModifiers()) }.
- findAll { !it.name.equals("__") && !it.name.equals("start") }.
+ findAll { !it.name.equals("__") && it.name != "start" }.
collect { it.name }.
unique().
sort { a, b -> a <=> b },
diff --git a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js
index 1e19609..9421730 100644
--- a/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js
+++ b/gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js
@@ -793,6 +793,16 @@ class GraphTraversal extends Traversal {
}
/**
+ * Graph traversal none method.
+ * @param {...Object} args
+ * @returns {GraphTraversal}
+ */
+ none(...args) {
+ this.bytecode.addStep('none', args);
+ return this;
+ }
+
+ /**
* Graph traversal not method.
* @param {...Object} args
* @returns {GraphTraversal}
diff --git a/gremlin-python/glv/generate.groovy b/gremlin-python/glv/generate.groovy
index 214eb2f..5856e81 100644
--- a/gremlin-python/glv/generate.groovy
+++ b/gremlin-python/glv/generate.groovy
@@ -87,7 +87,7 @@ def binding = ["enums": CoreImports.getClassImports()
unique().
sort { a, b -> a <=> b },
"sourceStepMethods": GraphTraversalSource.getMethods(). // SOURCE STEPS
- findAll { GraphTraversalSource.class.equals(it.returnType) }.
+ findAll { (GraphTraversalSource.class == it.returnType) }.
findAll {
!it.name.equals("clone") &&
!it.name.equals(TraversalSource.Symbols.with) &&
@@ -98,20 +98,20 @@ def binding = ["enums": CoreImports.getClassImports()
unique().
sort { a, b -> a <=> b },
"sourceSpawnMethods": GraphTraversalSource.getMethods(). // SPAWN STEPS
- findAll { GraphTraversal.class.equals(it.returnType) }.
+ findAll { (GraphTraversal.class == it.returnType) }.
collect { toPython(it.name) }.
unique().
sort { a, b -> a <=> b },
"graphStepMethods": GraphTraversal.getMethods().
- findAll { GraphTraversal.class.equals(it.returnType) }.
- findAll { !it.name.equals("clone") && !it.name.equals("iterate") }.
+ findAll { GraphTraversal.class == it.returnType }.
+ findAll { it.name != "clone" && it.name != "iterate" }.
collect { toPython(it.name) }.
unique().
sort { a, b -> a <=> b },
"anonStepMethods": __.class.getMethods().
- findAll { GraphTraversal.class.equals(it.returnType) }.
+ findAll { (GraphTraversal.class == it.returnType) }.
findAll { Modifier.isStatic(it.getModifiers()) }.
- findAll { !it.name.equals("__") && !it.name.equals("start") }.
+ findAll { it.name != "__" && it.name != "start" }.
collect { toPython(it.name) }.
unique().
sort { a, b -> a <=> b },
diff --git a/gremlin-python/src/main/jython/gremlin_python/process/graph_traversal.py b/gremlin-python/src/main/jython/gremlin_python/process/graph_traversal.py
index 545dce0..edf4ddf 100644
--- a/gremlin-python/src/main/jython/gremlin_python/process/graph_traversal.py
+++ b/gremlin-python/src/main/jython/gremlin_python/process/graph_traversal.py
@@ -377,6 +377,10 @@ class GraphTraversal(Traversal):
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
[tinkerpop] 02/02: Merge branch '3.4-dev'
Posted by sp...@apache.org.
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 <st...@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)