included new gremlin-python in package

goblin/gremlin_python/__init__.py

@@ -16,21 +16,6 @@ KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
 '''
-from .graph_traversal import PythonGraphTraversal
-from .graph_traversal import PythonGraphTraversalSource
-from .graph_traversal import __
-from .groovy_translator import GroovyTranslator
-from .jython_translator import JythonTranslator
-from .traversal import Barrier
-from .traversal import Cardinality
-from .traversal import Column
-from .traversal import Direction
-from .traversal import Operator
-from .traversal import Order
-from .traversal import P
-from .traversal import Pop
-from .traversal import PythonTraversal
-from .traversal import Scope
-from .traversal import T
+import statics
 
 __author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'

goblin/gremlin_python/driver/__init__.py

+'''
+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 remote_connection import RemoteConnection
+from rest_remote_connection import RESTRemoteConnection
+
+__author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'

goblin/gremlin_python/translator.py → goblin/gremlin_python/driver/remote_connection.py

@@ -20,50 +20,12 @@ from abc import abstractmethod
 
 __author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'
 
-TO_JAVA_MAP = {"_global": "global", "_as": "as", "_in": "in", "_and": "and",
-               "_or": "or", "_is": "is", "_not": "not", "_from": "from",
-               "Cardinality": "VertexProperty.Cardinality", "Barrier": "SackFunctions.Barrier"}
 
-
-class Translator(object):
-    def __init__(self, alias, source_language, target_language):
-        self.alias = alias
-        self.source_language = source_language
-        self.target_language = target_language
-        self.traversal_script = alias
-
-    @abstractmethod
-    def addStep(self, traversal, step_name, *args):
-        return
-
-    @abstractmethod
-    def addSpawnStep(self, traversal, step_name, *args):
-        return
-
-    @abstractmethod
-    def addSource(self, traversal_source, source_name, *args):
-        return
-
-    @abstractmethod
-    def getAnonymousTraversalTranslator(self):
-        return Translator("__", self.source_language, self.target_language)
+class RemoteConnection(object):
+    def __init__(self, url):
+        self.url = url
 
     @abstractmethod
-    def __repr__(self):
-        return "translator[" + self.source_language + "->" + self.target_language + "]"
-
-
-class SymbolHelper(object):
-    @staticmethod
-    def toJava(symbol):
-        if (symbol in TO_JAVA_MAP):
-            return TO_JAVA_MAP[symbol]
-        else:
-            return symbol
-
-    @staticmethod
-    def mapEnum(enum):
-        if (enum in enumMap):
-            return enumMap[enum]
-        else:
-            return enum
+    def submit(self, target_language, script, bindings):
+        print "sending " + script + " to GremlinServer..."
+        return iter([])

goblin/gremlin_python/driver/rest_remote_connection.py

+'''
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+'''
+import json
+import requests
+
+from gremlin_python.process.traversal import Traverser
+from remote_connection import RemoteConnection
+
+__author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'
+
+
+class RESTRemoteConnection(RemoteConnection):
+    def __init__(self, url):
+        RemoteConnection.__init__(self, url)
+
+    def __repr__(self):
+        return "RESTRemoteConnection[" + self.url + "]"
+
+    def submit(self, target_language, script, bindings):
+        response = requests.post(self.url, data=json.dumps(
+            {"gremlin": script, "language": target_language, "bindings": bindings}))
+        if response.status_code != requests.codes.ok:
+            raise BaseException(response.text)
+        results = []
+        for x in response.json()['result']['data']:
+            results.append(Traverser(x, 1))
+        return iter(results)

goblin/gremlin_python/process/__init__.py

+'''
+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 graph_traversal import GraphTraversal
+from graph_traversal import GraphTraversalSource
+from graph_traversal import __
+from groovy_translator import GroovyTranslator
+from jython_translator import JythonTranslator
+from traversal import Barrier
+from traversal import Bytecode
+from traversal import Cardinality
+from traversal import Column
+from traversal import Direction
+from traversal import Operator
+from traversal import Order
+from traversal import P
+from traversal import Pop
+from traversal import Scope
+from traversal import T
+from traversal import Traversal
+
+__author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'

goblin/gremlin_python/graph_traversal.py → goblin/gremlin_python/process/graph_traversal.py

@@ -16,22 +16,21 @@ KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
 '''
-from .traversal import RawExpression
-from .traversal import PythonTraversal
-from . import statics
-globalTranslator = None
-
-class PythonGraphTraversalSource(object):
-  def __init__(self, translator, remote_connection=None):
-    global globalTranslator
-    self.translator = translator
-    globalTranslator = translator
-    self.remote_connection = remote_connection
+from traversal import RawExpression
+from traversal import Traversal
+from traversal import Bytecode
+from gremlin_python import statics
+
+class GraphTraversalSource(object):
+  def __init__(self, graph, traversal_strategies, bytecode=Bytecode()):
+    self.graph = graph
+    self.traversal_strategies = traversal_strategies
+    self.bytecode = bytecode
   def __repr__(self):
-    return "graphtraversalsource[" + str(self.remote_connection) + ", " + self.translator.traversal_script + "]"
+    return "graphtraversalsource[" + str(self.graph) + "]"
   def E(self, *args):
