You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by ok...@apache.org on 2016/06/03 17:57:53 UTC
[2/2] incubator-tinkerpop git commit: Fixed up the Gremlin Language
Variants tutorial to make explicit that the generated variants are for
tutorial purposes and that a full fleded Gremlin-Python variant is available.
Fixed up the Gremlin Language Variants tutorial to make explicit that the generated variants are for tutorial purposes and that a full fleded Gremlin-Python variant is available.
Project: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/commit/a938e508
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/tree/a938e508
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/diff/a938e508
Branch: refs/heads/TINKERPOP-1278
Commit: a938e508483843917f61ff78431974bf9eea0dd9
Parents: 99632a3
Author: Marko A. Rodriguez <ok...@gmail.com>
Authored: Fri Jun 3 11:57:43 2016 -0600
Committer: Marko A. Rodriguez <ok...@gmail.com>
Committed: Fri Jun 3 11:57:43 2016 -0600
----------------------------------------------------------------------
.../gremlin-language-variants/index.asciidoc | 61 +-
docs/static/resources/gremlin-jython-demo.py | 721 +++++++++++++++++
docs/static/resources/gremlin-jython.py | 721 -----------------
docs/static/resources/gremlin-python-demo.py | 764 +++++++++++++++++++
docs/static/resources/gremlin-python.py | 764 -------------------
5 files changed, 1516 insertions(+), 1515 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a938e508/docs/src/tutorials/gremlin-language-variants/index.asciidoc
----------------------------------------------------------------------
diff --git a/docs/src/tutorials/gremlin-language-variants/index.asciidoc b/docs/src/tutorials/gremlin-language-variants/index.asciidoc
index 6101fae..11be3cb 100644
--- a/docs/src/tutorials/gremlin-language-variants/index.asciidoc
+++ b/docs/src/tutorials/gremlin-language-variants/index.asciidoc
@@ -120,6 +120,10 @@ Any Gremlin language variant, regardless of the implementation model chosen, **m
host language, be in 1-to-1 correspondence with Gremlin-Java. This ensures that language variants are collectively
consistent and easily leveraged by anyone versed in Gremlin.
+IMPORTANT: The "Gremlin-Python" presented in this tutorial is basic and provided to show the primary techniques used to
+construct a Gremlin language variant. Apache TinkerPop distributes with a full fledged Gremlin-Python variant
+that uses many of the techniques presented in this tutorial.
+
[[language-drivers-vs-language-variants]]
Language Drivers vs. Language Variants
--------------------------------------
@@ -328,7 +332,7 @@ corresponding Jython classes. Unfortunately, adding the near 200 `GraphTraversal
both tedious and error-prone. To alleviate this pain, Python classes can be dynamically created using Groovy and
link:https://en.wikipedia.org/wiki/Reflection_(computer_programming)#Java[Java reflection].
The Groovy code for constructing the `JythonGraphTraversal` class source is reviewed below. By simply executing this code
-in the link:http://tinkerpop.apache.org/docs/x.y.z/reference/#gremlin-console[Gremlin Console], the `gremlin-jython.py` file
+in the link:http://tinkerpop.apache.org/docs/x.y.z/reference/#gremlin-console[Gremlin Console], the `gremlin-jython-demo.py` file
is generated and can be `execfile()`'d by Jython.
NOTE: Any JVM language can use Java reflection to generate source code. The examples in this tutorial use Groovy because of
@@ -429,7 +433,7 @@ methods.each{ method ->
pythonClass.append("\n\n")
// save to a python file
-file = new File("/tmp/gremlin-jython.py") //// <6>
+file = new File("/tmp/gremlin-jython-demo.py") //// <6>
file.delete()
pythonClass.eachLine{ file.append(it + "\n") }
----
@@ -439,24 +443,26 @@ pythonClass.eachLine{ file.append(it + "\n") }
<3> Use Java reflection to get all the methods of `GraphTraversal`.
<4> If the method is a fluent traversal-method, then mutate the underlying/wrapped `GraphTraversal` instance accordingly.
<5> If the method is not a fluent traversal-method, return the result of applying the method.
-<6> Save the string representation of the Jython source code to `gremlin-jython.py`.
+<6> Save the string representation of the Jython source code to `gremlin-jython-demo.py`.
-From the Jython console, `gremlin-jython.py` is loaded and a complete Gremlin language variant is born: **Gremlin-Jython**.
-The generated file is available at link:../../resources/gremlin-jython.py[gremlin-jython.py].
+From the Jython console, `gremlin-jython-demo.py` is loaded and a complete Gremlin language variant is born: **Gremlin-Jython (demo)**.
+The generated file is available at link:../../resources/gremlin-jython-demo.py[gremlin-jython-demo.py]. This is called "demo"
+because it is a quick and dirty implementation to demonstrate the main concepts behind developing a JVM-based language variant
+and should not be considered the defacto, production-ready Gremlin-Jython implementation.
[source,python]
----
Jython 2.7.0 (default:9987c746f838, Apr 29 2015, 02:25:11)
[Java HotSpot(TM) 64-Bit Server VM (Oracle Corporation)] on java1.8.0_40
Type "help", "copyright", "credits" or "license" for more information.
->>> execfile("/tmp/gremlin-jython.py")
+>>> execfile("/tmp/gremlin-jython-demo.py")
>>> from org.apache.tinkerpop.gremlin.tinkergraph.structure import TinkerFactory
>>> graph = TinkerFactory.createModern()
>>> g = JythonGraphTraversalSource(graph.traversal())
-# using the Gremlin-Jython __getattr__ and __getitem__ extensions and anonymous traversals
+# using the Gremlin-Jython (demo) __getattr__ and __getitem__ extensions and anonymous traversals
>>> g.V().repeat(__.both("created")).times(2).name[1:3].path().toList()
[[v[1], v[3], v[4], josh], [v[1], v[3], v[6], peter]]
-# JythonGraphTraversalSource works as expected -- an example using Gremlin-Jython w/ OLAP
+# JythonGraphTraversalSource works as expected -- an example using Gremlin-Jython (demo) w/ OLAP
>>> g = g.withComputer()
>>> g
graphtraversalsource[tinkergraph[vertices:6 edges:6], graphcomputer]
@@ -465,10 +471,10 @@ graphtraversalsource[tinkergraph[vertices:6 edges:6], graphcomputer]
>>>
----
-Gremlin-Jython was simple to create. Unfortunately, this simplicity is not without some problems. These problems are itemized below.
+Gremlin-Jython (demo) was simple to create. Unfortunately, this simplicity is not without some problems. These problems are itemized below.
The interested reader can solve the aforementioned problems as a training exercise.
-* The Gremlin-Jython API is non-informative as all methods take a tuple reference (`*args`).
+* The Gremlin-Jython (demo) API is non-informative as all methods take a tuple reference (`*args`).
** The Gremlin-Java link:http://tinkerpop.apache.org/javadocs/x.y.z/full/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.html[JavaDoc] would be a sufficient guide to Gremlin-Jython (minus the extensions).
* Lambdas are not supported as `map(lambda x: x.get())` will throw an exception about not being able to coerce `lamba` into `java.util.function.Function`.
** Python type inspection with a creation of `Function` lambda wrapper would solve this problem.
@@ -647,19 +653,20 @@ methods.each{ method ->
pythonClass.append("\n\n")
// save to a python file
-file = new File("/tmp/gremlin-python.py") //// <3>
+file = new File("/tmp/gremlin-python-demo.py") //// <3>
file.delete()
pythonClass.eachLine{ file.append(it + "\n") }
----
<1> The `Helper` class contains static methods that are generally useful to the other classes. This could have been a separate file, but was included in the Groovy script so that the tutorial's code is consolidated.
<2> `toList()`'s method `def` is not generated programmatically, but instead is hardcoded and uses the gremlinclient driver to communicate with GremlinServer.
-<3> Save the string representation of the Python source code to `gremlin-python.py`.
+<3> Save the string representation of the Python source code to `gremlin-python-demo.py`.
-When the above Groovy script is evaluated in GremlinConsole, **Gremlin-Python** is born.
-The generated file is available at link:../../resources/gremlin-python.py[gremlin-python.py]. Now, from any Python
-virtual machine (not just Jython), Gremlin traversals can be expressed in native Python and a legal Gremlin-Groovy
-string is created behind the scenes.
+When the above Groovy script is evaluated in GremlinConsole, **Gremlin-Python (demo)** is born.
+The generated file is available at link:../../resources/gremlin-python-demo.py[gremlin-python-demo.py]. Again, Gremlin-Python (demo)
+should not be considered production ready. It is provided in this tutorial to explain the concepts behind Gremlin language
+variant development. Now, from any Python virtual machine (not just Jython), Gremlin traversals can be expressed in native Python
+and a legal Gremlin-Groovy string is created behind the scenes.
NOTE: The string that is generated for submission to a GremlinServer or `RemoteConnection` does not have to be a
Gremlin-Groovy string. However, it must be a string that has a respective `ScriptEngine` that is enabled on the remote
@@ -667,17 +674,11 @@ location. It is recommended that a Gremlin-Groovy string be constructed as Greml
Apache TinkerPop and is guaranteed to always be aligned with Gremlin-Java.
Be sure that GremlinServer is running and has a link:http://tinkerpop.apache.org/docs/x.y.z/reference/#graphson-reader-writer[GraphSON]
-endpoint. The following serializers were added to `conf/gremlin-server-modern.yaml`.
-
-[source,yaml]
-- { className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerGremlinV1d0, config: { useMapperFromGraph: graph }} # application/vnd.gremlin-v1.0+json
-- { className: org.apache.tinkerpop.gremlin.driver.ser.GraphSONMessageSerializerV1d0, config: { useMapperFromGraph: graph }} # application/json
-
-Then GremlinServer was started.
+endpoint.
[source,bash]
----
-$ bin/gremlin-server.sh conf/gremlin-server-modern.yaml
+$ bin/gremlin-server.sh conf/gremlin-server-rest-modern.yaml
[INFO] GremlinServer -
\,,,/
(o o)
@@ -710,7 +711,7 @@ $ bin/gremlin-server.sh conf/gremlin-server-modern.yaml
Python 2.7.2 (default, Oct 11 2012, 20:14:37)
[GCC 4.2.1 Compatible Apple Clang 4.0 (tags/Apple/clang-418.0.60)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
->>> execfile("/tmp/gremlin-python.py")
+>>> execfile("/tmp/gremlin-python-demo.py")
# PythonGraphTraversalSource requires a GremlinServer endpoint and a traversal alias
>>> g = PythonGraphTraversalSource("ws://localhost:8182/", "g")
>>> g
@@ -720,7 +721,7 @@ graphtraversalsource[ws://localhost:8182/, g]
g.V().repeat(__.both("created")).times(2).values("name").range(1, 3).path()
>>> g.V().hasLabel("person").repeat(__.both()).times(2).name[0:2].toList()
[u'marko', u'josh']
-# PythonGraphTraversalSource works as expected -- an example using Gremlin-Python w/ OLAP
+# PythonGraphTraversalSource works as expected -- an example using Gremlin-Python (demo) w/ OLAP
>>> g = g.withComputer()
>>> g
graphtraversalsource[ws://localhost:8182/, g.withComputer()]
@@ -738,7 +739,7 @@ graphtraversalsource[ws://localhost:8182/, g.withComputer()]
>>>
----
-Finally, for the sake of brevity, Gremlin-Python is simple and as such, incurs a few peculiarities that the interested
+Finally, for the sake of brevity, Gremlin-Python (demo) is simple and as such, incurs a few peculiarities that the interested
reader may want to remedy as an exercise.
* `P`, `T`, `Order`, etc. are handled via string analysis and are used as `has("age","P.gt(36)")`. It would be better to create `P`, `T`, etc. Python classes that yield the appropriate string representation.
@@ -754,16 +755,16 @@ conventions of the host language and ensuring consistency with Gremlin-Java. A c
this dual-language bridge are provided.
* If camelCase is not an accepted method naming convention in the host language, then the host language's convention should be used instead. For instance, in a Gremlin-Ruby implementation, `outE("created")` should be `out_e("created")`.
-* If Gremlin-Java step names conflict with the host language's reserved words, then a consistent amelioration should be used. For instance, in Python `as` is a reserved word, thus, Gremlin-Python uses `_as`.
+* If Gremlin-Java step names conflict with the host language's reserved words, then a consistent amelioration should be used. For instance, in Python `as` is a reserved word, thus, Gremlin-Python (demo) uses `_as`.
* If the host language does not use dot-notion for method chaining, then its method chaining convention should be used instead of going the route of operator overloading. For instance, a Gremlin-PHP implementation should do `$g->V()->out()`.
-* If a programming language does not support method overloading, then varargs and type introspection should be used. In Gremlin-Python, `*args` does just this and that is why there are not 200 methods off of `PythonGraphTraversal`.
+* If a programming language does not support method overloading, then varargs and type introspection should be used. In Gremlin-Python (demo), `*args` does just this and that is why there are not 200 methods off of `PythonGraphTraversal`.
As stated in <<language-drivers-vs-language-variants,"Language Drivers vs. Language Variants">>, drivers and variants should
be separate libraries. A proposed naming convention for each library type is `gremlin-<language>-driver` and
`gremlin-<language>`. Unfortunately, numerous drivers and languages already exist for Gremlin that don't use this convention.
However, moving forward, it might be good to be explicit in the naming so its obvious to users what is what.
-Finally, note that Gremlin-Jython and Gremlin-Python (as presented in this tutorial) were only manually tested. This
+Finally, note that the Gremlin-Jython and Gremlin-Python demos (as presented in this tutorial) were only manually tested. This
means that there are most likely errors in the translation and thus, some traversals may break. A future addition to this
tutorial will explain how to leverage TinkerPop's `ProcessStandardSuite` and `ProcessComputerSuite` to test not only
JVM-based language variants, but also non-JVM variants. In doing so, every Gremlin language variant's syntax and
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a938e508/docs/static/resources/gremlin-jython-demo.py
----------------------------------------------------------------------
diff --git a/docs/static/resources/gremlin-jython-demo.py b/docs/static/resources/gremlin-jython-demo.py
new file mode 100644
index 0000000..e52e234
--- /dev/null
+++ b/docs/static/resources/gremlin-jython-demo.py
@@ -0,0 +1,721 @@
+'''
+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.
+'''
+
+from org.apache.tinkerpop.gremlin.process.traversal import *
+from org.apache.tinkerpop.gremlin.structure import *
+from org.apache.tinkerpop.gremlin.process.traversal.dsl.graph import __ as anon
+
+class JythonGraphTraversalSource(object):
+ def __init__(self, traversalSource):
+ self.traversalSource = traversalSource
+ def __repr__(self):
+ return self.traversalSource.toString()
+ def toString(self, *args):
+ return self.traversalSource.toString(*args)
+ def clone(self, *args):
+ self.traversalSource = self.traversalSource.clone(*args)
+ return self
+ def V(self, *args):
+ return JythonGraphTraversal(self.traversalSource.V(*args))
+ def E(self, *args):
+ return JythonGraphTraversal(self.traversalSource.E(*args))
+ def build(self, *args):
+ return self.traversalSource.build(*args)
+ def withSack(self, *args):
+ self.traversalSource = self.traversalSource.withSack(*args)
+ return self
+ def computer(self, *args):
+ return self.traversalSource.computer(*args)
+ def withComputer(self, *args):
+ self.traversalSource = self.traversalSource.withComputer(*args)
+ return self
+ def withStrategies(self, *args):
+ self.traversalSource = self.traversalSource.withStrategies(*args)
+ return self
+ def withoutStrategies(self, *args):
+ self.traversalSource = self.traversalSource.withoutStrategies(*args)
+ return self
+ def withSideEffect(self, *args):
+ self.traversalSource = self.traversalSource.withSideEffect(*args)
+ return self
+ def withBulk(self, *args):
+ self.traversalSource = self.traversalSource.withBulk(*args)
+ return self
+ def withPath(self, *args):
+ self.traversalSource = self.traversalSource.withPath(*args)
+ return self
+ def standard(self, *args):
+ return self.traversalSource.standard(*args)
+ def inject(self, *args):
+ return JythonGraphTraversal(self.traversalSource.inject(*args))
+ def getStrategies(self, *args):
+ return self.traversalSource.getStrategies(*args)
+ def addV(self, *args):
+ return JythonGraphTraversal(self.traversalSource.addV(*args))
+ def getGraph(self, *args):
+ return self.traversalSource.getGraph(*args)
+ def tx(self, *args):
+ return self.traversalSource.tx(*args)
+ def wait(self, *args):
+ return self.traversalSource.wait(*args)
+ def equals(self, *args):
+ return self.traversalSource.equals(*args)
+ def hashCode(self, *args):
+ return self.traversalSource.hashCode(*args)
+ def getClass(self, *args):
+ return self.traversalSource.getClass(*args)
+ def notify(self, *args):
+ return self.traversalSource.notify(*args)
+ def notifyAll(self, *args):
+ return self.traversalSource.notifyAll(*args)
+
+
+class JythonGraphTraversal(object):
+ def __init__(self, traversal):
+ self.traversal = traversal
+ def __repr__(self):
+ return self.traversal.toString()
+ def __getitem__(self,index):
+ if type(index) is int:
+ self.traversal = self.traversal.range(index,index+1)
+ elif type(index) is slice:
+ self.traversal = self.traversal.range(index.start,index.stop)
+ else:
+ raise TypeError("index must be int or slice")
+ return self
+ def __getattr__(self,key):
+ return self.values(key)
+ def group(self, *args):
+ self.traversal = self.traversal.group(*args)
+ return self
+ def limit(self, *args):
+ self.traversal = self.traversal.limit(*args)
+ return self
+ def value(self, *args):
+ self.traversal = self.traversal.value(*args)
+ return self
+ def count(self, *args):
+ self.traversal = self.traversal.count(*args)
+ return self
+ def profile(self, *args):
+ self.traversal = self.traversal.profile(*args)
+ return self
+ def values(self, *args):
+ self.traversal = self.traversal.values(*args)
+ return self
+ def min(self, *args):
+ self.traversal = self.traversal.min(*args)
+ return self
+ def max(self, *args):
+ self.traversal = self.traversal.max(*args)
+ return self
+ def V(self, *args):
+ self.traversal = self.traversal.V(*args)
+ return self
+ def identity(self, *args):
+ self.traversal = self.traversal.identity(*args)
+ return self
+ def _in(self, *args):
+ return self.traversal.in(*args)
+ def out(self, *args):
+ self.traversal = self.traversal.out(*args)
+ return self
+ def key(self, *args):
+ self.traversal = self.traversal.key(*args)
+ return self
+ def store(self, *args):
+ self.traversal = self.traversal.store(*args)
+ return self
+ def path(self, *args):
+ self.traversal = self.traversal.path(*args)
+ return self
+ def sum(self, *args):
+ self.traversal = self.traversal.sum(*args)
+ return self
+ def toV(self, *args):
+ self.traversal = self.traversal.toV(*args)
+ return self
+ def filter(self, *args):
+ self.traversal = self.traversal.filter(*args)
+ return self
+ def tree(self, *args):
+ self.traversal = self.traversal.tree(*args)
+ return self
+ def match(self, *args):
+ self.traversal = self.traversal.match(*args)
+ return self
+ def range(self, *args):
+ self.traversal = self.traversal.range(*args)
+ return self
+ def order(self, *args):
+ self.traversal = self.traversal.order(*args)
+ return self
+ def map(self, *args):
+ self.traversal = self.traversal.map(*args)
+ return self
+ def tail(self, *args):
+ self.traversal = self.traversal.tail(*args)
+ return self
+ def _and(self, *args):
+ return self.traversal.and(*args)
+ def _or(self, *args):
+ return self.traversal.or(*args)
+ def id(self, *args):
+ self.traversal = self.traversal.id(*args)
+ return self
+ def option(self, *args):
+ self.traversal = self.traversal.option(*args)
+ return self
+ def _not(self, *args):
+ return self.traversal.not(*args)
+ def property(self, *args):
+ self.traversal = self.traversal.property(*args)
+ return self
+ def program(self, *args):
+ self.traversal = self.traversal.program(*args)
+ return self
+ def label(self, *args):
+ self.traversal = self.traversal.label(*args)
+ return self
+ def choose(self, *args):
+ self.traversal = self.traversal.choose(*args)
+ return self
+ def propertyMap(self, *args):
+ self.traversal = self.traversal.propertyMap(*args)
+ return self
+ def inject(self, *args):
+ self.traversal = self.traversal.inject(*args)
+ return self
+ def drop(self, *args):
+ self.traversal = self.traversal.drop(*args)
+ return self
+ def times(self, *args):
+ self.traversal = self.traversal.times(*args)
+ return self
+ def select(self, *args):
+ self.traversal = self.traversal.select(*args)
+ return self
+ def _as(self, *args):
+ return self.traversal.as(*args)
+ def outE(self, *args):
+ self.traversal = self.traversal.outE(*args)
+ return self
+ def inE(self, *args):
+ self.traversal = self.traversal.inE(*args)
+ return self
+ def toE(self, *args):
+ self.traversal = self.traversal.toE(*args)
+ return self
+ def bothE(self, *args):
+ self.traversal = self.traversal.bothE(*args)
+ return self
+ def inV(self, *args):
+ self.traversal = self.traversal.inV(*args)
+ return self
+ def outV(self, *args):
+ self.traversal = self.traversal.outV(*args)
+ return self
+ def both(self, *args):
+ self.traversal = self.traversal.both(*args)
+ return self
+ def bothV(self, *args):
+ self.traversal = self.traversal.bothV(*args)
+ return self
+ def otherV(self, *args):
+ self.traversal = self.traversal.otherV(*args)
+ return self
+ def valueMap(self, *args):
+ self.traversal = self.traversal.valueMap(*args)
+ return self
+ def mapValues(self, *args):
+ self.traversal = self.traversal.mapValues(*args)
+ return self
+ def mapKeys(self, *args):
+ self.traversal = self.traversal.mapKeys(*args)
+ return self
+ def sack(self, *args):
+ self.traversal = self.traversal.sack(*args)
+ return self
+ def loops(self, *args):
+ self.traversal = self.traversal.loops(*args)
+ return self
+ def project(self, *args):
+ self.traversal = self.traversal.project(*args)
+ return self
+ def unfold(self, *args):
+ self.traversal = self.traversal.unfold(*args)
+ return self
+ def fold(self, *args):
+ self.traversal = self.traversal.fold(*args)
+ return self
+ def mean(self, *args):
+ self.traversal = self.traversal.mean(*args)
+ return self
+ def groupV3d0(self, *args):
+ self.traversal = self.traversal.groupV3d0(*args)
+ return self
+ def addV(self, *args):
+ self.traversal = self.traversal.addV(*args)
+ return self
+ def addE(self, *args):
+ self.traversal = self.traversal.addE(*args)
+ return self
+ def addOutE(self, *args):
+ self.traversal = self.traversal.addOutE(*args)
+ return self
+ def addInE(self, *args):
+ self.traversal = self.traversal.addInE(*args)
+ return self
+ def dedup(self, *args):
+ self.traversal = self.traversal.dedup(*args)
+ return self
+ def where(self, *args):
+ self.traversal = self.traversal.where(*args)
+ return self
+ def hasNot(self, *args):
+ self.traversal = self.traversal.hasNot(*args)
+ return self
+ def hasLabel(self, *args):
+ self.traversal = self.traversal.hasLabel(*args)
+ return self
+ def hasId(self, *args):
+ self.traversal = self.traversal.hasId(*args)
+ return self
+ def hasKey(self, *args):
+ self.traversal = self.traversal.hasKey(*args)
+ return self
+ def hasValue(self, *args):
+ self.traversal = self.traversal.hasValue(*args)
+ return self
+ def coin(self, *args):
+ self.traversal = self.traversal.coin(*args)
+ return self
+ def timeLimit(self, *args):
+ self.traversal = self.traversal.timeLimit(*args)
+ return self
+ def simplePath(self, *args):
+ self.traversal = self.traversal.simplePath(*args)
+ return self
+ def cyclicPath(self, *args):
+ self.traversal = self.traversal.cyclicPath(*args)
+ return self
+ def sample(self, *args):
+ self.traversal = self.traversal.sample(*args)
+ return self
+ def sideEffect(self, *args):
+ self.traversal = self.traversal.sideEffect(*args)
+ return self
+ def subgraph(self, *args):
+ self.traversal = self.traversal.subgraph(*args)
+ return self
+ def aggregate(self, *args):
+ self.traversal = self.traversal.aggregate(*args)
+ return self
+ def branch(self, *args):
+ self.traversal = self.traversal.branch(*args)
+ return self
+ def optional(self, *args):
+ self.traversal = self.traversal.optional(*args)
+ return self
+ def coalesce(self, *args):
+ self.traversal = self.traversal.coalesce(*args)
+ return self
+ def repeat(self, *args):
+ self.traversal = self.traversal.repeat(*args)
+ return self
+ def emit(self, *args):
+ self.traversal = self.traversal.emit(*args)
+ return self
+ def local(self, *args):
+ self.traversal = self.traversal.local(*args)
+ return self
+ def pageRank(self, *args):
+ self.traversal = self.traversal.pageRank(*args)
+ return self
+ def peerPressure(self, *args):
+ self.traversal = self.traversal.peerPressure(*args)
+ return self
+ def barrier(self, *args):
+ self.traversal = self.traversal.barrier(*args)
+ return self
+ def by(self, *args):
+ self.traversal = self.traversal.by(*args)
+ return self
+ def _is(self, *args):
+ return self.traversal.is(*args)
+ def until(self, *args):
+ self.traversal = self.traversal.until(*args)
+ return self
+ def constant(self, *args):
+ self.traversal = self.traversal.constant(*args)
+ return self
+ def properties(self, *args):
+ self.traversal = self.traversal.properties(*args)
+ return self
+ def to(self, *args):
+ self.traversal = self.traversal.to(*args)
+ return self
+ def _from(self, *args):
+ return self.traversal.from(*args)
+ def has(self, *args):
+ self.traversal = self.traversal.has(*args)
+ return self
+ def union(self, *args):
+ self.traversal = self.traversal.union(*args)
+ return self
+ def groupCount(self, *args):
+ self.traversal = self.traversal.groupCount(*args)
+ return self
+ def flatMap(self, *args):
+ self.traversal = self.traversal.flatMap(*args)
+ return self
+ def iterate(self, *args):
+ self.traversal = self.traversal.iterate(*args)
+ return self
+ def cap(self, *args):
+ self.traversal = self.traversal.cap(*args)
+ return self
+ def asAdmin(self, *args):
+ self.traversal = self.traversal.asAdmin(*args)
+ return self
+ def next(self, *args):
+ return self.traversal.next(*args)
+ def fill(self, *args):
+ return self.traversal.fill(*args)
+ def forEachRemaining(self, *args):
+ return self.traversal.forEachRemaining(*args)
+ def toList(self, *args):
+ return self.traversal.toList(*args)
+ def toSet(self, *args):
+ return self.traversal.toSet(*args)
+ def toBulkSet(self, *args):
+ return self.traversal.toBulkSet(*args)
+ def tryNext(self, *args):
+ return self.traversal.tryNext(*args)
+ def toStream(self, *args):
+ return self.traversal.toStream(*args)
+ def explain(self, *args):
+ return self.traversal.explain(*args)
+ def remove(self, *args):
+ return self.traversal.remove(*args)
+ def hasNext(self, *args):
+ return self.traversal.hasNext(*args)
+
+
+class __(object):
+ @staticmethod
+ def group(*args):
+ return anon.group(*args)
+ @staticmethod
+ def limit(*args):
+ return anon.limit(*args)
+ @staticmethod
+ def value(*args):
+ return anon.value(*args)
+ @staticmethod
+ def count(*args):
+ return anon.count(*args)
+ @staticmethod
+ def values(*args):
+ return anon.values(*args)
+ @staticmethod
+ def min(*args):
+ return anon.min(*args)
+ @staticmethod
+ def max(*args):
+ return anon.max(*args)
+ @staticmethod
+ def V(*args):
+ return anon.V(*args)
+ @staticmethod
+ def identity(*args):
+ return anon.identity(*args)
+ @staticmethod
+ def _in(*args):
+ return anon.in(*args)
+ @staticmethod
+ def out(*args):
+ return anon.out(*args)
+ @staticmethod
+ def key(*args):
+ return anon.key(*args)
+ @staticmethod
+ def start(*args):
+ return anon.start(*args)
+ @staticmethod
+ def store(*args):
+ return anon.store(*args)
+ @staticmethod
+ def path(*args):
+ return anon.path(*args)
+ @staticmethod
+ def sum(*args):
+ return anon.sum(*args)
+ @staticmethod
+ def toV(*args):
+ return anon.toV(*args)
+ @staticmethod
+ def filter(*args):
+ return anon.filter(*args)
+ @staticmethod
+ def tree(*args):
+ return anon.tree(*args)
+ @staticmethod
+ def match(*args):
+ return anon.match(*args)
+ @staticmethod
+ def range(*args):
+ return anon.range(*args)
+ @staticmethod
+ def order(*args):
+ return anon.order(*args)
+ @staticmethod
+ def map(*args):
+ return anon.map(*args)
+ @staticmethod
+ def tail(*args):
+ return anon.tail(*args)
+ @staticmethod
+ def _and(*args):
+ return anon.and(*args)
+ @staticmethod
+ def _or(*args):
+ return anon.or(*args)
+ @staticmethod
+ def id(*args):
+ return anon.id(*args)
+ @staticmethod
+ def _not(*args):
+ return anon.not(*args)
+ @staticmethod
+ def property(*args):
+ return anon.property(*args)
+ @staticmethod
+ def label(*args):
+ return anon.label(*args)
+ @staticmethod
+ def choose(*args):
+ return anon.choose(*args)
+ @staticmethod
+ def propertyMap(*args):
+ return anon.propertyMap(*args)
+ @staticmethod
+ def inject(*args):
+ return anon.inject(*args)
+ @staticmethod
+ def drop(*args):
+ return anon.drop(*args)
+ @staticmethod
+ def times(*args):
+ return anon.times(*args)
+ @staticmethod
+ def select(*args):
+ return anon.select(*args)
+ @staticmethod
+ def _as(*args):
+ return anon.as(*args)
+ @staticmethod
+ def outE(*args):
+ return anon.outE(*args)
+ @staticmethod
+ def inE(*args):
+ return anon.inE(*args)
+ @staticmethod
+ def toE(*args):
+ return anon.toE(*args)
+ @staticmethod
+ def bothE(*args):
+ return anon.bothE(*args)
+ @staticmethod
+ def inV(*args):
+ return anon.inV(*args)
+ @staticmethod
+ def outV(*args):
+ return anon.outV(*args)
+ @staticmethod
+ def both(*args):
+ return anon.both(*args)
+ @staticmethod
+ def bothV(*args):
+ return anon.bothV(*args)
+ @staticmethod
+ def otherV(*args):
+ return anon.otherV(*args)
+ @staticmethod
+ def valueMap(*args):
+ return anon.valueMap(*args)
+ @staticmethod
+ def mapValues(*args):
+ return anon.mapValues(*args)
+ @staticmethod
+ def mapKeys(*args):
+ return anon.mapKeys(*args)
+ @staticmethod
+ def sack(*args):
+ return anon.sack(*args)
+ @staticmethod
+ def loops(*args):
+ return anon.loops(*args)
+ @staticmethod
+ def project(*args):
+ return anon.project(*args)
+ @staticmethod
+ def unfold(*args):
+ return anon.unfold(*args)
+ @staticmethod
+ def fold(*args):
+ return anon.fold(*args)
+ @staticmethod
+ def mean(*args):
+ return anon.mean(*args)
+ @staticmethod
+ def groupV3d0(*args):
+ return anon.groupV3d0(*args)
+ @staticmethod
+ def addV(*args):
+ return anon.addV(*args)
+ @staticmethod
+ def addE(*args):
+ return anon.addE(*args)
+ @staticmethod
+ def addOutE(*args):
+ return anon.addOutE(*args)
+ @staticmethod
+ def addInE(*args):
+ return anon.addInE(*args)
+ @staticmethod
+ def dedup(*args):
+ return anon.dedup(*args)
+ @staticmethod
+ def where(*args):
+ return anon.where(*args)
+ @staticmethod
+ def hasNot(*args):
+ return anon.hasNot(*args)
+ @staticmethod
+ def hasLabel(*args):
+ return anon.hasLabel(*args)
+ @staticmethod
+ def hasId(*args):
+ return anon.hasId(*args)
+ @staticmethod
+ def hasKey(*args):
+ return anon.hasKey(*args)
+ @staticmethod
+ def hasValue(*args):
+ return anon.hasValue(*args)
+ @staticmethod
+ def coin(*args):
+ return anon.coin(*args)
+ @staticmethod
+ def timeLimit(*args):
+ return anon.timeLimit(*args)
+ @staticmethod
+ def simplePath(*args):
+ return anon.simplePath(*args)
+ @staticmethod
+ def cyclicPath(*args):
+ return anon.cyclicPath(*args)
+ @staticmethod
+ def sample(*args):
+ return anon.sample(*args)
+ @staticmethod
+ def sideEffect(*args):
+ return anon.sideEffect(*args)
+ @staticmethod
+ def subgraph(*args):
+ return anon.subgraph(*args)
+ @staticmethod
+ def aggregate(*args):
+ return anon.aggregate(*args)
+ @staticmethod
+ def branch(*args):
+ return anon.branch(*args)
+ @staticmethod
+ def optional(*args):
+ return anon.optional(*args)
+ @staticmethod
+ def coalesce(*args):
+ return anon.coalesce(*args)
+ @staticmethod
+ def repeat(*args):
+ return anon.repeat(*args)
+ @staticmethod
+ def emit(*args):
+ return anon.emit(*args)
+ @staticmethod
+ def local(*args):
+ return anon.local(*args)
+ @staticmethod
+ def barrier(*args):
+ return anon.barrier(*args)
+ @staticmethod
+ def _is(*args):
+ return anon.is(*args)
+ @staticmethod
+ def until(*args):
+ return anon.until(*args)
+ @staticmethod
+ def __(*args):
+ return anon.__(*args)
+ @staticmethod
+ def constant(*args):
+ return anon.constant(*args)
+ @staticmethod
+ def properties(*args):
+ return anon.properties(*args)
+ @staticmethod
+ def to(*args):
+ return anon.to(*args)
+ @staticmethod
+ def has(*args):
+ return anon.has(*args)
+ @staticmethod
+ def union(*args):
+ return anon.union(*args)
+ @staticmethod
+ def groupCount(*args):
+ return anon.groupCount(*args)
+ @staticmethod
+ def flatMap(*args):
+ return anon.flatMap(*args)
+ @staticmethod
+ def cap(*args):
+ return anon.cap(*args)
+ @staticmethod
+ def wait(*args):
+ return anon.wait(*args)
+ @staticmethod
+ def equals(*args):
+ return anon.equals(*args)
+ @staticmethod
+ def toString(*args):
+ return anon.toString(*args)
+ @staticmethod
+ def hashCode(*args):
+ return anon.hashCode(*args)
+ @staticmethod
+ def getClass(*args):
+ return anon.getClass(*args)
+ @staticmethod
+ def notify(*args):
+ return anon.notify(*args)
+ @staticmethod
+ def notifyAll(*args):
+ return anon.notifyAll(*args)
+
+
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a938e508/docs/static/resources/gremlin-jython.py
----------------------------------------------------------------------
diff --git a/docs/static/resources/gremlin-jython.py b/docs/static/resources/gremlin-jython.py
deleted file mode 100644
index e52e234..0000000
--- a/docs/static/resources/gremlin-jython.py
+++ /dev/null
@@ -1,721 +0,0 @@
-'''
-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.
-'''
-
-from org.apache.tinkerpop.gremlin.process.traversal import *
-from org.apache.tinkerpop.gremlin.structure import *
-from org.apache.tinkerpop.gremlin.process.traversal.dsl.graph import __ as anon
-
-class JythonGraphTraversalSource(object):
- def __init__(self, traversalSource):
- self.traversalSource = traversalSource
- def __repr__(self):
- return self.traversalSource.toString()
- def toString(self, *args):
- return self.traversalSource.toString(*args)
- def clone(self, *args):
- self.traversalSource = self.traversalSource.clone(*args)
- return self
- def V(self, *args):
- return JythonGraphTraversal(self.traversalSource.V(*args))
- def E(self, *args):
- return JythonGraphTraversal(self.traversalSource.E(*args))
- def build(self, *args):
- return self.traversalSource.build(*args)
- def withSack(self, *args):
- self.traversalSource = self.traversalSource.withSack(*args)
- return self
- def computer(self, *args):
- return self.traversalSource.computer(*args)
- def withComputer(self, *args):
- self.traversalSource = self.traversalSource.withComputer(*args)
- return self
- def withStrategies(self, *args):
- self.traversalSource = self.traversalSource.withStrategies(*args)
- return self
- def withoutStrategies(self, *args):
- self.traversalSource = self.traversalSource.withoutStrategies(*args)
- return self
- def withSideEffect(self, *args):
- self.traversalSource = self.traversalSource.withSideEffect(*args)
- return self
- def withBulk(self, *args):
- self.traversalSource = self.traversalSource.withBulk(*args)
- return self
- def withPath(self, *args):
- self.traversalSource = self.traversalSource.withPath(*args)
- return self
- def standard(self, *args):
- return self.traversalSource.standard(*args)
- def inject(self, *args):
- return JythonGraphTraversal(self.traversalSource.inject(*args))
- def getStrategies(self, *args):
- return self.traversalSource.getStrategies(*args)
- def addV(self, *args):
- return JythonGraphTraversal(self.traversalSource.addV(*args))
- def getGraph(self, *args):
- return self.traversalSource.getGraph(*args)
- def tx(self, *args):
- return self.traversalSource.tx(*args)
- def wait(self, *args):
- return self.traversalSource.wait(*args)
- def equals(self, *args):
- return self.traversalSource.equals(*args)
- def hashCode(self, *args):
- return self.traversalSource.hashCode(*args)
- def getClass(self, *args):
- return self.traversalSource.getClass(*args)
- def notify(self, *args):
- return self.traversalSource.notify(*args)
- def notifyAll(self, *args):
- return self.traversalSource.notifyAll(*args)
-
-
-class JythonGraphTraversal(object):
- def __init__(self, traversal):
- self.traversal = traversal
- def __repr__(self):
- return self.traversal.toString()
- def __getitem__(self,index):
- if type(index) is int:
- self.traversal = self.traversal.range(index,index+1)
- elif type(index) is slice:
- self.traversal = self.traversal.range(index.start,index.stop)
- else:
- raise TypeError("index must be int or slice")
- return self
- def __getattr__(self,key):
- return self.values(key)
- def group(self, *args):
- self.traversal = self.traversal.group(*args)
- return self
- def limit(self, *args):
- self.traversal = self.traversal.limit(*args)
- return self
- def value(self, *args):
- self.traversal = self.traversal.value(*args)
- return self
- def count(self, *args):
- self.traversal = self.traversal.count(*args)
- return self
- def profile(self, *args):
- self.traversal = self.traversal.profile(*args)
- return self
- def values(self, *args):
- self.traversal = self.traversal.values(*args)
- return self
- def min(self, *args):
- self.traversal = self.traversal.min(*args)
- return self
- def max(self, *args):
- self.traversal = self.traversal.max(*args)
- return self
- def V(self, *args):
- self.traversal = self.traversal.V(*args)
- return self
- def identity(self, *args):
- self.traversal = self.traversal.identity(*args)
- return self
- def _in(self, *args):
- return self.traversal.in(*args)
- def out(self, *args):
- self.traversal = self.traversal.out(*args)
- return self
- def key(self, *args):
- self.traversal = self.traversal.key(*args)
- return self
- def store(self, *args):
- self.traversal = self.traversal.store(*args)
- return self
- def path(self, *args):
- self.traversal = self.traversal.path(*args)
- return self
- def sum(self, *args):
- self.traversal = self.traversal.sum(*args)
- return self
- def toV(self, *args):
- self.traversal = self.traversal.toV(*args)
- return self
- def filter(self, *args):
- self.traversal = self.traversal.filter(*args)
- return self
- def tree(self, *args):
- self.traversal = self.traversal.tree(*args)
- return self
- def match(self, *args):
- self.traversal = self.traversal.match(*args)
- return self
- def range(self, *args):
- self.traversal = self.traversal.range(*args)
- return self
- def order(self, *args):
- self.traversal = self.traversal.order(*args)
- return self
- def map(self, *args):
- self.traversal = self.traversal.map(*args)
- return self
- def tail(self, *args):
- self.traversal = self.traversal.tail(*args)
- return self
- def _and(self, *args):
- return self.traversal.and(*args)
- def _or(self, *args):
- return self.traversal.or(*args)
- def id(self, *args):
- self.traversal = self.traversal.id(*args)
- return self
- def option(self, *args):
- self.traversal = self.traversal.option(*args)
- return self
- def _not(self, *args):
- return self.traversal.not(*args)
- def property(self, *args):
- self.traversal = self.traversal.property(*args)
- return self
- def program(self, *args):
- self.traversal = self.traversal.program(*args)
- return self
- def label(self, *args):
- self.traversal = self.traversal.label(*args)
- return self
- def choose(self, *args):
- self.traversal = self.traversal.choose(*args)
- return self
- def propertyMap(self, *args):
- self.traversal = self.traversal.propertyMap(*args)
- return self
- def inject(self, *args):
- self.traversal = self.traversal.inject(*args)
- return self
- def drop(self, *args):
- self.traversal = self.traversal.drop(*args)
- return self
- def times(self, *args):
- self.traversal = self.traversal.times(*args)
- return self
- def select(self, *args):
- self.traversal = self.traversal.select(*args)
- return self
- def _as(self, *args):
- return self.traversal.as(*args)
- def outE(self, *args):
- self.traversal = self.traversal.outE(*args)
- return self
- def inE(self, *args):
- self.traversal = self.traversal.inE(*args)
- return self
- def toE(self, *args):
- self.traversal = self.traversal.toE(*args)
- return self
- def bothE(self, *args):
- self.traversal = self.traversal.bothE(*args)
- return self
- def inV(self, *args):
- self.traversal = self.traversal.inV(*args)
- return self
- def outV(self, *args):
- self.traversal = self.traversal.outV(*args)
- return self
- def both(self, *args):
- self.traversal = self.traversal.both(*args)
- return self
- def bothV(self, *args):
- self.traversal = self.traversal.bothV(*args)
- return self
- def otherV(self, *args):
- self.traversal = self.traversal.otherV(*args)
- return self
- def valueMap(self, *args):
- self.traversal = self.traversal.valueMap(*args)
- return self
- def mapValues(self, *args):
- self.traversal = self.traversal.mapValues(*args)
- return self
- def mapKeys(self, *args):
- self.traversal = self.traversal.mapKeys(*args)
- return self
- def sack(self, *args):
- self.traversal = self.traversal.sack(*args)
- return self
- def loops(self, *args):
- self.traversal = self.traversal.loops(*args)
- return self
- def project(self, *args):
- self.traversal = self.traversal.project(*args)
- return self
- def unfold(self, *args):
- self.traversal = self.traversal.unfold(*args)
- return self
- def fold(self, *args):
- self.traversal = self.traversal.fold(*args)
- return self
- def mean(self, *args):
- self.traversal = self.traversal.mean(*args)
- return self
- def groupV3d0(self, *args):
- self.traversal = self.traversal.groupV3d0(*args)
- return self
- def addV(self, *args):
- self.traversal = self.traversal.addV(*args)
- return self
- def addE(self, *args):
- self.traversal = self.traversal.addE(*args)
- return self
- def addOutE(self, *args):
- self.traversal = self.traversal.addOutE(*args)
- return self
- def addInE(self, *args):
- self.traversal = self.traversal.addInE(*args)
- return self
- def dedup(self, *args):
- self.traversal = self.traversal.dedup(*args)
- return self
- def where(self, *args):
- self.traversal = self.traversal.where(*args)
- return self
- def hasNot(self, *args):
- self.traversal = self.traversal.hasNot(*args)
- return self
- def hasLabel(self, *args):
- self.traversal = self.traversal.hasLabel(*args)
- return self
- def hasId(self, *args):
- self.traversal = self.traversal.hasId(*args)
- return self
- def hasKey(self, *args):
- self.traversal = self.traversal.hasKey(*args)
- return self
- def hasValue(self, *args):
- self.traversal = self.traversal.hasValue(*args)
- return self
- def coin(self, *args):
- self.traversal = self.traversal.coin(*args)
- return self
- def timeLimit(self, *args):
- self.traversal = self.traversal.timeLimit(*args)
- return self
- def simplePath(self, *args):
- self.traversal = self.traversal.simplePath(*args)
- return self
- def cyclicPath(self, *args):
- self.traversal = self.traversal.cyclicPath(*args)
- return self
- def sample(self, *args):
- self.traversal = self.traversal.sample(*args)
- return self
- def sideEffect(self, *args):
- self.traversal = self.traversal.sideEffect(*args)
- return self
- def subgraph(self, *args):
- self.traversal = self.traversal.subgraph(*args)
- return self
- def aggregate(self, *args):
- self.traversal = self.traversal.aggregate(*args)
- return self
- def branch(self, *args):
- self.traversal = self.traversal.branch(*args)
- return self
- def optional(self, *args):
- self.traversal = self.traversal.optional(*args)
- return self
- def coalesce(self, *args):
- self.traversal = self.traversal.coalesce(*args)
- return self
- def repeat(self, *args):
- self.traversal = self.traversal.repeat(*args)
- return self
- def emit(self, *args):
- self.traversal = self.traversal.emit(*args)
- return self
- def local(self, *args):
- self.traversal = self.traversal.local(*args)
- return self
- def pageRank(self, *args):
- self.traversal = self.traversal.pageRank(*args)
- return self
- def peerPressure(self, *args):
- self.traversal = self.traversal.peerPressure(*args)
- return self
- def barrier(self, *args):
- self.traversal = self.traversal.barrier(*args)
- return self
- def by(self, *args):
- self.traversal = self.traversal.by(*args)
- return self
- def _is(self, *args):
- return self.traversal.is(*args)
- def until(self, *args):
- self.traversal = self.traversal.until(*args)
- return self
- def constant(self, *args):
- self.traversal = self.traversal.constant(*args)
- return self
- def properties(self, *args):
- self.traversal = self.traversal.properties(*args)
- return self
- def to(self, *args):
- self.traversal = self.traversal.to(*args)
- return self
- def _from(self, *args):
- return self.traversal.from(*args)
- def has(self, *args):
- self.traversal = self.traversal.has(*args)
- return self
- def union(self, *args):
- self.traversal = self.traversal.union(*args)
- return self
- def groupCount(self, *args):
- self.traversal = self.traversal.groupCount(*args)
- return self
- def flatMap(self, *args):
- self.traversal = self.traversal.flatMap(*args)
- return self
- def iterate(self, *args):
- self.traversal = self.traversal.iterate(*args)
- return self
- def cap(self, *args):
- self.traversal = self.traversal.cap(*args)
- return self
- def asAdmin(self, *args):
- self.traversal = self.traversal.asAdmin(*args)
- return self
- def next(self, *args):
- return self.traversal.next(*args)
- def fill(self, *args):
- return self.traversal.fill(*args)
- def forEachRemaining(self, *args):
- return self.traversal.forEachRemaining(*args)
- def toList(self, *args):
- return self.traversal.toList(*args)
- def toSet(self, *args):
- return self.traversal.toSet(*args)
- def toBulkSet(self, *args):
- return self.traversal.toBulkSet(*args)
- def tryNext(self, *args):
- return self.traversal.tryNext(*args)
- def toStream(self, *args):
- return self.traversal.toStream(*args)
- def explain(self, *args):
- return self.traversal.explain(*args)
- def remove(self, *args):
- return self.traversal.remove(*args)
- def hasNext(self, *args):
- return self.traversal.hasNext(*args)
-
-
-class __(object):
- @staticmethod
- def group(*args):
- return anon.group(*args)
- @staticmethod
- def limit(*args):
- return anon.limit(*args)
- @staticmethod
- def value(*args):
- return anon.value(*args)
- @staticmethod
- def count(*args):
- return anon.count(*args)
- @staticmethod
- def values(*args):
- return anon.values(*args)
- @staticmethod
- def min(*args):
- return anon.min(*args)
- @staticmethod
- def max(*args):
- return anon.max(*args)
- @staticmethod
- def V(*args):
- return anon.V(*args)
- @staticmethod
- def identity(*args):
- return anon.identity(*args)
- @staticmethod
- def _in(*args):
- return anon.in(*args)
- @staticmethod
- def out(*args):
- return anon.out(*args)
- @staticmethod
- def key(*args):
- return anon.key(*args)
- @staticmethod
- def start(*args):
- return anon.start(*args)
- @staticmethod
- def store(*args):
- return anon.store(*args)
- @staticmethod
- def path(*args):
- return anon.path(*args)
- @staticmethod
- def sum(*args):
- return anon.sum(*args)
- @staticmethod
- def toV(*args):
- return anon.toV(*args)
- @staticmethod
- def filter(*args):
- return anon.filter(*args)
- @staticmethod
- def tree(*args):
- return anon.tree(*args)
- @staticmethod
- def match(*args):
- return anon.match(*args)
- @staticmethod
- def range(*args):
- return anon.range(*args)
- @staticmethod
- def order(*args):
- return anon.order(*args)
- @staticmethod
- def map(*args):
- return anon.map(*args)
- @staticmethod
- def tail(*args):
- return anon.tail(*args)
- @staticmethod
- def _and(*args):
- return anon.and(*args)
- @staticmethod
- def _or(*args):
- return anon.or(*args)
- @staticmethod
- def id(*args):
- return anon.id(*args)
- @staticmethod
- def _not(*args):
- return anon.not(*args)
- @staticmethod
- def property(*args):
- return anon.property(*args)
- @staticmethod
- def label(*args):
- return anon.label(*args)
- @staticmethod
- def choose(*args):
- return anon.choose(*args)
- @staticmethod
- def propertyMap(*args):
- return anon.propertyMap(*args)
- @staticmethod
- def inject(*args):
- return anon.inject(*args)
- @staticmethod
- def drop(*args):
- return anon.drop(*args)
- @staticmethod
- def times(*args):
- return anon.times(*args)
- @staticmethod
- def select(*args):
- return anon.select(*args)
- @staticmethod
- def _as(*args):
- return anon.as(*args)
- @staticmethod
- def outE(*args):
- return anon.outE(*args)
- @staticmethod
- def inE(*args):
- return anon.inE(*args)
- @staticmethod
- def toE(*args):
- return anon.toE(*args)
- @staticmethod
- def bothE(*args):
- return anon.bothE(*args)
- @staticmethod
- def inV(*args):
- return anon.inV(*args)
- @staticmethod
- def outV(*args):
- return anon.outV(*args)
- @staticmethod
- def both(*args):
- return anon.both(*args)
- @staticmethod
- def bothV(*args):
- return anon.bothV(*args)
- @staticmethod
- def otherV(*args):
- return anon.otherV(*args)
- @staticmethod
- def valueMap(*args):
- return anon.valueMap(*args)
- @staticmethod
- def mapValues(*args):
- return anon.mapValues(*args)
- @staticmethod
- def mapKeys(*args):
- return anon.mapKeys(*args)
- @staticmethod
- def sack(*args):
- return anon.sack(*args)
- @staticmethod
- def loops(*args):
- return anon.loops(*args)
- @staticmethod
- def project(*args):
- return anon.project(*args)
- @staticmethod
- def unfold(*args):
- return anon.unfold(*args)
- @staticmethod
- def fold(*args):
- return anon.fold(*args)
- @staticmethod
- def mean(*args):
- return anon.mean(*args)
- @staticmethod
- def groupV3d0(*args):
- return anon.groupV3d0(*args)
- @staticmethod
- def addV(*args):
- return anon.addV(*args)
- @staticmethod
- def addE(*args):
- return anon.addE(*args)
- @staticmethod
- def addOutE(*args):
- return anon.addOutE(*args)
- @staticmethod
- def addInE(*args):
- return anon.addInE(*args)
- @staticmethod
- def dedup(*args):
- return anon.dedup(*args)
- @staticmethod
- def where(*args):
- return anon.where(*args)
- @staticmethod
- def hasNot(*args):
- return anon.hasNot(*args)
- @staticmethod
- def hasLabel(*args):
- return anon.hasLabel(*args)
- @staticmethod
- def hasId(*args):
- return anon.hasId(*args)
- @staticmethod
- def hasKey(*args):
- return anon.hasKey(*args)
- @staticmethod
- def hasValue(*args):
- return anon.hasValue(*args)
- @staticmethod
- def coin(*args):
- return anon.coin(*args)
- @staticmethod
- def timeLimit(*args):
- return anon.timeLimit(*args)
- @staticmethod
- def simplePath(*args):
- return anon.simplePath(*args)
- @staticmethod
- def cyclicPath(*args):
- return anon.cyclicPath(*args)
- @staticmethod
- def sample(*args):
- return anon.sample(*args)
- @staticmethod
- def sideEffect(*args):
- return anon.sideEffect(*args)
- @staticmethod
- def subgraph(*args):
- return anon.subgraph(*args)
- @staticmethod
- def aggregate(*args):
- return anon.aggregate(*args)
- @staticmethod
- def branch(*args):
- return anon.branch(*args)
- @staticmethod
- def optional(*args):
- return anon.optional(*args)
- @staticmethod
- def coalesce(*args):
- return anon.coalesce(*args)
- @staticmethod
- def repeat(*args):
- return anon.repeat(*args)
- @staticmethod
- def emit(*args):
- return anon.emit(*args)
- @staticmethod
- def local(*args):
- return anon.local(*args)
- @staticmethod
- def barrier(*args):
- return anon.barrier(*args)
- @staticmethod
- def _is(*args):
- return anon.is(*args)
- @staticmethod
- def until(*args):
- return anon.until(*args)
- @staticmethod
- def __(*args):
- return anon.__(*args)
- @staticmethod
- def constant(*args):
- return anon.constant(*args)
- @staticmethod
- def properties(*args):
- return anon.properties(*args)
- @staticmethod
- def to(*args):
- return anon.to(*args)
- @staticmethod
- def has(*args):
- return anon.has(*args)
- @staticmethod
- def union(*args):
- return anon.union(*args)
- @staticmethod
- def groupCount(*args):
- return anon.groupCount(*args)
- @staticmethod
- def flatMap(*args):
- return anon.flatMap(*args)
- @staticmethod
- def cap(*args):
- return anon.cap(*args)
- @staticmethod
- def wait(*args):
- return anon.wait(*args)
- @staticmethod
- def equals(*args):
- return anon.equals(*args)
- @staticmethod
- def toString(*args):
- return anon.toString(*args)
- @staticmethod
- def hashCode(*args):
- return anon.hashCode(*args)
- @staticmethod
- def getClass(*args):
- return anon.getClass(*args)
- @staticmethod
- def notify(*args):
- return anon.notify(*args)
- @staticmethod
- def notifyAll(*args):
- return anon.notifyAll(*args)
-
-
http://git-wip-us.apache.org/repos/asf/incubator-tinkerpop/blob/a938e508/docs/static/resources/gremlin-python-demo.py
----------------------------------------------------------------------
diff --git a/docs/static/resources/gremlin-python-demo.py b/docs/static/resources/gremlin-python-demo.py
new file mode 100644
index 0000000..6301bc9
--- /dev/null
+++ b/docs/static/resources/gremlin-python-demo.py
@@ -0,0 +1,764 @@
+'''
+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.
+'''
+
+from tornado import gen
+from tornado.ioloop import IOLoop
+from gremlinclient.tornado_client import submit
+
+class Helper(object):
+ @staticmethod
+ def stringOrObject(arg):
+ if (type(arg) is str and
+ not(arg.startswith("P.")) and
+ not(arg.startswith("Order.")) and
+ not(arg.startswith("T.")) and
+ not(arg.startswith("Pop.")) and
+ not(arg.startswith("Column."))):
+ return "\"" + arg + "\""
+ elif type(arg) is bool:
+ return str(arg).lower()
+ else:
+ return str(arg)
+ @staticmethod
+ def stringify(*args):
+ if len(args) == 0:
+ return ""
+ elif len(args) == 1:
+ return Helper.stringOrObject(args[0])
+ else:
+ return ", ".join(Helper.stringOrObject(i) for i in args)
+ @staticmethod
+ @gen.coroutine
+ def submit(gremlinServerURI, traversalString):
+ response = yield submit(gremlinServerURI, traversalString)
+ while True:
+ result = yield response.read()
+ if result is None:
+ break
+ raise gen.Return(result.data)
+
+class PythonGraphTraversalSource(object):
+ def __init__(self, gremlinServerURI, traversalSourceString):
+ self.gremlinServerURI = gremlinServerURI
+ self.traversalSourceString = traversalSourceString
+ def __repr__(self):
+ return "graphtraversalsource[" + self.gremlinServerURI + ", " + self.traversalSourceString + "]"
+ def toString(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".toString(" + Helper.stringify(*args) + ")")
+ def clone(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".clone(" + Helper.stringify(*args) + ")")
+ def V(self, *args):
+ return PythonGraphTraversal(self.traversalSourceString + ".V(" + Helper.stringify(*args) + ")", self.gremlinServerURI)
+ def E(self, *args):
+ return PythonGraphTraversal(self.traversalSourceString + ".E(" + Helper.stringify(*args) + ")", self.gremlinServerURI)
+ def build(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".build(" + Helper.stringify(*args) + ")")
+ def getStrategies(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".getStrategies(" + Helper.stringify(*args) + ")")
+ def addV(self, *args):
+ return PythonGraphTraversal(self.traversalSourceString + ".addV(" + Helper.stringify(*args) + ")", self.gremlinServerURI)
+ def getGraph(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".getGraph(" + Helper.stringify(*args) + ")")
+ def inject(self, *args):
+ return PythonGraphTraversal(self.traversalSourceString + ".inject(" + Helper.stringify(*args) + ")", self.gremlinServerURI)
+ def computer(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".computer(" + Helper.stringify(*args) + ")")
+ def tx(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".tx(" + Helper.stringify(*args) + ")")
+ def withComputer(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".withComputer(" + Helper.stringify(*args) + ")")
+ def withStrategies(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".withStrategies(" + Helper.stringify(*args) + ")")
+ def withoutStrategies(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".withoutStrategies(" + Helper.stringify(*args) + ")")
+ def withSideEffect(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".withSideEffect(" + Helper.stringify(*args) + ")")
+ def withSack(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".withSack(" + Helper.stringify(*args) + ")")
+ def withBulk(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".withBulk(" + Helper.stringify(*args) + ")")
+ def withPath(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".withPath(" + Helper.stringify(*args) + ")")
+ def standard(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".standard(" + Helper.stringify(*args) + ")")
+ def wait(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".wait(" + Helper.stringify(*args) + ")")
+ def equals(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".equals(" + Helper.stringify(*args) + ")")
+ def hashCode(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".hashCode(" + Helper.stringify(*args) + ")")
+ def getClass(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".getClass(" + Helper.stringify(*args) + ")")
+ def notify(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".notify(" + Helper.stringify(*args) + ")")
+ def notifyAll(self, *args):
+ return PythonGraphTraversalSource(self.gremlinServerURI, self.traversalSourceString + ".notifyAll(" + Helper.stringify(*args) + ")")
+
+
+class PythonGraphTraversal(object):
+ def __init__(self, traversalString, gremlinServerURI=None):
+ self.traversalString = traversalString
+ self.gremlinServerURI = gremlinServerURI
+ self.result = None
+ def __repr__(self):
+ return self.traversalString;
+ def __getitem__(self,index):
+ if type(index) is int:
+ return self.range(index,index+1)
+ elif type(index) is slice:
+ return self.range(index.start,index.stop)
+ else:
+ raise TypeError("index must be int or slice")
+ def __getattr__(self,key):
+ return self.values(key)
+ def toList(self):
+ return IOLoop.current().run_sync(lambda: Helper.submit(self.gremlinServerURI, self.traversalString))
+ def group(self, *args):
+ self.traversalString = self.traversalString + ".group(" + Helper.stringify(*args) + ")"
+ return self
+ def limit(self, *args):
+ self.traversalString = self.traversalString + ".limit(" + Helper.stringify(*args) + ")"
+ return self
+ def value(self, *args):
+ self.traversalString = self.traversalString + ".value(" + Helper.stringify(*args) + ")"
+ return self
+ def count(self, *args):
+ self.traversalString = self.traversalString + ".count(" + Helper.stringify(*args) + ")"
+ return self
+ def profile(self, *args):
+ self.traversalString = self.traversalString + ".profile(" + Helper.stringify(*args) + ")"
+ return self
+ def values(self, *args):
+ self.traversalString = self.traversalString + ".values(" + Helper.stringify(*args) + ")"
+ return self
+ def min(self, *args):
+ self.traversalString = self.traversalString + ".min(" + Helper.stringify(*args) + ")"
+ return self
+ def max(self, *args):
+ self.traversalString = self.traversalString + ".max(" + Helper.stringify(*args) + ")"
+ return self
+ def V(self, *args):
+ self.traversalString = self.traversalString + ".V(" + Helper.stringify(*args) + ")"
+ return self
+ def identity(self, *args):
+ self.traversalString = self.traversalString + ".identity(" + Helper.stringify(*args) + ")"
+ return self
+ def _in(self, *args):
+ self.traversalString = self.traversalString + ".in(" + Helper.stringify(*args) + ")"
+ return self
+ def out(self, *args):
+ self.traversalString = self.traversalString + ".out(" + Helper.stringify(*args) + ")"
+ return self
+ def key(self, *args):
+ self.traversalString = self.traversalString + ".key(" + Helper.stringify(*args) + ")"
+ return self
+ def store(self, *args):
+ self.traversalString = self.traversalString + ".store(" + Helper.stringify(*args) + ")"
+ return self
+ def path(self, *args):
+ self.traversalString = self.traversalString + ".path(" + Helper.stringify(*args) + ")"
+ return self
+ def sum(self, *args):
+ self.traversalString = self.traversalString + ".sum(" + Helper.stringify(*args) + ")"
+ return self
+ def toV(self, *args):
+ self.traversalString = self.traversalString + ".toV(" + Helper.stringify(*args) + ")"
+ return self
+ def filter(self, *args):
+ self.traversalString = self.traversalString + ".filter(" + Helper.stringify(*args) + ")"
+ return self
+ def tree(self, *args):
+ self.traversalString = self.traversalString + ".tree(" + Helper.stringify(*args) + ")"
+ return self
+ def match(self, *args):
+ self.traversalString = self.traversalString + ".match(" + Helper.stringify(*args) + ")"
+ return self
+ def range(self, *args):
+ self.traversalString = self.traversalString + ".range(" + Helper.stringify(*args) + ")"
+ return self
+ def order(self, *args):
+ self.traversalString = self.traversalString + ".order(" + Helper.stringify(*args) + ")"
+ return self
+ def map(self, *args):
+ self.traversalString = self.traversalString + ".map(" + Helper.stringify(*args) + ")"
+ return self
+ def tail(self, *args):
+ self.traversalString = self.traversalString + ".tail(" + Helper.stringify(*args) + ")"
+ return self
+ def _and(self, *args):
+ self.traversalString = self.traversalString + ".and(" + Helper.stringify(*args) + ")"
+ return self
+ def _or(self, *args):
+ self.traversalString = self.traversalString + ".or(" + Helper.stringify(*args) + ")"
+ return self
+ def id(self, *args):
+ self.traversalString = self.traversalString + ".id(" + Helper.stringify(*args) + ")"
+ return self
+ def outE(self, *args):
+ self.traversalString = self.traversalString + ".outE(" + Helper.stringify(*args) + ")"
+ return self
+ def toE(self, *args):
+ self.traversalString = self.traversalString + ".toE(" + Helper.stringify(*args) + ")"
+ return self
+ def inE(self, *args):
+ self.traversalString = self.traversalString + ".inE(" + Helper.stringify(*args) + ")"
+ return self
+ def property(self, *args):
+ self.traversalString = self.traversalString + ".property(" + Helper.stringify(*args) + ")"
+ return self
+ def both(self, *args):
+ self.traversalString = self.traversalString + ".both(" + Helper.stringify(*args) + ")"
+ return self
+ def bothE(self, *args):
+ self.traversalString = self.traversalString + ".bothE(" + Helper.stringify(*args) + ")"
+ return self
+ def inV(self, *args):
+ self.traversalString = self.traversalString + ".inV(" + Helper.stringify(*args) + ")"
+ return self
+ def outV(self, *args):
+ self.traversalString = self.traversalString + ".outV(" + Helper.stringify(*args) + ")"
+ return self
+ def bothV(self, *args):
+ self.traversalString = self.traversalString + ".bothV(" + Helper.stringify(*args) + ")"
+ return self
+ def otherV(self, *args):
+ self.traversalString = self.traversalString + ".otherV(" + Helper.stringify(*args) + ")"
+ return self
+ def valueMap(self, *args):
+ self.traversalString = self.traversalString + ".valueMap(" + Helper.stringify(*args) + ")"
+ return self
+ def mapValues(self, *args):
+ self.traversalString = self.traversalString + ".mapValues(" + Helper.stringify(*args) + ")"
+ return self
+ def mapKeys(self, *args):
+ self.traversalString = self.traversalString + ".mapKeys(" + Helper.stringify(*args) + ")"
+ return self
+ def sack(self, *args):
+ self.traversalString = self.traversalString + ".sack(" + Helper.stringify(*args) + ")"
+ return self
+ def loops(self, *args):
+ self.traversalString = self.traversalString + ".loops(" + Helper.stringify(*args) + ")"
+ return self
+ def project(self, *args):
+ self.traversalString = self.traversalString + ".project(" + Helper.stringify(*args) + ")"
+ return self
+ def unfold(self, *args):
+ self.traversalString = self.traversalString + ".unfold(" + Helper.stringify(*args) + ")"
+ return self
+ def fold(self, *args):
+ self.traversalString = self.traversalString + ".fold(" + Helper.stringify(*args) + ")"
+ return self
+ def mean(self, *args):
+ self.traversalString = self.traversalString + ".mean(" + Helper.stringify(*args) + ")"
+ return self
+ def groupV3d0(self, *args):
+ self.traversalString = self.traversalString + ".groupV3d0(" + Helper.stringify(*args) + ")"
+ return self
+ def addV(self, *args):
+ self.traversalString = self.traversalString + ".addV(" + Helper.stringify(*args) + ")"
+ return self
+ def addE(self, *args):
+ self.traversalString = self.traversalString + ".addE(" + Helper.stringify(*args) + ")"
+ return self
+ def addOutE(self, *args):
+ self.traversalString = self.traversalString + ".addOutE(" + Helper.stringify(*args) + ")"
+ return self
+ def addInE(self, *args):
+ self.traversalString = self.traversalString + ".addInE(" + Helper.stringify(*args) + ")"
+ return self
+ def dedup(self, *args):
+ self.traversalString = self.traversalString + ".dedup(" + Helper.stringify(*args) + ")"
+ return self
+ def where(self, *args):
+ self.traversalString = self.traversalString + ".where(" + Helper.stringify(*args) + ")"
+ return self
+ def hasNot(self, *args):
+ self.traversalString = self.traversalString + ".hasNot(" + Helper.stringify(*args) + ")"
+ return self
+ def hasLabel(self, *args):
+ self.traversalString = self.traversalString + ".hasLabel(" + Helper.stringify(*args) + ")"
+ return self
+ def hasId(self, *args):
+ self.traversalString = self.traversalString + ".hasId(" + Helper.stringify(*args) + ")"
+ return self
+ def hasKey(self, *args):
+ self.traversalString = self.traversalString + ".hasKey(" + Helper.stringify(*args) + ")"
+ return self
+ def hasValue(self, *args):
+ self.traversalString = self.traversalString + ".hasValue(" + Helper.stringify(*args) + ")"
+ return self
+ def coin(self, *args):
+ self.traversalString = self.traversalString + ".coin(" + Helper.stringify(*args) + ")"
+ return self
+ def timeLimit(self, *args):
+ self.traversalString = self.traversalString + ".timeLimit(" + Helper.stringify(*args) + ")"
+ return self
+ def simplePath(self, *args):
+ self.traversalString = self.traversalString + ".simplePath(" + Helper.stringify(*args) + ")"
+ return self
+ def cyclicPath(self, *args):
+ self.traversalString = self.traversalString + ".cyclicPath(" + Helper.stringify(*args) + ")"
+ return self
+ def sample(self, *args):
+ self.traversalString = self.traversalString + ".sample(" + Helper.stringify(*args) + ")"
+ return self
+ def sideEffect(self, *args):
+ self.traversalString = self.traversalString + ".sideEffect(" + Helper.stringify(*args) + ")"
+ return self
+ def subgraph(self, *args):
+ self.traversalString = self.traversalString + ".subgraph(" + Helper.stringify(*args) + ")"
+ return self
+ def aggregate(self, *args):
+ self.traversalString = self.traversalString + ".aggregate(" + Helper.stringify(*args) + ")"
+ return self
+ def branch(self, *args):
+ self.traversalString = self.traversalString + ".branch(" + Helper.stringify(*args) + ")"
+ return self
+ def optional(self, *args):
+ self.traversalString = self.traversalString + ".optional(" + Helper.stringify(*args) + ")"
+ return self
+ def coalesce(self, *args):
+ self.traversalString = self.traversalString + ".coalesce(" + Helper.stringify(*args) + ")"
+ return self
+ def repeat(self, *args):
+ self.traversalString = self.traversalString + ".repeat(" + Helper.stringify(*args) + ")"
+ return self
+ def emit(self, *args):
+ self.traversalString = self.traversalString + ".emit(" + Helper.stringify(*args) + ")"
+ return self
+ def local(self, *args):
+ self.traversalString = self.traversalString + ".local(" + Helper.stringify(*args) + ")"
+ return self
+ def pageRank(self, *args):
+ self.traversalString = self.traversalString + ".pageRank(" + Helper.stringify(*args) + ")"
+ return self
+ def peerPressure(self, *args):
+ self.traversalString = self.traversalString + ".peerPressure(" + Helper.stringify(*args) + ")"
+ return self
+ def barrier(self, *args):
+ self.traversalString = self.traversalString + ".barrier(" + Helper.stringify(*args) + ")"
+ return self
+ def by(self, *args):
+ self.traversalString = self.traversalString + ".by(" + Helper.stringify(*args) + ")"
+ return self
+ def option(self, *args):
+ self.traversalString = self.traversalString + ".option(" + Helper.stringify(*args) + ")"
+ return self
+ def choose(self, *args):
+ self.traversalString = self.traversalString + ".choose(" + Helper.stringify(*args) + ")"
+ return self
+ def cap(self, *args):
+ self.traversalString = self.traversalString + ".cap(" + Helper.stringify(*args) + ")"
+ return self
+ def inject(self, *args):
+ self.traversalString = self.traversalString + ".inject(" + Helper.stringify(*args) + ")"
+ return self
+ def drop(self, *args):
+ self.traversalString = self.traversalString + ".drop(" + Helper.stringify(*args) + ")"
+ return self
+ def times(self, *args):
+ self.traversalString = self.traversalString + ".times(" + Helper.stringify(*args) + ")"
+ return self
+ def _as(self, *args):
+ self.traversalString = self.traversalString + ".as(" + Helper.stringify(*args) + ")"
+ return self
+ def label(self, *args):
+ self.traversalString = self.traversalString + ".label(" + Helper.stringify(*args) + ")"
+ return self
+ def propertyMap(self, *args):
+ self.traversalString = self.traversalString + ".propertyMap(" + Helper.stringify(*args) + ")"
+ return self
+ def constant(self, *args):
+ self.traversalString = self.traversalString + ".constant(" + Helper.stringify(*args) + ")"
+ return self
+ def until(self, *args):
+ self.traversalString = self.traversalString + ".until(" + Helper.stringify(*args) + ")"
+ return self
+ def has(self, *args):
+ self.traversalString = self.traversalString + ".has(" + Helper.stringify(*args) + ")"
+ return self
+ def union(self, *args):
+ self.traversalString = self.traversalString + ".union(" + Helper.stringify(*args) + ")"
+ return self
+ def groupCount(self, *args):
+ self.traversalString = self.traversalString + ".groupCount(" + Helper.stringify(*args) + ")"
+ return self
+ def flatMap(self, *args):
+ self.traversalString = self.traversalString + ".flatMap(" + Helper.stringify(*args) + ")"
+ return self
+ def iterate(self, *args):
+ self.traversalString = self.traversalString + ".iterate(" + Helper.stringify(*args) + ")"
+ return self
+ def properties(self, *args):
+ self.traversalString = self.traversalString + ".properties(" + Helper.stringify(*args) + ")"
+ return self
+ def to(self, *args):
+ self.traversalString = self.traversalString + ".to(" + Helper.stringify(*args) + ")"
+ return self
+ def _from(self, *args):
+ self.traversalString = self.traversalString + ".from(" + Helper.stringify(*args) + ")"
+ return self
+ def _not(self, *args):
+ self.traversalString = self.traversalString + ".not(" + Helper.stringify(*args) + ")"
+ return self
+ def _is(self, *args):
+ self.traversalString = self.traversalString + ".is(" + Helper.stringify(*args) + ")"
+ return self
+ def select(self, *args):
+ self.traversalString = self.traversalString + ".select(" + Helper.stringify(*args) + ")"
+ return self
+ def asAdmin(self, *args):
+ self.traversalString = self.traversalString + ".asAdmin(" + Helper.stringify(*args) + ")"
+ return self
+ def program(self, *args):
+ self.traversalString = self.traversalString + ".program(" + Helper.stringify(*args) + ")"
+ return self
+ def next(self, *args):
+ self.traversalString = self.traversalString + ".next(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def fill(self, *args):
+ self.traversalString = self.traversalString + ".fill(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def forEachRemaining(self, *args):
+ self.traversalString = self.traversalString + ".forEachRemaining(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def toSet(self, *args):
+ self.traversalString = self.traversalString + ".toSet(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def tryNext(self, *args):
+ self.traversalString = self.traversalString + ".tryNext(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def explain(self, *args):
+ self.traversalString = self.traversalString + ".explain(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def toStream(self, *args):
+ self.traversalString = self.traversalString + ".toStream(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def toBulkSet(self, *args):
+ self.traversalString = self.traversalString + ".toBulkSet(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def remove(self, *args):
+ self.traversalString = self.traversalString + ".remove(" + Helper.stringify(*args) + ")"
+ return self.toList()
+ def hasNext(self, *args):
+ self.traversalString = self.traversalString + ".hasNext(" + Helper.stringify(*args) + ")"
+ return self.toList()
+
+
+class __(object):
+ @staticmethod
+ def group(*args):
+ return PythonGraphTraversal("__").group(*args)
+ @staticmethod
+ def limit(*args):
+ return PythonGraphTraversal("__").limit(*args)
+ @staticmethod
+ def value(*args):
+ return PythonGraphTraversal("__").value(*args)
+ @staticmethod
+ def count(*args):
+ return PythonGraphTraversal("__").count(*args)
+ @staticmethod
+ def values(*args):
+ return PythonGraphTraversal("__").values(*args)
+ @staticmethod
+ def min(*args):
+ return PythonGraphTraversal("__").min(*args)
+ @staticmethod
+ def max(*args):
+ return PythonGraphTraversal("__").max(*args)
+ @staticmethod
+ def V(*args):
+ return PythonGraphTraversal("__").V(*args)
+ @staticmethod
+ def identity(*args):
+ return PythonGraphTraversal("__").identity(*args)
+ @staticmethod
+ def _in(*args):
+ return PythonGraphTraversal("__")._in(*args)
+ @staticmethod
+ def out(*args):
+ return PythonGraphTraversal("__").out(*args)
+ @staticmethod
+ def key(*args):
+ return PythonGraphTraversal("__").key(*args)
+ @staticmethod
+ def start(*args):
+ return PythonGraphTraversal("__").start(*args)
+ @staticmethod
+ def store(*args):
+ return PythonGraphTraversal("__").store(*args)
+ @staticmethod
+ def path(*args):
+ return PythonGraphTraversal("__").path(*args)
+ @staticmethod
+ def sum(*args):
+ return PythonGraphTraversal("__").sum(*args)
+ @staticmethod
+ def toV(*args):
+ return PythonGraphTraversal("__").toV(*args)
+ @staticmethod
+ def filter(*args):
+ return PythonGraphTraversal("__").filter(*args)
+ @staticmethod
+ def tree(*args):
+ return PythonGraphTraversal("__").tree(*args)
+ @staticmethod
+ def match(*args):
+ return PythonGraphTraversal("__").match(*args)
+ @staticmethod
+ def range(*args):
+ return PythonGraphTraversal("__").range(*args)
+ @staticmethod
+ def order(*args):
+ return PythonGraphTraversal("__").order(*args)
+ @staticmethod
+ def map(*args):
+ return PythonGraphTraversal("__").map(*args)
+ @staticmethod
+ def tail(*args):
+ return PythonGraphTraversal("__").tail(*args)
+ @staticmethod
+ def _and(*args):
+ return PythonGraphTraversal("__")._and(*args)
+ @staticmethod
+ def _or(*args):
+ return PythonGraphTraversal("__")._or(*args)
+ @staticmethod
+ def id(*args):
+ return PythonGraphTraversal("__").id(*args)
+ @staticmethod
+ def outE(*args):
+ return PythonGraphTraversal("__").outE(*args)
+ @staticmethod
+ def toE(*args):
+ return PythonGraphTraversal("__").toE(*args)
+ @staticmethod
+ def inE(*args):
+ return PythonGraphTraversal("__").inE(*args)
+ @staticmethod
+ def property(*args):
+ return PythonGraphTraversal("__").property(*args)
+ @staticmethod
+ def both(*args):
+ return PythonGraphTraversal("__").both(*args)
+ @staticmethod
+ def bothE(*args):
+ return PythonGraphTraversal("__").bothE(*args)
+ @staticmethod
+ def inV(*args):
+ return PythonGraphTraversal("__").inV(*args)
+ @staticmethod
+ def outV(*args):
+ return PythonGraphTraversal("__").outV(*args)
+ @staticmethod
+ def bothV(*args):
+ return PythonGraphTraversal("__").bothV(*args)
+ @staticmethod
+ def otherV(*args):
+ return PythonGraphTraversal("__").otherV(*args)
+ @staticmethod
+ def valueMap(*args):
+ return PythonGraphTraversal("__").valueMap(*args)
+ @staticmethod
+ def mapValues(*args):
+ return PythonGraphTraversal("__").mapValues(*args)
+ @staticmethod
+ def mapKeys(*args):
+ return PythonGraphTraversal("__").mapKeys(*args)
+ @staticmethod
+ def sack(*args):
+ return PythonGraphTraversal("__").sack(*args)
+ @staticmethod
+ def loops(*args):
+ return PythonGraphTraversal("__").loops(*args)
+ @staticmethod
+ def project(*args):
+ return PythonGraphTraversal("__").project(*args)
+ @staticmethod
+ def unfold(*args):
+ return PythonGraphTraversal("__").unfold(*args)
+ @staticmethod
+ def fold(*args):
+ return PythonGraphTraversal("__").fold(*args)
+ @staticmethod
+ def mean(*args):
+ return PythonGraphTraversal("__").mean(*args)
+ @staticmethod
+ def groupV3d0(*args):
+ return PythonGraphTraversal("__").groupV3d0(*args)
+ @staticmethod
+ def addV(*args):
+ return PythonGraphTraversal("__").addV(*args)
+ @staticmethod
+ def addE(*args):
+ return PythonGraphTraversal("__").addE(*args)
+ @staticmethod
+ def addOutE(*args):
+ return PythonGraphTraversal("__").addOutE(*args)
+ @staticmethod
+ def addInE(*args):
+ return PythonGraphTraversal("__").addInE(*args)
+ @staticmethod
+ def dedup(*args):
+ return PythonGraphTraversal("__").dedup(*args)
+ @staticmethod
+ def where(*args):
+ return PythonGraphTraversal("__").where(*args)
+ @staticmethod
+ def hasNot(*args):
+ return PythonGraphTraversal("__").hasNot(*args)
+ @staticmethod
+ def hasLabel(*args):
+ return PythonGraphTraversal("__").hasLabel(*args)
+ @staticmethod
+ def hasId(*args):
+ return PythonGraphTraversal("__").hasId(*args)
+ @staticmethod
+ def hasKey(*args):
+ return PythonGraphTraversal("__").hasKey(*args)
+ @staticmethod
+ def hasValue(*args):
+ return PythonGraphTraversal("__").hasValue(*args)
+ @staticmethod
+ def coin(*args):
+ return PythonGraphTraversal("__").coin(*args)
+ @staticmethod
+ def timeLimit(*args):
+ return PythonGraphTraversal("__").timeLimit(*args)
+ @staticmethod
+ def simplePath(*args):
+ return PythonGraphTraversal("__").simplePath(*args)
+ @staticmethod
+ def cyclicPath(*args):
+ return PythonGraphTraversal("__").cyclicPath(*args)
+ @staticmethod
+ def sample(*args):
+ return PythonGraphTraversal("__").sample(*args)
+ @staticmethod
+ def sideEffect(*args):
+ return PythonGraphTraversal("__").sideEffect(*args)
+ @staticmethod
+ def subgraph(*args):
+ return PythonGraphTraversal("__").subgraph(*args)
+ @staticmethod
+ def aggregate(*args):
+ return PythonGraphTraversal("__").aggregate(*args)
+ @staticmethod
+ def branch(*args):
+ return PythonGraphTraversal("__").branch(*args)
+ @staticmethod
+ def optional(*args):
+ return PythonGraphTraversal("__").optional(*args)
+ @staticmethod
+ def coalesce(*args):
+ return PythonGraphTraversal("__").coalesce(*args)
+ @staticmethod
+ def repeat(*args):
+ return PythonGraphTraversal("__").repeat(*args)
+ @staticmethod
+ def emit(*args):
+ return PythonGraphTraversal("__").emit(*args)
+ @staticmethod
+ def local(*args):
+ return PythonGraphTraversal("__").local(*args)
+ @staticmethod
+ def barrier(*args):
+ return PythonGraphTraversal("__").barrier(*args)
+ @staticmethod
+ def choose(*args):
+ return PythonGraphTraversal("__").choose(*args)
+ @staticmethod
+ def cap(*args):
+ return PythonGraphTraversal("__").cap(*args)
+ @staticmethod
+ def inject(*args):
+ return PythonGraphTraversal("__").inject(*args)
+ @staticmethod
+ def drop(*args):
+ return PythonGraphTraversal("__").drop(*args)
+ @staticmethod
+ def times(*args):
+ return PythonGraphTraversal("__").times(*args)
+ @staticmethod
+ def _as(*args):
+ return PythonGraphTraversal("__")._as(*args)
+ @staticmethod
+ def label(*args):
+ return PythonGraphTraversal("__").label(*args)
+ @staticmethod
+ def propertyMap(*args):
+ return PythonGraphTraversal("__").propertyMap(*args)
+ @staticmethod
+ def constant(*args):
+ return PythonGraphTraversal("__").constant(*args)
+ @staticmethod
+ def until(*args):
+ return PythonGraphTraversal("__").until(*args)
+ @staticmethod
+ def __(*args):
+ return PythonGraphTraversal("__").__(*args)
+ @staticmethod
+ def has(*args):
+ return PythonGraphTraversal("__").has(*args)
+ @staticmethod
+ def union(*args):
+ return PythonGraphTraversal("__").union(*args)
+ @staticmethod
+ def groupCount(*args):
+ return PythonGraphTraversal("__").groupCount(*args)
+ @staticmethod
+ def flatMap(*args):
+ return PythonGraphTraversal("__").flatMap(*args)
+ @staticmethod
+ def properties(*args):
+ return PythonGraphTraversal("__").properties(*args)
+ @staticmethod
+ def to(*args):
+ return PythonGraphTraversal("__").to(*args)
+ @staticmethod
+ def _not(*args):
+ return PythonGraphTraversal("__")._not(*args)
+ @staticmethod
+ def _is(*args):
+ return PythonGraphTraversal("__")._is(*args)
+ @staticmethod
+ def select(*args):
+ return PythonGraphTraversal("__").select(*args)
+ @staticmethod
+ def wait(*args):
+ return PythonGraphTraversal("__").wait(*args)
+ @staticmethod
+ def equals(*args):
+ return PythonGraphTraversal("__").equals(*args)
+ @staticmethod
+ def toString(*args):
+ return PythonGraphTraversal("__").toString(*args)
+ @staticmethod
+ def hashCode(*args):
+ return PythonGraphTraversal("__").hashCode(*args)
+ @staticmethod
+ def getClass(*args):
+ return PythonGraphTraversal("__").getClass(*args)
+ @staticmethod
+ def notify(*args):
+ return PythonGraphTraversal("__").notify(*args)
+ @staticmethod
+ def notifyAll(*args):
+ return PythonGraphTraversal("__").notifyAll(*args)
+
+