| ''' |
| 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) |
| |
| |