-    traversal = PythonGraphTraversal(self.translator, self.remote_connection)
-    traversal.translator.addSpawnStep(traversal, "E", *args)
+    traversal = GraphTraversal(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    traversal.bytecode.add_step("E", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -39,8 +38,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return traversal
   def V(self, *args):
-    traversal = PythonGraphTraversal(self.translator, self.remote_connection)
-    traversal.translator.addSpawnStep(traversal, "V", *args)
+    traversal = GraphTraversal(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    traversal.bytecode.add_step("V", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -48,8 +47,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return traversal
   def addV(self, *args):
-    traversal = PythonGraphTraversal(self.translator, self.remote_connection)
-    traversal.translator.addSpawnStep(traversal, "addV", *args)
+    traversal = GraphTraversal(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    traversal.bytecode.add_step("addV", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -57,8 +56,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return traversal
   def inject(self, *args):
-    traversal = PythonGraphTraversal(self.translator, self.remote_connection)
-    traversal.translator.addSpawnStep(traversal, "inject", *args)
+    traversal = GraphTraversal(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    traversal.bytecode.add_step("inject", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -66,8 +65,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return traversal
   def withBulk(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withBulk", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withBulk", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -75,8 +74,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return source
   def withComputer(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withComputer", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withComputer", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -84,8 +83,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return source
   def withPath(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withPath", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withPath", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -93,8 +92,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return source
   def withSack(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withSack", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withSack", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -102,8 +101,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return source
   def withSideEffect(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withSideEffect", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withSideEffect", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -111,8 +110,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return source
   def withStrategies(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withStrategies", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withStrategies", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -120,8 +119,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return source
   def withTranslator(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withTranslator", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withTranslator", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -129,8 +128,8 @@ class PythonGraphTraversalSource(object):
         self.bindings.update(arg.bindings)
     return source
   def withoutStrategies(self, *args):
-    source = PythonGraphTraversalSource(self.translator, self.remote_connection)
-    source.translator.addSource(source, "withoutStrategies", *args)
+    source = GraphTraversalSource(self.graph, self.traversal_strategies, Bytecode(self.bytecode))
+    source.bytecode.add_source("withoutStrategies", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -139,11 +138,11 @@ class PythonGraphTraversalSource(object):
     return source
 
 
-class PythonGraphTraversal(PythonTraversal):
-  def __init__(self, translator, remote_connection=None):
-    PythonTraversal.__init__(self, translator, remote_connection)
+class GraphTraversal(Traversal):
+  def __init__(self, graph, traversal_strategies, bytecode):
+    Traversal.__init__(self, graph, traversal_strategies, bytecode)
   def V(self, *args):
-    self.translator.addStep(self, "V", *args)
+    self.bytecode.add_step("V", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -151,7 +150,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def _and(self, *args):
-    self.translator.addStep(self, "_and", *args)
+    self.bytecode.add_step("_and", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -159,7 +158,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def _as(self, *args):
-    self.translator.addStep(self, "_as", *args)
+    self.bytecode.add_step("_as", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -167,7 +166,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def _from(self, *args):
-    self.translator.addStep(self, "_from", *args)
+    self.bytecode.add_step("_from", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -175,7 +174,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def _in(self, *args):
-    self.translator.addStep(self, "_in", *args)
+    self.bytecode.add_step("_in", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -183,7 +182,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def _is(self, *args):
-    self.translator.addStep(self, "_is", *args)
+    self.bytecode.add_step("_is", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -191,7 +190,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def _not(self, *args):
-    self.translator.addStep(self, "_not", *args)
+    self.bytecode.add_step("_not", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -199,7 +198,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def _or(self, *args):
-    self.translator.addStep(self, "_or", *args)
+    self.bytecode.add_step("_or", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -207,7 +206,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def addE(self, *args):
-    self.translator.addStep(self, "addE", *args)
+    self.bytecode.add_step("addE", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -215,7 +214,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def addInE(self, *args):
-    self.translator.addStep(self, "addInE", *args)
+    self.bytecode.add_step("addInE", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -223,7 +222,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def addOutE(self, *args):
-    self.translator.addStep(self, "addOutE", *args)
+    self.bytecode.add_step("addOutE", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -231,7 +230,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def addV(self, *args):
-    self.translator.addStep(self, "addV", *args)
+    self.bytecode.add_step("addV", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -239,7 +238,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def aggregate(self, *args):
-    self.translator.addStep(self, "aggregate", *args)
+    self.bytecode.add_step("aggregate", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -247,7 +246,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def asAdmin(self, *args):
-    self.translator.addStep(self, "asAdmin", *args)
+    self.bytecode.add_step("asAdmin", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -255,7 +254,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def barrier(self, *args):
-    self.translator.addStep(self, "barrier", *args)
+    self.bytecode.add_step("barrier", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -263,7 +262,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def both(self, *args):
-    self.translator.addStep(self, "both", *args)
+    self.bytecode.add_step("both", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -271,7 +270,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def bothE(self, *args):
-    self.translator.addStep(self, "bothE", *args)
+    self.bytecode.add_step("bothE", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -279,7 +278,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def bothV(self, *args):
-    self.translator.addStep(self, "bothV", *args)
+    self.bytecode.add_step("bothV", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -287,7 +286,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def branch(self, *args):
-    self.translator.addStep(self, "branch", *args)
+    self.bytecode.add_step("branch", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -295,7 +294,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def by(self, *args):
-    self.translator.addStep(self, "by", *args)
+    self.bytecode.add_step("by", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -303,7 +302,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def cap(self, *args):
-    self.translator.addStep(self, "cap", *args)
+    self.bytecode.add_step("cap", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -311,7 +310,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def choose(self, *args):
-    self.translator.addStep(self, "choose", *args)
+    self.bytecode.add_step("choose", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -319,7 +318,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def coalesce(self, *args):
-    self.translator.addStep(self, "coalesce", *args)
+    self.bytecode.add_step("coalesce", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -327,7 +326,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def coin(self, *args):
-    self.translator.addStep(self, "coin", *args)
+    self.bytecode.add_step("coin", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -335,7 +334,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def constant(self, *args):
-    self.translator.addStep(self, "constant", *args)
+    self.bytecode.add_step("constant", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -343,7 +342,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def count(self, *args):
-    self.translator.addStep(self, "count", *args)
+    self.bytecode.add_step("count", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -351,7 +350,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def cyclicPath(self, *args):
-    self.translator.addStep(self, "cyclicPath", *args)
+    self.bytecode.add_step("cyclicPath", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -359,7 +358,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def dedup(self, *args):
-    self.translator.addStep(self, "dedup", *args)
+    self.bytecode.add_step("dedup", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -367,7 +366,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def drop(self, *args):
-    self.translator.addStep(self, "drop", *args)
+    self.bytecode.add_step("drop", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -375,7 +374,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def emit(self, *args):
-    self.translator.addStep(self, "emit", *args)
+    self.bytecode.add_step("emit", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -383,7 +382,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def filter(self, *args):
-    self.translator.addStep(self, "filter", *args)
+    self.bytecode.add_step("filter", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -391,7 +390,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def flatMap(self, *args):
-    self.translator.addStep(self, "flatMap", *args)
+    self.bytecode.add_step("flatMap", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -399,7 +398,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def fold(self, *args):
-    self.translator.addStep(self, "fold", *args)
+    self.bytecode.add_step("fold", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -407,7 +406,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def group(self, *args):
-    self.translator.addStep(self, "group", *args)
+    self.bytecode.add_step("group", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -415,7 +414,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def groupCount(self, *args):
-    self.translator.addStep(self, "groupCount", *args)
+    self.bytecode.add_step("groupCount", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -423,7 +422,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def groupV3d0(self, *args):
-    self.translator.addStep(self, "groupV3d0", *args)
+    self.bytecode.add_step("groupV3d0", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -431,7 +430,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def has(self, *args):
-    self.translator.addStep(self, "has", *args)
+    self.bytecode.add_step("has", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -439,7 +438,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def hasId(self, *args):
-    self.translator.addStep(self, "hasId", *args)
+    self.bytecode.add_step("hasId", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -447,7 +446,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def hasKey(self, *args):
-    self.translator.addStep(self, "hasKey", *args)
+    self.bytecode.add_step("hasKey", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -455,7 +454,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def hasLabel(self, *args):
-    self.translator.addStep(self, "hasLabel", *args)
+    self.bytecode.add_step("hasLabel", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -463,7 +462,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def hasNot(self, *args):
-    self.translator.addStep(self, "hasNot", *args)
+    self.bytecode.add_step("hasNot", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -471,7 +470,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def hasValue(self, *args):
-    self.translator.addStep(self, "hasValue", *args)
+    self.bytecode.add_step("hasValue", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -479,7 +478,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def id(self, *args):
-    self.translator.addStep(self, "id", *args)
+    self.bytecode.add_step("id", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -487,7 +486,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def identity(self, *args):
-    self.translator.addStep(self, "identity", *args)
+    self.bytecode.add_step("identity", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -495,7 +494,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def inE(self, *args):
-    self.translator.addStep(self, "inE", *args)
+    self.bytecode.add_step("inE", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -503,7 +502,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def inV(self, *args):
-    self.translator.addStep(self, "inV", *args)
+    self.bytecode.add_step("inV", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -511,7 +510,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def inject(self, *args):
-    self.translator.addStep(self, "inject", *args)
+    self.bytecode.add_step("inject", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -519,7 +518,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def iterate(self, *args):
-    self.translator.addStep(self, "iterate", *args)
+    self.bytecode.add_step("iterate", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -527,7 +526,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def key(self, *args):
-    self.translator.addStep(self, "key", *args)
+    self.bytecode.add_step("key", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -535,7 +534,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def label(self, *args):
-    self.translator.addStep(self, "label", *args)
+    self.bytecode.add_step("label", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -543,7 +542,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def limit(self, *args):
-    self.translator.addStep(self, "limit", *args)
+    self.bytecode.add_step("limit", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -551,7 +550,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def local(self, *args):
-    self.translator.addStep(self, "local", *args)
+    self.bytecode.add_step("local", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -559,7 +558,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def loops(self, *args):
-    self.translator.addStep(self, "loops", *args)
+    self.bytecode.add_step("loops", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -567,7 +566,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def map(self, *args):
-    self.translator.addStep(self, "map", *args)
+    self.bytecode.add_step("map", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -575,7 +574,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def mapKeys(self, *args):
-    self.translator.addStep(self, "mapKeys", *args)
+    self.bytecode.add_step("mapKeys", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -583,7 +582,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def mapValues(self, *args):
-    self.translator.addStep(self, "mapValues", *args)
+    self.bytecode.add_step("mapValues", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -591,7 +590,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def match(self, *args):
-    self.translator.addStep(self, "match", *args)
+    self.bytecode.add_step("match", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -599,7 +598,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def max(self, *args):
-    self.translator.addStep(self, "max", *args)
+    self.bytecode.add_step("max", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -607,7 +606,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def mean(self, *args):
-    self.translator.addStep(self, "mean", *args)
+    self.bytecode.add_step("mean", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -615,7 +614,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def min(self, *args):
-    self.translator.addStep(self, "min", *args)
+    self.bytecode.add_step("min", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -623,7 +622,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def option(self, *args):
-    self.translator.addStep(self, "option", *args)
+    self.bytecode.add_step("option", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -631,7 +630,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def optional(self, *args):
-    self.translator.addStep(self, "optional", *args)
+    self.bytecode.add_step("optional", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -639,7 +638,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def order(self, *args):
-    self.translator.addStep(self, "order", *args)
+    self.bytecode.add_step("order", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -647,7 +646,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def otherV(self, *args):
-    self.translator.addStep(self, "otherV", *args)
+    self.bytecode.add_step("otherV", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -655,7 +654,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def out(self, *args):
-    self.translator.addStep(self, "out", *args)
+    self.bytecode.add_step("out", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -663,7 +662,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def outE(self, *args):
-    self.translator.addStep(self, "outE", *args)
+    self.bytecode.add_step("outE", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -671,7 +670,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def outV(self, *args):
-    self.translator.addStep(self, "outV", *args)
+    self.bytecode.add_step("outV", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -679,7 +678,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def pageRank(self, *args):
-    self.translator.addStep(self, "pageRank", *args)
+    self.bytecode.add_step("pageRank", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -687,7 +686,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def path(self, *args):
-    self.translator.addStep(self, "path", *args)
+    self.bytecode.add_step("path", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -695,7 +694,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def peerPressure(self, *args):
-    self.translator.addStep(self, "peerPressure", *args)
+    self.bytecode.add_step("peerPressure", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -703,7 +702,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def profile(self, *args):
-    self.translator.addStep(self, "profile", *args)
+    self.bytecode.add_step("profile", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -711,7 +710,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def program(self, *args):
-    self.translator.addStep(self, "program", *args)
+    self.bytecode.add_step("program", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -719,7 +718,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def project(self, *args):
-    self.translator.addStep(self, "project", *args)
+    self.bytecode.add_step("project", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -727,7 +726,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def properties(self, *args):
-    self.translator.addStep(self, "properties", *args)
+    self.bytecode.add_step("properties", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -735,7 +734,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def property(self, *args):
-    self.translator.addStep(self, "property", *args)
+    self.bytecode.add_step("property", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -743,7 +742,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def propertyMap(self, *args):
-    self.translator.addStep(self, "propertyMap", *args)
+    self.bytecode.add_step("propertyMap", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -751,7 +750,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def range(self, *args):
-    self.translator.addStep(self, "range", *args)
+    self.bytecode.add_step("range", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -759,7 +758,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def repeat(self, *args):
-    self.translator.addStep(self, "repeat", *args)
+    self.bytecode.add_step("repeat", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -767,7 +766,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def sack(self, *args):
-    self.translator.addStep(self, "sack", *args)
+    self.bytecode.add_step("sack", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -775,7 +774,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def sample(self, *args):
-    self.translator.addStep(self, "sample", *args)
+    self.bytecode.add_step("sample", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -783,7 +782,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def select(self, *args):
-    self.translator.addStep(self, "select", *args)
+    self.bytecode.add_step("select", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -791,7 +790,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def sideEffect(self, *args):
-    self.translator.addStep(self, "sideEffect", *args)
+    self.bytecode.add_step("sideEffect", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -799,7 +798,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def simplePath(self, *args):
-    self.translator.addStep(self, "simplePath", *args)
+    self.bytecode.add_step("simplePath", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -807,7 +806,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def store(self, *args):
-    self.translator.addStep(self, "store", *args)
+    self.bytecode.add_step("store", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -815,7 +814,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def subgraph(self, *args):
-    self.translator.addStep(self, "subgraph", *args)
+    self.bytecode.add_step("subgraph", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -823,7 +822,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def sum(self, *args):
-    self.translator.addStep(self, "sum", *args)
+    self.bytecode.add_step("sum", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -831,7 +830,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def tail(self, *args):
-    self.translator.addStep(self, "tail", *args)
+    self.bytecode.add_step("tail", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -839,7 +838,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def timeLimit(self, *args):
-    self.translator.addStep(self, "timeLimit", *args)
+    self.bytecode.add_step("timeLimit", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -847,7 +846,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def times(self, *args):
-    self.translator.addStep(self, "times", *args)
+    self.bytecode.add_step("times", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -855,7 +854,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def to(self, *args):
-    self.translator.addStep(self, "to", *args)
+    self.bytecode.add_step("to", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -863,7 +862,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def toE(self, *args):
-    self.translator.addStep(self, "toE", *args)
+    self.bytecode.add_step("toE", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -871,7 +870,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def toV(self, *args):
-    self.translator.addStep(self, "toV", *args)
+    self.bytecode.add_step("toV", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -879,7 +878,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def tree(self, *args):
-    self.translator.addStep(self, "tree", *args)
+    self.bytecode.add_step("tree", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -887,7 +886,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def unfold(self, *args):
-    self.translator.addStep(self, "unfold", *args)
+    self.bytecode.add_step("unfold", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -895,7 +894,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def union(self, *args):
-    self.translator.addStep(self, "union", *args)
+    self.bytecode.add_step("union", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -903,7 +902,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def until(self, *args):
-    self.translator.addStep(self, "until", *args)
+    self.bytecode.add_step("until", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -911,7 +910,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def value(self, *args):
-    self.translator.addStep(self, "value", *args)
+    self.bytecode.add_step("value", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -919,7 +918,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def valueMap(self, *args):
-    self.translator.addStep(self, "valueMap", *args)
+    self.bytecode.add_step("valueMap", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -927,7 +926,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def values(self, *args):
-    self.translator.addStep(self, "values", *args)
+    self.bytecode.add_step("values", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -935,7 +934,7 @@ class PythonGraphTraversal(PythonTraversal):
         self.bindings.update(arg.bindings)
     return self
   def where(self, *args):
-    self.translator.addStep(self, "where", *args)
+    self.bytecode.add_step("where", *args)
     for arg in args:
       if isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):
         self.bindings[arg[0]] = arg[1]
@@ -947,650 +946,744 @@ class PythonGraphTraversal(PythonTraversal):
 class __(object):
   @staticmethod
   def V(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).V(*args)
+    return GraphTraversal(None, None, Bytecode()).V(*args)
   @staticmethod
   def __(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).__(*args)
+    return GraphTraversal(None, None, Bytecode()).__(*args)
   @staticmethod
   def _and(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator())._and(*args)
+    return GraphTraversal(None, None, Bytecode())._and(*args)
   @staticmethod
   def _as(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator())._as(*args)
+    return GraphTraversal(None, None, Bytecode())._as(*args)
   @staticmethod
   def _in(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator())._in(*args)
+    return GraphTraversal(None, None, Bytecode())._in(*args)
   @staticmethod
   def _is(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator())._is(*args)
+    return GraphTraversal(None, None, Bytecode())._is(*args)
   @staticmethod
   def _not(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator())._not(*args)
+    return GraphTraversal(None, None, Bytecode())._not(*args)
   @staticmethod
   def _or(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator())._or(*args)
+    return GraphTraversal(None, None, Bytecode())._or(*args)
   @staticmethod
   def addE(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).addE(*args)
+    return GraphTraversal(None, None, Bytecode()).addE(*args)
   @staticmethod
   def addInE(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).addInE(*args)
+    return GraphTraversal(None, None, Bytecode()).addInE(*args)
   @staticmethod
   def addOutE(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).addOutE(*args)
+    return GraphTraversal(None, None, Bytecode()).addOutE(*args)
   @staticmethod
   def addV(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).addV(*args)
+    return GraphTraversal(None, None, Bytecode()).addV(*args)
   @staticmethod
   def aggregate(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).aggregate(*args)
+    return GraphTraversal(None, None, Bytecode()).aggregate(*args)
   @staticmethod
   def barrier(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).barrier(*args)
+    return GraphTraversal(None, None, Bytecode()).barrier(*args)
   @staticmethod
   def both(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).both(*args)
+    return GraphTraversal(None, None, Bytecode()).both(*args)
   @staticmethod
   def bothE(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).bothE(*args)
+    return GraphTraversal(None, None, Bytecode()).bothE(*args)
   @staticmethod
   def bothV(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).bothV(*args)
+    return GraphTraversal(None, None, Bytecode()).bothV(*args)
   @staticmethod
   def branch(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).branch(*args)
+    return GraphTraversal(None, None, Bytecode()).branch(*args)
   @staticmethod
   def cap(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).cap(*args)
+    return GraphTraversal(None, None, Bytecode()).cap(*args)
   @staticmethod
   def choose(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).choose(*args)
+    return GraphTraversal(None, None, Bytecode()).choose(*args)
   @staticmethod
   def coalesce(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).coalesce(*args)
+    return GraphTraversal(None, None, Bytecode()).coalesce(*args)
   @staticmethod
   def coin(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).coin(*args)
+    return GraphTraversal(None, None, Bytecode()).coin(*args)
   @staticmethod
   def constant(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).constant(*args)
+    return GraphTraversal(None, None, Bytecode()).constant(*args)
   @staticmethod
   def count(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).count(*args)
+    return GraphTraversal(None, None, Bytecode()).count(*args)
   @staticmethod
   def cyclicPath(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).cyclicPath(*args)
+    return GraphTraversal(None, None, Bytecode()).cyclicPath(*args)
   @staticmethod
   def dedup(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).dedup(*args)
+    return GraphTraversal(None, None, Bytecode()).dedup(*args)
   @staticmethod
   def drop(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).drop(*args)
+    return GraphTraversal(None, None, Bytecode()).drop(*args)
   @staticmethod
   def emit(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).emit(*args)
+    return GraphTraversal(None, None, Bytecode()).emit(*args)
   @staticmethod
   def filter(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).filter(*args)
+    return GraphTraversal(None, None, Bytecode()).filter(*args)
   @staticmethod
   def flatMap(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).flatMap(*args)
+    return GraphTraversal(None, None, Bytecode()).flatMap(*args)
   @staticmethod
   def fold(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).fold(*args)
+    return GraphTraversal(None, None, Bytecode()).fold(*args)
   @staticmethod
   def group(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).group(*args)
+    return GraphTraversal(None, None, Bytecode()).group(*args)
   @staticmethod
   def groupCount(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).groupCount(*args)
+    return GraphTraversal(None, None, Bytecode()).groupCount(*args)
   @staticmethod
   def groupV3d0(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).groupV3d0(*args)
+    return GraphTraversal(None, None, Bytecode()).groupV3d0(*args)
   @staticmethod
   def has(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).has(*args)
+    return GraphTraversal(None, None, Bytecode()).has(*args)
   @staticmethod
   def hasId(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).hasId(*args)
+    return GraphTraversal(None, None, Bytecode()).hasId(*args)
   @staticmethod
   def hasKey(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).hasKey(*args)
+    return GraphTraversal(None, None, Bytecode()).hasKey(*args)
   @staticmethod
   def hasLabel(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).hasLabel(*args)
+    return GraphTraversal(None, None, Bytecode()).hasLabel(*args)
   @staticmethod
   def hasNot(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).hasNot(*args)
+    return GraphTraversal(None, None, Bytecode()).hasNot(*args)
   @staticmethod
   def hasValue(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).hasValue(*args)
+    return GraphTraversal(None, None, Bytecode()).hasValue(*args)
   @staticmethod
   def id(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).id(*args)
+    return GraphTraversal(None, None, Bytecode()).id(*args)
   @staticmethod
   def identity(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).identity(*args)
+    return GraphTraversal(None, None, Bytecode()).identity(*args)
   @staticmethod
   def inE(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).inE(*args)
+    return GraphTraversal(None, None, Bytecode()).inE(*args)
   @staticmethod
   def inV(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).inV(*args)
+    return GraphTraversal(None, None, Bytecode()).inV(*args)
   @staticmethod
   def inject(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).inject(*args)
+    return GraphTraversal(None, None, Bytecode()).inject(*args)
   @staticmethod
   def key(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).key(*args)
+    return GraphTraversal(None, None, Bytecode()).key(*args)
   @staticmethod
   def label(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).label(*args)
+    return GraphTraversal(None, None, Bytecode()).label(*args)
   @staticmethod
   def limit(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).limit(*args)
+    return GraphTraversal(None, None, Bytecode()).limit(*args)
   @staticmethod
   def local(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).local(*args)
+    return GraphTraversal(None, None, Bytecode()).local(*args)
   @staticmethod
   def loops(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).loops(*args)
+    return GraphTraversal(None, None, Bytecode()).loops(*args)
   @staticmethod
   def map(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).map(*args)
+    return GraphTraversal(None, None, Bytecode()).map(*args)
   @staticmethod
   def mapKeys(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).mapKeys(*args)
+    return GraphTraversal(None, None, Bytecode()).mapKeys(*args)
   @staticmethod
   def mapValues(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).mapValues(*args)
+    return GraphTraversal(None, None, Bytecode()).mapValues(*args)
   @staticmethod
   def match(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).match(*args)
+    return GraphTraversal(None, None, Bytecode()).match(*args)
   @staticmethod
   def max(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).max(*args)
+    return GraphTraversal(None, None, Bytecode()).max(*args)
   @staticmethod
   def mean(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).mean(*args)
+    return GraphTraversal(None, None, Bytecode()).mean(*args)
   @staticmethod
   def min(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).min(*args)
+    return GraphTraversal(None, None, Bytecode()).min(*args)
   @staticmethod
   def optional(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).optional(*args)
+    return GraphTraversal(None, None, Bytecode()).optional(*args)
   @staticmethod
   def order(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).order(*args)
+    return GraphTraversal(None, None, Bytecode()).order(*args)
   @staticmethod
   def otherV(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).otherV(*args)
+    return GraphTraversal(None, None, Bytecode()).otherV(*args)
   @staticmethod
   def out(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).out(*args)
+    return GraphTraversal(None, None, Bytecode()).out(*args)
   @staticmethod
   def outE(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).outE(*args)
+    return GraphTraversal(None, None, Bytecode()).outE(*args)
   @staticmethod
   def outV(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).outV(*args)
+    return GraphTraversal(None, None, Bytecode()).outV(*args)
   @staticmethod
   def path(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).path(*args)
+    return GraphTraversal(None, None, Bytecode()).path(*args)
   @staticmethod
   def project(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).project(*args)
+    return GraphTraversal(None, None, Bytecode()).project(*args)
   @staticmethod
   def properties(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).properties(*args)
+    return GraphTraversal(None, None, Bytecode()).properties(*args)
   @staticmethod
   def property(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).property(*args)
+    return GraphTraversal(None, None, Bytecode()).property(*args)
   @staticmethod
   def propertyMap(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).propertyMap(*args)
+    return GraphTraversal(None, None, Bytecode()).propertyMap(*args)
   @staticmethod
   def range(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).range(*args)
+    return GraphTraversal(None, None, Bytecode()).range(*args)
   @staticmethod
   def repeat(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).repeat(*args)
+    return GraphTraversal(None, None, Bytecode()).repeat(*args)
   @staticmethod
   def sack(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).sack(*args)
+    return GraphTraversal(None, None, Bytecode()).sack(*args)
   @staticmethod
   def sample(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).sample(*args)
+    return GraphTraversal(None, None, Bytecode()).sample(*args)
   @staticmethod
   def select(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).select(*args)
+    return GraphTraversal(None, None, Bytecode()).select(*args)
   @staticmethod
   def sideEffect(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).sideEffect(*args)
+    return GraphTraversal(None, None, Bytecode()).sideEffect(*args)
   @staticmethod
   def simplePath(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).simplePath(*args)
+    return GraphTraversal(None, None, Bytecode()).simplePath(*args)
   @staticmethod
   def start(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).start(*args)
+    return GraphTraversal(None, None, Bytecode()).start(*args)
   @staticmethod
   def store(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).store(*args)
+    return GraphTraversal(None, None, Bytecode()).store(*args)
   @staticmethod
   def subgraph(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).subgraph(*args)
+    return GraphTraversal(None, None, Bytecode()).subgraph(*args)
   @staticmethod
   def sum(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).sum(*args)
+    return GraphTraversal(None, None, Bytecode()).sum(*args)
   @staticmethod
   def tail(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).tail(*args)
+    return GraphTraversal(None, None, Bytecode()).tail(*args)
   @staticmethod
   def timeLimit(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).timeLimit(*args)
+    return GraphTraversal(None, None, Bytecode()).timeLimit(*args)
   @staticmethod
   def times(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).times(*args)
+    return GraphTraversal(None, None, Bytecode()).times(*args)
   @staticmethod
   def to(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).to(*args)
+    return GraphTraversal(None, None, Bytecode()).to(*args)
   @staticmethod
   def toE(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).toE(*args)
+    return GraphTraversal(None, None, Bytecode()).toE(*args)
   @staticmethod
   def toV(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).toV(*args)
+    return GraphTraversal(None, None, Bytecode()).toV(*args)
   @staticmethod
   def tree(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).tree(*args)
+    return GraphTraversal(None, None, Bytecode()).tree(*args)
   @staticmethod
   def unfold(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).unfold(*args)
+    return GraphTraversal(None, None, Bytecode()).unfold(*args)
   @staticmethod
   def union(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).union(*args)
+    return GraphTraversal(None, None, Bytecode()).union(*args)
   @staticmethod
   def until(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).until(*args)
+    return GraphTraversal(None, None, Bytecode()).until(*args)
   @staticmethod
   def value(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).value(*args)
+    return GraphTraversal(None, None, Bytecode()).value(*args)
   @staticmethod
   def valueMap(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).valueMap(*args)
+    return GraphTraversal(None, None, Bytecode()).valueMap(*args)
   @staticmethod
   def values(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).values(*args)
+    return GraphTraversal(None, None, Bytecode()).values(*args)
   @staticmethod
   def where(*args):
-    return PythonGraphTraversal(globalTranslator.getAnonymousTraversalTranslator()).where(*args)
+    return GraphTraversal(None, None, Bytecode()).where(*args)
 
 
 def V(*args):
       return __.V(*args)
 
 statics.add_static('V', V)
+
 def _and(*args):
       return __._and(*args)
 
 statics.add_static('_and', _and)
+
 def _as(*args):
       return __._as(*args)
 
 statics.add_static('_as', _as)
+
 def _in(*args):
       return __._in(*args)
 
 statics.add_static('_in', _in)
+
 def _is(*args):
       return __._is(*args)
 
 statics.add_static('_is', _is)
+
 def _not(*args):
       return __._not(*args)
 
 statics.add_static('_not', _not)
+
 def _or(*args):
       return __._or(*args)
 
 statics.add_static('_or', _or)
+
 def addE(*args):
       return __.addE(*args)
 
 statics.add_static('addE', addE)
+
 def addInE(*args):
       return __.addInE(*args)
 
 statics.add_static('addInE', addInE)
+
 def addOutE(*args):
       return __.addOutE(*args)
 
 statics.add_static('addOutE', addOutE)
+
 def addV(*args):
       return __.addV(*args)
 
 statics.add_static('addV', addV)
+
 def aggregate(*args):
       return __.aggregate(*args)
 
 statics.add_static('aggregate', aggregate)
+
 def barrier(*args):
       return __.barrier(*args)
 
 statics.add_static('barrier', barrier)
+
 def both(*args):
       return __.both(*args)
 
 statics.add_static('both', both)
+
 def bothE(*args):
       return __.bothE(*args)
 
 statics.add_static('bothE', bothE)
+
 def bothV(*args):
       return __.bothV(*args)
 
 statics.add_static('bothV', bothV)
+
 def branch(*args):
       return __.branch(*args)
 
 statics.add_static('branch', branch)
+
 def cap(*args):
       return __.cap(*args)
 
 statics.add_static('cap', cap)
+
 def choose(*args):
       return __.choose(*args)
 
 statics.add_static('choose', choose)
+
 def coalesce(*args):
       return __.coalesce(*args)
 
 statics.add_static('coalesce', coalesce)
+
 def coin(*args):
       return __.coin(*args)
 
 statics.add_static('coin', coin)
+
 def constant(*args):
       return __.constant(*args)
 
 statics.add_static('constant', constant)
+
 def count(*args):
       return __.count(*args)
 
 statics.add_static('count', count)
+
 def cyclicPath(*args):
       return __.cyclicPath(*args)
 
 statics.add_static('cyclicPath', cyclicPath)
+
 def dedup(*args):
       return __.dedup(*args)
 
 statics.add_static('dedup', dedup)
+
 def drop(*args):
       return __.drop(*args)
 
 statics.add_static('drop', drop)
+
 def emit(*args):
       return __.emit(*args)
 
 statics.add_static('emit', emit)
+
 def filter(*args):
       return __.filter(*args)
 
 statics.add_static('filter', filter)
+
 def flatMap(*args):
       return __.flatMap(*args)
 
 statics.add_static('flatMap', flatMap)
+
 def fold(*args):
       return __.fold(*args)
 
 statics.add_static('fold', fold)
+
 def group(*args):
       return __.group(*args)
 
 statics.add_static('group', group)
+
 def groupCount(*args):
       return __.groupCount(*args)
 
 statics.add_static('groupCount', groupCount)
+
 def groupV3d0(*args):
       return __.groupV3d0(*args)
 
 statics.add_static('groupV3d0', groupV3d0)
+
 def has(*args):
       return __.has(*args)
 
 statics.add_static('has', has)
+
 def hasId(*args):
       return __.hasId(*args)
 
 statics.add_static('hasId', hasId)
+
 def hasKey(*args):
       return __.hasKey(*args)
 
 statics.add_static('hasKey', hasKey)
+
 def hasLabel(*args):
       return __.hasLabel(*args)
 
 statics.add_static('hasLabel', hasLabel)
+
 def hasNot(*args):
       return __.hasNot(*args)
 
 statics.add_static('hasNot', hasNot)
+
 def hasValue(*args):
       return __.hasValue(*args)
 
 statics.add_static('hasValue', hasValue)
+
 def id(*args):
       return __.id(*args)
 
 statics.add_static('id', id)
+
 def identity(*args):
       return __.identity(*args)
 
 statics.add_static('identity', identity)
+
 def inE(*args):
       return __.inE(*args)
 
 statics.add_static('inE', inE)
+
 def inV(*args):
       return __.inV(*args)
 
 statics.add_static('inV', inV)
+
 def inject(*args):
       return __.inject(*args)
 
 statics.add_static('inject', inject)
+
 def key(*args):
       return __.key(*args)
 
 statics.add_static('key', key)
+
 def label(*args):
       return __.label(*args)
 
 statics.add_static('label', label)
+
 def limit(*args):
       return __.limit(*args)
 
 statics.add_static('limit', limit)
+
 def local(*args):
       return __.local(*args)
 
 statics.add_static('local', local)
+
 def loops(*args):
       return __.loops(*args)
 
 statics.add_static('loops', loops)
+
 def map(*args):
       return __.map(*args)
 
 statics.add_static('map', map)
+
 def mapKeys(*args):
       return __.mapKeys(*args)
 
 statics.add_static('mapKeys', mapKeys)
+
 def mapValues(*args):
       return __.mapValues(*args)
 
 statics.add_static('mapValues', mapValues)
+
 def match(*args):
       return __.match(*args)
 
 statics.add_static('match', match)
+
 def max(*args):
       return __.max(*args)
 
 statics.add_static('max', max)
+
 def mean(*args):
       return __.mean(*args)
 
 statics.add_static('mean', mean)
+
 def min(*args):
       return __.min(*args)
 
 statics.add_static('min', min)
+
 def optional(*args):
       return __.optional(*args)
 
 statics.add_static('optional', optional)
+
 def order(*args):
       return __.order(*args)
 
 statics.add_static('order', order)
+
 def otherV(*args):
       return __.otherV(*args)
 
 statics.add_static('otherV', otherV)
+
 def out(*args):
       return __.out(*args)
 
 statics.add_static('out', out)
+
 def outE(*args):
       return __.outE(*args)
 
 statics.add_static('outE', outE)
+
 def outV(*args):
       return __.outV(*args)
 
 statics.add_static('outV', outV)
+
 def path(*args):
       return __.path(*args)
 
 statics.add_static('path', path)
+
 def project(*args):
       return __.project(*args)
 
 statics.add_static('project', project)
+
 def properties(*args):
       return __.properties(*args)
 
 statics.add_static('properties', properties)
+
 def property(*args):
       return __.property(*args)
 
 statics.add_static('property', property)
+
 def propertyMap(*args):
       return __.propertyMap(*args)
 
 statics.add_static('propertyMap', propertyMap)
+
 def range(*args):
       return __.range(*args)
 
 statics.add_static('range', range)
+
 def repeat(*args):
       return __.repeat(*args)
 
 statics.add_static('repeat', repeat)
+
 def sack(*args):
       return __.sack(*args)
 
 statics.add_static('sack', sack)
+
 def sample(*args):
       return __.sample(*args)
 
 statics.add_static('sample', sample)
+
 def select(*args):
       return __.select(*args)
 
 statics.add_static('select', select)
+
 def sideEffect(*args):
       return __.sideEffect(*args)
 
 statics.add_static('sideEffect', sideEffect)
+
 def simplePath(*args):
       return __.simplePath(*args)
 
 statics.add_static('simplePath', simplePath)
+
 def start(*args):
       return __.start(*args)
 
 statics.add_static('start', start)
+
 def store(*args):
       return __.store(*args)
 
 statics.add_static('store', store)
+
 def subgraph(*args):
       return __.subgraph(*args)
 
 statics.add_static('subgraph', subgraph)
+
 def sum(*args):
       return __.sum(*args)
 
 statics.add_static('sum', sum)
+
 def tail(*args):
       return __.tail(*args)
 
 statics.add_static('tail', tail)
+
 def timeLimit(*args):
       return __.timeLimit(*args)
 
 statics.add_static('timeLimit', timeLimit)
+
 def times(*args):
       return __.times(*args)
 
 statics.add_static('times', times)
+
 def to(*args):
       return __.to(*args)
 
 statics.add_static('to', to)
+
 def toE(*args):
       return __.toE(*args)
 
 statics.add_static('toE', toE)
+
 def toV(*args):
       return __.toV(*args)
 
 statics.add_static('toV', toV)
+
 def tree(*args):
       return __.tree(*args)
 
 statics.add_static('tree', tree)
+
 def unfold(*args):
       return __.unfold(*args)
 
 statics.add_static('unfold', unfold)
+
 def union(*args):
       return __.union(*args)
 
 statics.add_static('union', union)
+
 def until(*args):
       return __.until(*args)
 
 statics.add_static('until', until)
+
 def value(*args):
       return __.value(*args)
 
 statics.add_static('value', value)
+
 def valueMap(*args):
       return __.valueMap(*args)
 
 statics.add_static('valueMap', valueMap)
+
 def values(*args):
       return __.values(*args)
 
 statics.add_static('values', values)
+
 def where(*args):
       return __.where(*args)
 
 statics.add_static('where', where)
+
+
+

goblin/gremlin_python/groovy_translator.py → goblin/gremlin_python/process/groovy_translator.py

@@ -20,10 +20,11 @@ under the License.
 import sys
 from aenum import Enum
 
-from .translator import SymbolHelper
-from .translator import Translator
-from .traversal import P
-from .traversal import RawExpression
+from traversal import Bytecode
+from traversal import P
+from traversal import RawExpression
+from traversal import SymbolHelper
+from traversal import Translator
 
 if sys.version_info.major > 2:
     long = int
@@ -32,32 +33,23 @@ __author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'
 
 
 class GroovyTranslator(Translator):
-    def __init__(self, alias, source_language="python", target_language="gremlin-groovy"):
-        Translator.__init__(self, alias, source_language, target_language)
+    def __init__(self, traversal_source, anonymous_traversal="__", target_language="gremlin-groovy"):
+        Translator.__init__(self, traversal_source, anonymous_traversal, target_language)
 
-    def addStep(self, traversal, step_name, *args):
-        self.traversal_script = self.traversal_script + "." + SymbolHelper.toJava(
-            step_name) + "(" + GroovyTranslator.stringify(*args) + ")"
+    def translate(self, bytecode):
+        return self.__internalTranslate(self.traversal_source, bytecode)
 
-    def addSpawnStep(self, traversal, step_name, *args):
-        newTranslator = GroovyTranslator(self.alias, self.source_language, self.target_language)
-        newTranslator.traversal_script = self.traversal_script
-        newTranslator.traversal_script = newTranslator.traversal_script + "." + SymbolHelper.toJava(
-            step_name) + "(" + GroovyTranslator.stringify(*args) + ")"
-        traversal.translator = newTranslator
+    def __internalTranslate(self, start, bytecode):
+        traversal_script = start
+        for instruction in bytecode.source_instructions:
+            traversal_script = traversal_script + "." + SymbolHelper.toJava(
+                instruction[0]) + "(" + self.stringify(*instruction[1]) + ")"
+        for instruction in bytecode.step_instructions:
+            traversal_script = traversal_script + "." + SymbolHelper.toJava(
+                instruction[0]) + "(" + self.stringify(*instruction[1]) + ")"
+        return traversal_script
 
-    def addSource(self, traversal_source, source_name, *args):
-        newTranslator = GroovyTranslator(self.alias, self.source_language, self.target_language)
-        newTranslator.traversal_script = self.traversal_script
-        newTranslator.traversal_script = newTranslator.traversal_script + "." + SymbolHelper.toJava(
-            source_name) + "(" + GroovyTranslator.stringify(*args) + ")"
-        traversal_source.translator = newTranslator
-
-    def getAnonymousTraversalTranslator(self):
-        return GroovyTranslator("__", self.source_language, self.target_language)
-
-    @staticmethod
-    def stringOrObject(arg):
+    def stringOrObject(self, arg):
         if isinstance(arg, str):
             return "\"" + arg + "\""
         elif isinstance(arg, bool):
@@ -70,11 +62,13 @@ class GroovyTranslator(Translator):
             return SymbolHelper.toJava(type(arg).__name__) + "." + SymbolHelper.toJava(str(arg.name))
         elif isinstance(arg, P):
             if arg.other is None:
-                return "P." + SymbolHelper.toJava(arg.operator) + "(" + GroovyTranslator.stringOrObject(
+                return "P." + SymbolHelper.toJava(arg.operator) + "(" + self.stringOrObject(
                     arg.value) + ")"
             else:
-                return GroovyTranslator.stringOrObject(arg.other) + "." + SymbolHelper.toJava(
-                    arg.operator) + "(" + GroovyTranslator.stringOrObject(arg.value) + ")"
+                return self.stringOrObject(arg.other) + "." + SymbolHelper.toJava(
+                    arg.operator) + "(" + self.stringOrObject(arg.value) + ")"
+        elif isinstance(arg, Bytecode):
+            return self.__internalTranslate(self.anonymous_traversal, arg)
         elif callable(arg):  # closures
             lambdaString = arg().strip()
             if lambdaString.startswith("{"):
@@ -84,15 +78,14 @@ class GroovyTranslator(Translator):
         elif isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):  # bindings
             return arg[0]
         elif isinstance(arg, RawExpression):
-            return "".join(GroovyTranslator.stringOrObject(i) for i in arg.parts)
+            return "".join(self.stringOrObject(i) for i in arg.parts)
         else:
             return str(arg)
 
-    @staticmethod
-    def stringify(*args):
+    def stringify(self, *args):
         if len(args) == 0:
             return ""
         elif len(args) == 1:
-            return GroovyTranslator.stringOrObject(args[0])
+            return self.stringOrObject(args[0])
         else:
-            return ", ".join(GroovyTranslator.stringOrObject(i) for i in args)
+            return ", ".join(self.stringOrObject(i) for i in args)

goblin/gremlin_python/jython_translator.py → goblin/gremlin_python/process/jython_translator.py

@@ -21,13 +21,14 @@ import inspect
 import sys
 from aenum import Enum
 
-from .translator import SymbolHelper
-from .translator import Translator
-from .traversal import Barrier
-from .traversal import Cardinality
-from .traversal import Column
-from .traversal import P
-from .traversal import RawExpression
+from traversal import Barrier
+from traversal import Bytecode
+from traversal import Cardinality
+from traversal import Column
+from traversal import P
+from traversal import RawExpression
+from traversal import SymbolHelper
+from traversal import Translator
 
 if sys.version_info.major > 2:
     long = int
@@ -36,36 +37,27 @@ __author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'
 
 
 class JythonTranslator(Translator):
-    def __init__(self, alias, source_language="python", target_language="gremlin-jython"):
-        Translator.__init__(self, alias, source_language, target_language)
+    def __init__(self, traversal_source, anonymous_traversal="__", target_language="gremlin-jython"):
+        Translator.__init__(self, traversal_source, anonymous_traversal, target_language)
 
-    def addStep(self, traversal, step_name, *args):
-        self.traversal_script = self.traversal_script + "." + SymbolHelper.toJava(
-            step_name) + "(" + JythonTranslator.stringify(*args) + ")"
+    def translate(self, bytecode):
+        return self.__internalTranslate(self.traversal_source, bytecode)
 
-    def addSpawnStep(self, traversal, step_name, *args):
-        newTranslator = JythonTranslator(self.alias, self.source_language, self.target_language)
-        newTranslator.traversal_script = self.traversal_script
-        newTranslator.traversal_script = newTranslator.traversal_script + "." + SymbolHelper.toJava(
-            step_name) + "(" + JythonTranslator.stringify(*args) + ")"
-        traversal.translator = newTranslator
+    def __internalTranslate(self, start, bytecode):
+        traversal_script = start
+        for instruction in bytecode.source_instructions:
+            traversal_script = traversal_script + "." + SymbolHelper.toJava(
+                instruction[0]) + "(" + self.stringify(*instruction[1]) + ")"
+        for instruction in bytecode.step_instructions:
+            traversal_script = traversal_script + "." + SymbolHelper.toJava(
+                instruction[0]) + "(" + self.stringify(*instruction[1]) + ")"
+        return traversal_script
 
-    def addSource(self, traversal_source, source_name, *args):
-        newTranslator = JythonTranslator(self.alias, self.source_language, self.target_language)
-        newTranslator.traversal_script = self.traversal_script
-        newTranslator.traversal_script = newTranslator.traversal_script + "." + SymbolHelper.toJava(
-            source_name) + "(" + JythonTranslator.stringify(*args) + ")"
-        traversal_source.translator = newTranslator
-
-    def getAnonymousTraversalTranslator(self):
-        return JythonTranslator("__", self.source_language, self.target_language)
-
-    @staticmethod
-    def stringOrObject(arg):
+    def stringOrObject(self, arg):
         if isinstance(arg, str):
             return "\"" + arg + "\""
         elif isinstance(arg, long):
-            return str(arg) + "L" if arg > 9223372036854775807 else "Long(" + str(arg) + ")"
+            return str(arg) + "L" if arg > 9223372036854775807L else "Long(" + str(arg) + ")"
         elif isinstance(arg, Barrier):
             return "Barrier" + "." + SymbolHelper.toJava(str(arg.name))
         elif isinstance(arg, Column):
@@ -76,11 +68,13 @@ class JythonTranslator(Translator):
             return SymbolHelper.toJava(type(arg).__name__) + "." + SymbolHelper.toJava(str(arg.name))
         elif isinstance(arg, P):
             if arg.other is None:
-                return "P." + SymbolHelper.toJava(arg.operator) + "(" + JythonTranslator.stringOrObject(
+                return "P." + SymbolHelper.toJava(arg.operator) + "(" + self.stringOrObject(
                     arg.value) + ")"
             else:
-                return JythonTranslator.stringOrObject(arg.other) + "." + SymbolHelper.toJava(
-                    arg.operator) + "(" + JythonTranslator.stringOrObject(arg.value) + ")"
+                return self.stringOrObject(arg.other) + "." + SymbolHelper.toJava(
+                    arg.operator) + "(" + self.stringOrObject(arg.value) + ")"
+        elif isinstance(arg, Bytecode):
+            return self.__internalTranslate(self.anonymous_traversal, arg)
         elif callable(arg):  # lambda that produces a string that is a lambda
             argLambdaString = arg().strip()
             argLength = len(inspect.getargspec(eval(argLambdaString)).args)
@@ -95,15 +89,14 @@ class JythonTranslator(Translator):
         elif isinstance(arg, tuple) and 2 == len(arg) and isinstance(arg[0], str):  # bindings
             return arg[0]
         elif isinstance(arg, RawExpression):
-            return "".join(JythonTranslator.stringOrObject(i) for i in arg.parts)
+            return "".join(self.stringOrObject(i) for i in arg.parts)
         else:
             return str(arg)
 
-    @staticmethod
-    def stringify(*args):
+    def stringify(self, *args):
         if len(args) == 0:
             return ""
         elif len(args) == 1:
-            return JythonTranslator.stringOrObject(args[0])
+            return self.stringOrObject(args[0])
         else:
-            return ", ".join(JythonTranslator.stringOrObject(i) for i in args)
+            return ", ".join(self.stringOrObject(i) for i in args)

goblin/gremlin_python/traversal.py → goblin/gremlin_python/process/traversal.py

@@ -16,19 +16,21 @@ KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
 '''
+from abc import abstractmethod
 from aenum import Enum
-from . import statics
+from gremlin_python import statics
 
-class PythonTraversal(object):
-    def __init__(self, translator, remote_connection=None):
-        self.translator = translator
-        self.remote_connection = remote_connection
+class Traversal(object):
+    def __init__(self, graph, traversal_strategies, bytecode):
+        self.graph = graph
+        self.traversal_strategies = traversal_strategies
+        self.bytecode = bytecode
         self.results = None
         self.last_traverser = None
         self.bindings = {}
 
     def __repr__(self):
-        return self.translator.traversal_script
+        return self.graph.translator.translate(self.bytecode)
 
     def __getitem__(self, index):
         if isinstance(index, int):
@@ -46,8 +48,7 @@ class PythonTraversal(object):
 
     def __next__(self):
         if self.results is None:
-            self.results = self.remote_connection.submit(self.translator.target_language,
-                                                         self.translator.traversal_script, self.bindings)
+            self.traversal_strategies.apply_strategies(self)
         if self.last_traverser is None:
             self.last_traverser = next(self.results)
         object = self.last_traverser.object
@@ -191,55 +192,68 @@ def _not(*args):
       return P._not(*args)
 
 statics.add_static('_not',_not)
+
 def between(*args):
       return P.between(*args)
 
 statics.add_static('between',between)
+
 def eq(*args):
       return P.eq(*args)
 
 statics.add_static('eq',eq)
+
 def gt(*args):
       return P.gt(*args)
 
 statics.add_static('gt',gt)
+
 def gte(*args):
       return P.gte(*args)
 
 statics.add_static('gte',gte)
+
 def inside(*args):
       return P.inside(*args)
 
 statics.add_static('inside',inside)
+
 def lt(*args):
       return P.lt(*args)
 
 statics.add_static('lt',lt)
+
 def lte(*args):
       return P.lte(*args)
 
 statics.add_static('lte',lte)
+
 def neq(*args):
       return P.neq(*args)
 
 statics.add_static('neq',neq)
+
 def outside(*args):
       return P.outside(*args)
 
 statics.add_static('outside',outside)
+
 def test(*args):
       return P.test(*args)
 
 statics.add_static('test',test)
+
 def within(*args):
       return P.within(*args)
 
 statics.add_static('within',within)
+
 def without(*args):
       return P.without(*args)
 
 statics.add_static('without',without)
 
+
 class RawExpression(object):
    def __init__(self, *args):
       self.bindings = dict()
@@ -258,3 +272,106 @@ class Raw(object):
 
    def __str__(self):
       return str(self.value)
+
+
+'''
+TRAVERSER
+'''
+
+class Traverser(object):
+    def __init__(self, object, bulk):
+        self.object = object
+        self.bulk = bulk
+    def __repr__(self):
+        return str(self.object)
+
+'''
+TRAVERSAL STRATEGIES
+'''
+
+class TraversalStrategies(object):
+    global_cache = {}
+
+    def __init__(self, traversal_strategies):
+        self.traversal_strategies = traversal_strategies
+        return
+
+    def apply_strategies(self, traversal):
+        for traversal_strategy in self.traversal_strategies:
+            traversal_strategy.apply(traversal)
+        return
+
+
+class TraversalStrategy(object):
+    @abstractmethod
+    def apply(self, traversal):
+        return
+
+'''
+BYTECODE AND TRANSLATOR
+'''
+
+class Bytecode(object):
+    def __init__(self, bytecode=None):
+        self.source_instructions = []
+        self.step_instructions = []
+        if bytecode is not None:
+            self.source_instructions = list(bytecode.source_instructions)
+            self.step_instructions = list(bytecode.step_instructions)
+
+    def add_source(self, source_name, *args):
+        newArgs = ()
+        for arg in args:
+            newArgs = newArgs + (Bytecode.__convertArgument(arg),)
+        self.source_instructions.append((source_name, newArgs))
+        return
+
+    def add_step(self, step_name, *args):
+        newArgs = ()
+        for arg in args:
+            newArgs = newArgs + (Bytecode.__convertArgument(arg),)
+        self.step_instructions.append((step_name, newArgs))
+        return
+
+    @staticmethod
+    def __convertArgument(arg):
+        if isinstance(arg, Traversal):
+            return arg.bytecode
+        else:
+            return arg
+
+
+TO_JAVA_MAP = {"_global": "global", "_as": "as", "_in": "in", "_and": "and",
+               "_or": "or", "_is": "is", "_not": "not", "_from": "from",
+               "Cardinality": "VertexProperty.Cardinality", "Barrier": "SackFunctions.Barrier"}
+
+
+class Translator(object):
+    def __init__(self, traversal_source, anonymous_traversal, target_language):
+        self.traversal_source = traversal_source
+        self.anonymous_traversal = anonymous_traversal
+        self.target_language = target_language
+
+    @abstractmethod
+    def translate(self, bytecode):
+        return
+
+    @abstractmethod
+    def __repr__(self):
+        return "translator[" + self.traversal_source + ":" + self.target_language + "]"
+
+
+class SymbolHelper(object):
+    @staticmethod
+    def toJava(symbol):
+        if (symbol in TO_JAVA_MAP):
+            return TO_JAVA_MAP[symbol]
+        else:
+            return symbol
+
+    @staticmethod
+    def mapEnum(enum):
+        if (enum in enumMap):
+            return enumMap[enum]
+        else:
+            return enum

goblin/gremlin_python/structure/__init__.py

+'''
+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 graph import Graph
+from remote_graph import RemoteGraph
+
+__author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'

goblin/gremlin_python/structure/graph.py

+'''
+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.
+'''
+
+__author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'
+
+from gremlin_python.process.graph_traversal import GraphTraversalSource
+from gremlin_python.process.traversal import TraversalStrategies
+
+
+class Graph(object):
+    def traversal(self):
+        return GraphTraversalSource(self, TraversalStrategies.global_cache[self.__class__])

goblin/gremlin_python/structure/remote_graph.py

+'''
+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.
+'''
+
+__author__ = 'Marko A. Rodriguez (http://markorodriguez.com)'
+
+from graph import Graph
+from gremlin_python.process.traversal import TraversalStrategies
+from gremlin_python.process.traversal import TraversalStrategy
+
+
+class RemoteGraph(Graph):
+    def __init__(self, translator, remote_connection):
+        TraversalStrategies.global_cache[self.__class__] = TraversalStrategies([RemoteStrategy()])
+        self.translator = translator
+        self.remote_connection = remote_connection
+
+    def __repr__(self):
+        return "remotegraph[" + self.remote_connection.url + "]"
+
+
+class RemoteStrategy(TraversalStrategy):
+    def apply(self, traversal):
+        if not (traversal.graph.__class__.__name__ == "RemoteGraph"):
+            raise BaseException(
+                "RemoteStrategy can only be used with a RemoteGraph: " + traversal.graph.__class__.__name__)
+        if traversal.results is None:
+            traversal.results = traversal.graph.remote_connection.submit(
+                traversal.graph.translator.target_language,  # script engine
+                traversal.graph.translator.translate(traversal.bytecode),  # script
+                traversal.bindings)  # bindings
+        return