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/04/21 16:58:17 UTC
svn commit: r1740337 - in
/incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources: ./
gremlin-jython.py gremlin-python.py
Author: okram
Date: Thu Apr 21 14:58:17 2016
New Revision: 1740337
URL: http://svn.apache.org/viewvc?rev=1740337&view=rev
Log:
added source code resources.
Added:
incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/
incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-jython.py
incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-python.py
Added: incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-jython.py
URL: http://svn.apache.org/viewvc/incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-jython.py?rev=1740337&view=auto
==============================================================================
--- incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-jython.py (added)
+++ incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-jython.py Thu Apr 21 14:58:17 2016
@@ -0,0 +1,718 @@
+'''
+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.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 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 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 build(self, *args):
+ return self.traversalSource.build(*args)
+ def inject(self, *args):
+ return JythonGraphTraversal(self.traversalSource.inject(*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(indices,indices+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 label(self, *args):
+ self.traversal = self.traversal.label(*args)
+ return self
+ 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 until(self, *args):
+ self.traversal = self.traversal.until(*args)
+ return self
+ def asAdmin(self, *args):
+ self.traversal = self.traversal.asAdmin(*args)
+ return self
+ def choose(self, *args):
+ self.traversal = self.traversal.choose(*args)
+ return self
+ def program(self, *args):
+ self.traversal = self.traversal.program(*args)
+ return self
+ def both(self, *args):
+ self.traversal = self.traversal.both(*args)
+ return self
+ def toE(self, *args):
+ self.traversal = self.traversal.toE(*args)
+ return self
+ 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 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 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 propertyMap(self, *args):
+ self.traversal = self.traversal.propertyMap(*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 property(self, *args):
+ self.traversal = self.traversal.property(*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 option(self, *args):
+ self.traversal = self.traversal.option(*args)
+ return self
+ def cap(self, *args):
+ self.traversal = self.traversal.cap(*args)
+ return self
+ def _is(self, *args):
+ return self.traversal.is(*args)
+ def _not(self, *args):
+ return self.traversal.not(*args)
+ 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 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 tryNext(self, *args):
+ return self.traversal.tryNext(*args)
+ def toStream(self, *args):
+ return self.traversal.toStream(*args)
+ def toBulkSet(self, *args):
+ return self.traversal.toBulkSet(*args)
+ def explain(self, *args):
+ return self.traversal.explain(*args)
+ def toSet(self, *args):
+ return self.traversal.toSet(*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 label(*args):
+ return anon.label(*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 until(*args):
+ return anon.until(*args)
+ @staticmethod
+ def __(*args):
+ return anon.__(*args)
+ @staticmethod
+ def choose(*args):
+ return anon.choose(*args)
+ @staticmethod
+ def both(*args):
+ return anon.both(*args)
+ @staticmethod
+ def toE(*args):
+ return anon.toE(*args)
+ @staticmethod
+ def outE(*args):
+ return anon.outE(*args)
+ @staticmethod
+ def inE(*args):
+ return anon.inE(*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 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 propertyMap(*args):
+ return anon.propertyMap(*args)
+ @staticmethod
+ def select(*args):
+ return anon.select(*args)
+ @staticmethod
+ def _as(*args):
+ return anon.as(*args)
+ @staticmethod
+ def property(*args):
+ return anon.property(*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 cap(*args):
+ return anon.cap(*args)
+ @staticmethod
+ def _is(*args):
+ return anon.is(*args)
+ @staticmethod
+ def _not(*args):
+ return anon.not(*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 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)
+
Added: incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-python.py
URL: http://svn.apache.org/viewvc/incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-python.py?rev=1740337&view=auto
==============================================================================
--- incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-python.py (added)
+++ incubator/tinkerpop/site/docs/3.2.1-SNAPSHOT/resources/gremlin-python.py Thu Apr 21 14:58:17 2016
@@ -0,0 +1,747 @@
+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(indices,indices+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)
+
+