#
# 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 logging
import sys
import copy
import warnings
from threading import Lock
from .traversal import Traversal
from .traversal import TraversalStrategies
from .strategies import VertexProgramStrategy, OptionsStrategy
from .traversal import Bytecode
from ..driver.remote_connection import RemoteStrategy
from .. import statics
from ..statics import long

log = logging.getLogger("gremlinpython")

__author__ = 'Stephen Mallette (http://stephen.genoprime.com), Lyndon Bauto (lyndonb@bitquilltech.com)'


class GraphTraversalSource(object):
    def __init__(self, graph, traversal_strategies, bytecode=None):
        log.info("Creating GraphTraversalSource.")
        self.graph = graph
        self.traversal_strategies = traversal_strategies
        if bytecode is None:
            bytecode = Bytecode()
        self.bytecode = bytecode
        self.graph_traversal = GraphTraversal
        self.remote_connection = None

    def __repr__(self):
        return "graphtraversalsource[" + str(self.graph) + "]"

    def get_graph_traversal_source(self):
        return self.__class__(self.graph, TraversalStrategies(self.traversal_strategies), Bytecode(self.bytecode))

    def get_graph_traversal(self):
        return self.graph_traversal(self.graph, self.traversal_strategies, Bytecode(self.bytecode))

    def withBulk(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.withBulk will be replaced by "
            "gremlin_python.process.GraphTraversalSource.with_bulk.",
            DeprecationWarning)
        return self.with_bulk(*args)

    def with_bulk(self, *args):
        source = self.get_graph_traversal_source()
        source.bytecode.add_source("withBulk", *args)
        return source

    def withPath(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.withPath will be replaced by "
            "gremlin_python.process.Traversal.with_path.",
            DeprecationWarning)
        return self.with_path(*args)

    def with_path(self, *args):
        source = self.get_graph_traversal_source()
        source.bytecode.add_source("withPath", *args)
        return source

    def withSack(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.withSack will be replaced by "
            "gremlin_python.process.GraphTraversalSource.with_sack.",
            DeprecationWarning)
        return self.with_sack(*args)

    def with_sack(self, *args):
        source = self.get_graph_traversal_source()
        source.bytecode.add_source("withSack", *args)
        return source

    def withSideEffect(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.with_side_effect will be replaced by "
            "gremlin_python.process.GraphTraversalSource.with_sack.",
            DeprecationWarning)
        return self.with_side_effect(*args)

    def with_side_effect(self, *args):
        source = self.get_graph_traversal_source()
        source.bytecode.add_source("withSideEffect", *args)
        return source

    def withStrategies(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.withStrategies will be replaced by "
            "gremlin_python.process.GraphTraversalSource.with_strategies.",
            DeprecationWarning)
        return self.with_strategies(*args)

    def with_strategies(self, *args):
        source = self.get_graph_traversal_source()
        source.bytecode.add_source("withStrategies", *args)
        return source

    def withoutStrategies(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.withoutStrategies will be replaced by "
            "gremlin_python.process.GraphTraversalSource.without_strategies.",
            DeprecationWarning)
        return self.without_strategies(*args)

    def without_strategies(self, *args):
        source = self.get_graph_traversal_source()
        source.bytecode.add_source("withoutStrategies", *args)
        return source

    def with_(self, k, v=None):
        source = self.get_graph_traversal_source()
        options_strategy = next((x for x in source.bytecode.source_instructions
                                 if x[0] == "withStrategies" and type(x[1]) is OptionsStrategy), None)

        val = True if v is None else v
        if options_strategy is None:
            options_strategy = OptionsStrategy({k: val})
            source = self.with_strategies(options_strategy)
        else:
            options_strategy[1].configuration[k] = val

        return source

    def withRemote(self, remote_connection):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.withRemote will be replaced by "
            "gremlin_python.process.GraphTraversalSource.with_remote.",
            DeprecationWarning)
        return self.with_remote(remote_connection)

    def with_remote(self, remote_connection):
        source = self.get_graph_traversal_source()
        source.traversal_strategies.add_strategies([RemoteStrategy(remote_connection)])
        self.remote_connection = remote_connection
        return source

    def tx(self):
        # In order to keep the constructor unchanged within 3.5.x we can try to pop the RemoteConnection out of the
        # TraversalStrategies. keeping this unchanged will allow user DSLs to not take a break.
        # This is the same strategy as gremlin-javascript.
        # TODO https://issues.apache.org/jira/browse/TINKERPOP-2664: refactor this to be nicer in 3.6.0 when
        #  we can take a breaking change
        remote_connection = next((x.remote_connection for x in self.traversal_strategies.traversal_strategies if
                                  x.fqcn == "py:RemoteStrategy"), None)

        if remote_connection is None:
            raise Exception("Error, remote connection is required for transaction.")

        # You can't do g.tx().begin().tx() i.e child transactions are not supported.
        if remote_connection and remote_connection.is_session_bound():
            raise Exception("This TraversalSource is already bound to a transaction - child transactions are not "
                            "supported")
        return Transaction(self, remote_connection)

    def withComputer(self, graph_computer=None, workers=None, result=None, persist=None, vertices=None,
                     edges=None, configuration=None):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.withComputer will be replaced by "
            "gremlin_python.process.GraphTraversalSource.with_computer.",
            DeprecationWarning)
        return self.with_computer(graph_computer, workers, result, persist, vertices, edges, configuration)

    def with_computer(self, graph_computer=None, workers=None, result=None, persist=None, vertices=None,
                  edges=None, configuration=None):
        return self.with_strategies(
            VertexProgramStrategy(graph_computer, workers, result, persist, vertices, edges, configuration))

    def E(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("E", *args)
        return traversal

    def V(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("V", *args)
        return traversal

    def addE(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.addE will be replaced by "
            "gremlin_python.process.GraphTraversalSource.add_e.",
            DeprecationWarning)
        return self.add_e(*args)

    def add_e(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("addE", *args)
        return traversal

    def addV(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.addV will be replaced by "
            "gremlin_python.process.GraphTraversalSource.add_v.",
            DeprecationWarning)
        return self.add_v(*args)

    def add_v(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("addV", *args)
        return traversal

    def merge_v(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("mergeV", *args)
        return traversal

    def merge_e(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("mergeE", *args)
        return traversal

    def inject(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("inject", *args)
        return traversal

    def io(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("io", *args)
        return traversal

    def call(self, *args):
        traversal = self.get_graph_traversal()
        traversal.bytecode.add_step("call", *args)
        return traversal


class GraphTraversal(Traversal):
    def __init__(self, graph, traversal_strategies, bytecode):
        super(GraphTraversal, self).__init__(graph, traversal_strategies, bytecode)

    def __getitem__(self, index):
        if isinstance(index, int):
            return self.range_(long(index), long(index + 1))
        elif isinstance(index, slice):
            low = long(0) if index.start is None else long(index.start)
            high = long(sys.maxsize) if index.stop is None else long(index.stop)
            if low == long(0):
                return self.limit(high)
            else:
                return self.range_(low, high)
        else:
            raise TypeError("Index must be int or slice")

    def __getattr__(self, key):
        if key.startswith('__'):
            raise AttributeError(
                'Python magic methods or keys starting with double underscore cannot be used for Gremlin sugar - prefer values(' + key + ')')
        return self.values(key)

    def clone(self):
        return GraphTraversal(self.graph, self.traversal_strategies, copy.deepcopy(self.bytecode))

    def V(self, *args):
        self.bytecode.add_step("V", *args)
        return self

    def addE(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversal.addE will be replaced by "
            "gremlin_python.process.GraphTraversal.add_e.",
            DeprecationWarning)
        return self.add_e(*args)

    def add_e(self, *args):
        self.bytecode.add_step("addE", *args)
        return self

    def addV(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.addV will be replaced by "
            "gremlin_python.process.GraphTraversalSource.add_v.",
            DeprecationWarning)
        return self.add_v(*args)

    def add_v(self, *args):
        self.bytecode.add_step("addV", *args)
        return self

    def aggregate(self, *args):
        self.bytecode.add_step("aggregate", *args)
        return self

    def and_(self, *args):
        self.bytecode.add_step("and", *args)
        return self

    def as_(self, *args):
        self.bytecode.add_step("as", *args)
        return self

    def barrier(self, *args):
        self.bytecode.add_step("barrier", *args)
        return self

    def both(self, *args):
        self.bytecode.add_step("both", *args)
        return self

    def bothE(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.bothE will be replaced by "
            "gremlin_python.process.GraphTraversalSource.both_e.",
            DeprecationWarning)
        return self.both_e(*args)

    def both_e(self, *args):
        self.bytecode.add_step("bothE", *args)
        return self

    def bothV(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.bothV will be replaced by "
            "gremlin_python.process.GraphTraversalSource.both_v.",
            DeprecationWarning)
        return self.both_v(*args)

    def both_v(self, *args):
        self.bytecode.add_step("bothV", *args)
        return self

    def branch(self, *args):
        self.bytecode.add_step("branch", *args)
        return self

    def by(self, *args):
        self.bytecode.add_step("by", *args)
        return self

    def call(self, *args):
        self.bytecode.add_step("call", *args)
        return self

    def cap(self, *args):
        self.bytecode.add_step("cap", *args)
        return self

    def choose(self, *args):
        self.bytecode.add_step("choose", *args)
        return self

    def coalesce(self, *args):
        self.bytecode.add_step("coalesce", *args)
        return self

    def coin(self, *args):
        self.bytecode.add_step("coin", *args)
        return self

    def connectedComponent(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.connectedComponent will be replaced by "
            "gremlin_python.process.GraphTraversalSource.connected_component.",
            DeprecationWarning)
        return self.connected_component(*args)

    def connected_component(self, *args):
        self.bytecode.add_step("connectedComponent", *args)
        return self

    def constant(self, *args):
        self.bytecode.add_step("constant", *args)
        return self

    def count(self, *args):
        self.bytecode.add_step("count", *args)
        return self

    def cyclicPath(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.cyclicPath will be replaced by "
            "gremlin_python.process.GraphTraversalSource.cyclic_path.",
            DeprecationWarning)
        return self.cyclic_path(*args)

    def cyclic_path(self, *args):
        self.bytecode.add_step("cyclicPath", *args)
        return self

    def dedup(self, *args):
        self.bytecode.add_step("dedup", *args)
        return self

    def drop(self, *args):
        self.bytecode.add_step("drop", *args)
        return self

    def element(self, *args):
        self.bytecode.add_step("element", *args)
        return self

    def elementMap(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.elementMap will be replaced by "
            "gremlin_python.process.GraphTraversalSource.element_map.",
            DeprecationWarning)
        return self.element_map(*args)

    def element_map(self, *args):
        self.bytecode.add_step("elementMap", *args)
        return self

    def emit(self, *args):
        self.bytecode.add_step("emit", *args)
        return self

    def fail(self, *args):
        self.bytecode.add_step("fail", *args)
        return self

    def filter_(self, *args):
        self.bytecode.add_step("filter", *args)
        return self

    def flatMap(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.flatMap will be replaced by "
            "gremlin_python.process.GraphTraversalSource.flat_map.",
            DeprecationWarning)
        return self.flat_map(*args)

    def flat_map(self, *args):
        self.bytecode.add_step("flatMap", *args)
        return self

    def fold(self, *args):
        self.bytecode.add_step("fold", *args)
        return self

    def from_(self, *args):
        self.bytecode.add_step("from", *args)
        return self

    def group(self, *args):
        self.bytecode.add_step("group", *args)
        return self

    def groupCount(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.groupCount will be replaced by "
            "gremlin_python.process.GraphTraversalSource.group_count.",
            DeprecationWarning)
        return self.group_count(*args)

    def group_count(self, *args):
        self.bytecode.add_step("groupCount", *args)
        return self

    def has(self, *args):
        self.bytecode.add_step("has", *args)
        return self

    def hasId(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.hasId will be replaced by "
            "gremlin_python.process.GraphTraversalSource.has_id.",
            DeprecationWarning)
        return self.has_id(*args)

    def has_id(self, *args):
        self.bytecode.add_step("hasId", *args)
        return self

    def hasKey(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.hasKey will be replaced by "
            "gremlin_python.process.GraphTraversalSource.has_key.",
            DeprecationWarning)
        return self.has_key_(*args)

    def has_key_(self, *args):
        self.bytecode.add_step("hasKey", *args)
        return self

    def hasLabel(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.hasLabel will be replaced by "
            "gremlin_python.process.GraphTraversalSource.has_label.",
            DeprecationWarning)
        return self.has_label(*args)

    def has_label(self, *args):
        self.bytecode.add_step("hasLabel", *args)
        return self

    def hasNot(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.hasNot will be replaced by "
            "gremlin_python.process.GraphTraversalSource.has_not.",
            DeprecationWarning)
        return self.has_not(*args)

    def has_not(self, *args):
        self.bytecode.add_step("hasNot", *args)
        return self

    def hasValue(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.hasValue will be replaced by "
            "gremlin_python.process.GraphTraversalSource.has_value.",
            DeprecationWarning)
        return self.has_value(*args)

    def has_value(self, *args):
        self.bytecode.add_step("hasValue", *args)
        return self

    def id_(self, *args):
        self.bytecode.add_step("id", *args)
        return self

    def identity(self, *args):
        self.bytecode.add_step("identity", *args)
        return self

    def inE(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.inE will be replaced by "
            "gremlin_python.process.GraphTraversalSource.in_e.",
            DeprecationWarning)
        return self.in_e(*args)

    def in_e(self, *args):
        self.bytecode.add_step("inE", *args)
        return self

    def inV(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.inV will be replaced by "
            "gremlin_python.process.GraphTraversalSource.in_v.",
            DeprecationWarning)
        return self.in_v(*args)

    def in_v(self, *args):
        self.bytecode.add_step("inV", *args)
        return self

    def in_(self, *args):
        self.bytecode.add_step("in", *args)
        return self

    def index(self, *args):
        self.bytecode.add_step("index", *args)
        return self

    def inject(self, *args):
        self.bytecode.add_step("inject", *args)
        return self

    def is_(self, *args):
        self.bytecode.add_step("is", *args)
        return self

    def key(self, *args):
        self.bytecode.add_step("key", *args)
        return self

    def label(self, *args):
        self.bytecode.add_step("label", *args)
        return self

    def limit(self, *args):
        self.bytecode.add_step("limit", *args)
        return self

    def local(self, *args):
        self.bytecode.add_step("local", *args)
        return self

    def loops(self, *args):
        self.bytecode.add_step("loops", *args)
        return self

    def map(self, *args):
        self.bytecode.add_step("map", *args)
        return self

    def match(self, *args):
        self.bytecode.add_step("match", *args)
        return self

    def math(self, *args):
        self.bytecode.add_step("math", *args)
        return self

    def max_(self, *args):
        self.bytecode.add_step("max", *args)
        return self

    def mean(self, *args):
        self.bytecode.add_step("mean", *args)
        return self

    def merge_e(self, *args):
        self.bytecode.add_step("mergeE", *args)
        return self

    def merge_v(self, *args):
        self.bytecode.add_step("mergeV", *args)
        return self

    def min_(self, *args):
        self.bytecode.add_step("min", *args)
        return self

    def none(self, *args):
        self.bytecode.add_step("none", *args)
        return self

    def not_(self, *args):
        self.bytecode.add_step("not", *args)
        return self

    def option(self, *args):
        self.bytecode.add_step("option", *args)
        return self

    def optional(self, *args):
        self.bytecode.add_step("optional", *args)
        return self

    def or_(self, *args):
        self.bytecode.add_step("or", *args)
        return self

    def order(self, *args):
        self.bytecode.add_step("order", *args)
        return self

    def otherV(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.otherV will be replaced by "
            "gremlin_python.process.GraphTraversalSource.other_v.",
            DeprecationWarning)
        return self.other_v(*args)

    def other_v(self, *args):
        self.bytecode.add_step("otherV", *args)
        return self

    def out(self, *args):
        self.bytecode.add_step("out", *args)
        return self

    def outE(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.outE will be replaced by "
            "gremlin_python.process.GraphTraversalSource.out_e.",
            DeprecationWarning)
        return self.out_e(*args)

    def out_e(self, *args):
        self.bytecode.add_step("outE", *args)
        return self

    def outV(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.outV will be replaced by "
            "gremlin_python.process.GraphTraversalSource.out_v.",
            DeprecationWarning)
        return self.out_v(*args)

    def out_v(self, *args):
        self.bytecode.add_step("outV", *args)
        return self

    def pageRank(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.pageRank will be replaced by "
            "gremlin_python.process.GraphTraversalSource.page_rank.",
            DeprecationWarning)
        return self.page_rank(*args)

    def page_rank(self, *args):
        self.bytecode.add_step("pageRank", *args)
        return self

    def path(self, *args):
        self.bytecode.add_step("path", *args)
        return self

    def peerPressure(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.peerPressure will be replaced by "
            "gremlin_python.process.GraphTraversalSource.peer_pressure.",
            DeprecationWarning)
        return self.peer_pressure(*args)

    def peer_pressure(self, *args):
        self.bytecode.add_step("peerPressure", *args)
        return self

    def profile(self, *args):
        self.bytecode.add_step("profile", *args)
        return self

    def program(self, *args):
        self.bytecode.add_step("program", *args)
        return self

    def project(self, *args):
        self.bytecode.add_step("project", *args)
        return self

    def properties(self, *args):
        self.bytecode.add_step("properties", *args)
        return self

    def property(self, *args):
        self.bytecode.add_step("property", *args)
        return self

    def propertyMap(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.propertyMap will be replaced by "
            "gremlin_python.process.GraphTraversalSource.property_map.",
            DeprecationWarning)
        return self.property_map(*args)

    def property_map(self, *args):
        self.bytecode.add_step("propertyMap", *args)
        return self

    def range_(self, *args):
        self.bytecode.add_step("range", *args)
        return self

    def read(self, *args):
        self.bytecode.add_step("read", *args)
        return self

    def repeat(self, *args):
        self.bytecode.add_step("repeat", *args)
        return self

    def sack(self, *args):
        self.bytecode.add_step("sack", *args)
        return self

    def sample(self, *args):
        self.bytecode.add_step("sample", *args)
        return self

    def select(self, *args):
        self.bytecode.add_step("select", *args)
        return self

    def shortestPath(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.shortestPath will be replaced by "
            "gremlin_python.process.GraphTraversalSource.shortest_path.",
            DeprecationWarning)
        return self.shortest_path(*args)

    def shortest_path(self, *args):
        self.bytecode.add_step("shortestPath", *args)
        return self

    def sideEffect(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.sideEffect will be replaced by "
            "gremlin_python.process.GraphTraversalSource.side_effect.",
            DeprecationWarning)
        return self.side_effect(*args)

    def side_effect(self, *args):
        self.bytecode.add_step("sideEffect", *args)
        return self

    def simplePath(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.simplePath will be replaced by "
            "gremlin_python.process.GraphTraversalSource.simple_path.",
            DeprecationWarning)
        return self.simple_path(*args)

    def simple_path(self, *args):
        self.bytecode.add_step("simplePath", *args)
        return self

    def skip(self, *args):
        self.bytecode.add_step("skip", *args)
        return self

    def store(self, *args):
        self.bytecode.add_step("store", *args)
        return self

    def subgraph(self, *args):
        self.bytecode.add_step("subgraph", *args)
        return self

    def sum_(self, *args):
        self.bytecode.add_step("sum", *args)
        return self

    def tail(self, *args):
        self.bytecode.add_step("tail", *args)
        return self

    def timeLimit(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.timeLimit will be replaced by "
            "gremlin_python.process.GraphTraversalSource.time_limit.",
            DeprecationWarning)
        return self.time_limit(*args)

    def time_limit(self, *args):
        self.bytecode.add_step("timeLimit", *args)
        return self

    def times(self, *args):
        self.bytecode.add_step("times", *args)
        return self

    def to(self, *args):
        self.bytecode.add_step("to", *args)
        return self

    def toE(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.toE will be replaced by "
            "gremlin_python.process.GraphTraversalSource.to_e.",
            DeprecationWarning)
        return self.to_e(*args)

    def to_e(self, *args):
        self.bytecode.add_step("toE", *args)
        return self

    def toV(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.toV will be replaced by "
            "gremlin_python.process.GraphTraversalSource.to_v.",
            DeprecationWarning)
        return self.to_v(*args)

    def to_v(self, *args):
        self.bytecode.add_step("toV", *args)
        return self

    def tree(self, *args):
        self.bytecode.add_step("tree", *args)
        return self

    def unfold(self, *args):
        self.bytecode.add_step("unfold", *args)
        return self

    def union(self, *args):
        self.bytecode.add_step("union", *args)
        return self

    def until(self, *args):
        self.bytecode.add_step("until", *args)
        return self

    def value(self, *args):
        self.bytecode.add_step("value", *args)
        return self

    def valueMap(self, *args):
        warnings.warn(
            "gremlin_python.process.GraphTraversalSource.valueMap will be replaced by "
            "gremlin_python.process.GraphTraversalSource.value_map.",
            DeprecationWarning)
        return self.value_map(*args)

    def value_map(self, *args):
        self.bytecode.add_step("valueMap", *args)
        return self

    def values(self, *args):
        self.bytecode.add_step("values", *args)
        return self

    def where(self, *args):
        self.bytecode.add_step("where", *args)
        return self

    def with_(self, *args):
        self.bytecode.add_step("with", *args)
        return self

    def write(self, *args):
        self.bytecode.add_step("write", *args)
        return self


class MagicType(type):

    def __getattr__(cls, k):
        if k.startswith('__'):
            raise AttributeError(
                'Python magic methods or keys starting with double underscore cannot be used for Gremlin sugar - prefer values(' + k + ')')
        return __.values(k)


class __(object, metaclass=MagicType):
    graph_traversal = GraphTraversal

    @classmethod
    def start(cls):
        return GraphTraversal(None, None, Bytecode())

    @classmethod
    def __(cls, *args):
        return __.inject(*args)

    @classmethod
    def V(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).V(*args)

    @classmethod
    def addE(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.addE will be replaced by "
            "gremlin_python.process.__.add_e.",
            DeprecationWarning)
        return cls.add_e(*args)

    @classmethod
    def add_e(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).add_e(*args)

    @classmethod
    def addV(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.addV will be replaced by "
            "gremlin_python.process.__.add_v.",
            DeprecationWarning)
        return cls.add_v(*args)

    @classmethod
    def add_v(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).add_v(*args)

    @classmethod
    def aggregate(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).aggregate(*args)

    @classmethod
    def and_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).and_(*args)

    @classmethod
    def as_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).as_(*args)

    @classmethod
    def barrier(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).barrier(*args)

    @classmethod
    def both(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).both(*args)

    @classmethod
    def bothE(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.bothE will be replaced by "
            "gremlin_python.process.__.both_e.",
            DeprecationWarning)
        return cls.both_e(*args)

    @classmethod
    def both_e(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).both_e(*args)

    @classmethod
    def bothV(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.bothV will be replaced by "
            "gremlin_python.process.__.both_v.",
            DeprecationWarning)
        return cls.both_v(*args)

    @classmethod
    def both_v(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).both_v(*args)

    @classmethod
    def branch(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).branch(*args)

    @classmethod
    def call(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).call(*args)

    @classmethod
    def cap(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).cap(*args)

    @classmethod
    def choose(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).choose(*args)

    @classmethod
    def coalesce(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).coalesce(*args)

    @classmethod
    def coin(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).coin(*args)

    @classmethod
    def constant(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).constant(*args)

    @classmethod
    def count(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).count(*args)

    @classmethod
    def cyclicPath(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.cyclicPath will be replaced by "
            "gremlin_python.process.__.cyclic_path.",
            DeprecationWarning)
        return cls.cyclic_path(*args)

    @classmethod
    def cyclic_path(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).cyclic_path(*args)

    @classmethod
    def dedup(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).dedup(*args)

    @classmethod
    def drop(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).drop(*args)

    @classmethod
    def element(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).element(*args)

    @classmethod
    def elementMap(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.elementMap will be replaced by "
            "gremlin_python.process.__.element_map.",
            DeprecationWarning)
        return cls.element_map(*args)

    @classmethod
    def element_map(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).element_map(*args)

    @classmethod
    def emit(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).emit(*args)

    @classmethod
    def fail(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).fail(*args)

    @classmethod
    def filter_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).filter_(*args)

    @classmethod
    def flatMap(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.flatMap will be replaced by "
            "gremlin_python.process.__.flat_map.",
            DeprecationWarning)
        return cls.flat_map(*args)

    @classmethod
    def flat_map(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).flat_map(*args)

    @classmethod
    def fold(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).fold(*args)

    @classmethod
    def group(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).group(*args)

    @classmethod
    def groupCount(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.groupCount will be replaced by "
            "gremlin_python.process.__.group_count.",
            DeprecationWarning)
        return cls.group_count(*args)

    @classmethod
    def group_count(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).group_count(*args)

    @classmethod
    def has(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).has(*args)

    @classmethod
    def hasId(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.hasId will be replaced by "
            "gremlin_python.process.__.has_id.",
            DeprecationWarning)
        return cls.has_id(*args)

    @classmethod
    def has_id(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).has_id(*args)

    @classmethod
    def hasKey(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.hasKey will be replaced by "
            "gremlin_python.process.__.has_key.",
            DeprecationWarning)
        return cls.has_key_(*args)

    @classmethod
    def has_key_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).has_key_(*args)

    @classmethod
    def hasLabel(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.hasLabel will be replaced by "
            "gremlin_python.process.__.has_label.",
            DeprecationWarning)
        return cls.has_label(*args)

    @classmethod
    def has_label(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).has_label(*args)

    @classmethod
    def hasNot(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.hasNot will be replaced by "
            "gremlin_python.process.__.has_not.",
            DeprecationWarning)
        return cls.has_not(*args)

    @classmethod
    def has_not(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).has_not(*args)

    @classmethod
    def hasValue(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.hasValue will be replaced by "
            "gremlin_python.process.__.has_value.",
            DeprecationWarning)
        return cls.has_value(*args)

    @classmethod
    def has_value(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).has_value(*args)

    @classmethod
    def id_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).id_(*args)

    @classmethod
    def identity(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).identity(*args)

    @classmethod
    def inE(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.inE will be replaced by "
            "gremlin_python.process.__.in_e.",
            DeprecationWarning)
        return cls.in_e(*args)

    @classmethod
    def in_e(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).in_e(*args)

    @classmethod
    def inV(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.inV will be replaced by "
            "gremlin_python.process.__.in_v.",
            DeprecationWarning)
        return cls.in_v(*args)

    @classmethod
    def in_v(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).in_v(*args)

    @classmethod
    def in_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).in_(*args)

    @classmethod
    def index(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).index(*args)

    @classmethod
    def inject(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).inject(*args)

    @classmethod
    def is_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).is_(*args)

    @classmethod
    def key(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).key(*args)

    @classmethod
    def label(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).label(*args)

    @classmethod
    def limit(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).limit(*args)

    @classmethod
    def local(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).local(*args)

    @classmethod
    def loops(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).loops(*args)

    @classmethod
    def map(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).map(*args)

    @classmethod
    def match(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).match(*args)

    @classmethod
    def math(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).math(*args)

    @classmethod
    def max_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).max_(*args)

    @classmethod
    def mean(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).mean(*args)

    @classmethod
    def merge_e(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).merge_e(*args)

    @classmethod
    def merge_v(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).merge_v(*args)

    @classmethod
    def min_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).min_(*args)

    @classmethod
    def not_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).not_(*args)

    @classmethod
    def optional(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).optional(*args)

    @classmethod
    def or_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).or_(*args)

    @classmethod
    def order(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).order(*args)

    @classmethod
    def otherV(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.otherV will be replaced by "
            "gremlin_python.process.__.other_v.",
            DeprecationWarning)
        return cls.other_v(*args)

    @classmethod
    def other_v(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).other_v(*args)

    @classmethod
    def out(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).out(*args)

    @classmethod
    def outE(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.outE will be replaced by "
            "gremlin_python.process.__.out_e.",
            DeprecationWarning)
        return cls.out_e(*args)

    @classmethod
    def out_e(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).out_e(*args)

    @classmethod
    def outV(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.outV will be replaced by "
            "gremlin_python.process.__.out_v.",
            DeprecationWarning)
        return cls.out_v(*args)

    @classmethod
    def out_v(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).out_v(*args)

    @classmethod
    def path(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).path(*args)

    @classmethod
    def project(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).project(*args)

    @classmethod
    def properties(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).properties(*args)

    @classmethod
    def property(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).property(*args)

    @classmethod
    def propertyMap(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.propertyMap will be replaced by "
            "gremlin_python.process.__.property_map.",
            DeprecationWarning)
        return cls.property_map(*args)

    @classmethod
    def property_map(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).property_map(*args)

    @classmethod
    def range_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).range_(*args)

    @classmethod
    def repeat(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).repeat(*args)

    @classmethod
    def sack(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).sack(*args)

    @classmethod
    def sample(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).sample(*args)

    @classmethod
    def select(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).select(*args)

    @classmethod
    def sideEffect(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.sideEffect will be replaced by "
            "gremlin_python.process.__.side_effect.",
            DeprecationWarning)
        return cls.side_effect(*args)

    @classmethod
    def side_effect(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).side_effect(*args)

    @classmethod
    def simplePath(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.simplePath will be replaced by "
            "gremlin_python.process.__.simple_path.",
            DeprecationWarning)
        return cls.simple_path(*args)

    @classmethod
    def simple_path(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).simple_path(*args)

    @classmethod
    def skip(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).skip(*args)

    @classmethod
    def store(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).store(*args)

    @classmethod
    def subgraph(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).subgraph(*args)

    @classmethod
    def sum_(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).sum_(*args)

    @classmethod
    def tail(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).tail(*args)

    @classmethod
    def timeLimit(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.timeLimit will be replaced by "
            "gremlin_python.process.__.time_limit.",
            DeprecationWarning)
        return cls.time_limit(*args)

    @classmethod
    def time_limit(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).time_limit(*args)

    @classmethod
    def times(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).times(*args)

    @classmethod
    def to(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).to(*args)

    @classmethod
    def toE(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.toE will be replaced by "
            "gremlin_python.process.__.to_e.",
            DeprecationWarning)
        return cls.to_e(*args)

    @classmethod
    def to_e(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).to_e(*args)

    @classmethod
    def toV(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.toV will be replaced by "
            "gremlin_python.process.__.to_v.",
            DeprecationWarning)
        return cls.to_v(*args)

    @classmethod
    def to_v(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).to_v(*args)

    @classmethod
    def tree(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).tree(*args)

    @classmethod
    def unfold(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).unfold(*args)

    @classmethod
    def union(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).union(*args)

    @classmethod
    def until(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).until(*args)

    @classmethod
    def value(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).value(*args)

    @classmethod
    def valueMap(cls, *args):
        warnings.warn(
            "gremlin_python.process.__.valueMap will be replaced by "
            "gremlin_python.process.__.value_map.",
            DeprecationWarning)
        return cls.value_map(*args)

    @classmethod
    def value_map(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).value_map(*args)

    @classmethod
    def values(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).values(*args)

    @classmethod
    def where(cls, *args):
        return cls.graph_traversal(None, None, Bytecode()).where(*args)


# Class to handle transactions.
class Transaction:

    def __init__(self, g, remote_connection):
        self._g = g
        self._session_based_connection = None
        self._remote_connection = remote_connection
        self.__is_open = False
        self.__mutex = Lock()

    # Begins transaction.
    def begin(self):
        with self.__mutex:
            # Verify transaction is not open.
            self.__verify_transaction_state(False, "Transaction already started on this object")

            # Create new session using the remote connection.
            self._session_based_connection = self._remote_connection.create_session()
            self.__is_open = True

            # Set the session as a remote strategy within the traversal strategy.
            traversal_strategy = TraversalStrategies()
            traversal_strategy.add_strategies([RemoteStrategy(self._session_based_connection)])

            # Return new GraphTraversalSource.
            return GraphTraversalSource(self._g.graph, traversal_strategy, self._g.bytecode)

    # Rolls transaction back.
    def rollback(self):
        with self.__mutex:
            # Verify transaction is open, close session and return result of transaction's rollback.
            self.__verify_transaction_state(True, "Cannot commit a transaction that is not started.")
            return self.__close_session(self._session_based_connection.rollback())

    # Commits the current transaction.
    def commit(self):
        with self.__mutex:
            # Verify transaction is open, close session and return result of transaction's commit.
            self.__verify_transaction_state(True, "Cannot commit a transaction that is not started.")
            return self.__close_session(self._session_based_connection.commit())

    # Closes session.
    def close(self):
        with self.__mutex:
            # Verify transaction is open.
            self.__verify_transaction_state(True, "Cannot close a transaction that has previously been closed.")
            self.__close_session(None)

    # Return whether or not transaction is open.
    # Allow camelcase function here to keep api consistent with other languages.
    def isOpen(self):
        warnings.warn(
            "gremlin_python.process.Transaction.isOpen will be replaced by "
            "gremlin_python.process.Transaction.is_open.",
            DeprecationWarning)
        return self.is_open()

    def is_open(self):
        # if the underlying DriverRemoteConnection is closed then the Transaction can't be open
        if (self._session_based_connection and self._session_based_connection.is_closed()) or \
                self._remote_connection.is_closed():
            self.__is_open = False

        return self.__is_open

    def __verify_transaction_state(self, state, error_message):
        if self.__is_open != state:
            raise Exception(error_message)

    def __close_session(self, session):
        self.__is_open = False
        self._remote_connection.remove_session(self._session_based_connection)
        return session


def V(*args):
    return __.V(*args)


def addE(*args):
    return __.add_e(*args)


def add_e(*args):
    return __.add_e(*args)


def addV(*args):
    return __.add_v(*args)


def add_v(*args):
    return __.add_v(*args)


def aggregate(*args):
    return __.aggregate(*args)


def and_(*args):
    return __.and_(*args)


def as_(*args):
    return __.as_(*args)


def barrier(*args):
    return __.barrier(*args)


def both(*args):
    return __.both(*args)


def bothE(*args):
    return __.both_e(*args)


def both_e(*args):
    return __.both_e(*args)


def bothV(*args):
    return __.both_v(*args)


def both_v(*args):
    return __.both_v(*args)


def branch(*args):
    return __.branch(*args)


def call(*args):
    return __.call(*args)


def cap(*args):
    return __.cap(*args)


def choose(*args):
    return __.choose(*args)


def coalesce(*args):
    return __.coalesce(*args)


def coin(*args):
    return __.coin(*args)


def constant(*args):
    return __.constant(*args)


def count(*args):
    return __.count(*args)


def cyclicPath(*args):
    return __.cyclic_path(*args)


def cyclic_path(*args):
    return __.cyclic_path(*args)


def dedup(*args):
    return __.dedup(*args)


def drop(*args):
    return __.drop(*args)


def element(*args):
    return __.element(*args)


def elementMap(*args):
    return __.element_map(*args)


def element_map(*args):
    return __.element_map(*args)


def emit(*args):
    return __.emit(*args)


def fail(*args):
    return __.fail(*args)


def filter_(*args):
    return __.filter_(*args)


def flatMap(*args):
    return __.flat_map(*args)


def flat_map(*args):
    return __.flat_map(*args)


def fold(*args):
    return __.fold(*args)


def group(*args):
    return __.group(*args)


def groupCount(*args):
    return __.group_count(*args)


def group_count(*args):
    return __.group_count(*args)


def has(*args):
    return __.has(*args)


def hasId(*args):
    return __.has_id(*args)


def has_id(*args):
    return __.has_id(*args)


def hasKey(*args):
    return __.has_key_(*args)


def has_key_(*args):
    return __.has_key_(*args)


def hasLabel(*args):
    return __.has_label(*args)


def has_label(*args):
    return __.has_label(*args)


def hasNot(*args):
    return __.has_not(*args)


def has_not(*args):
    return __.has_not(*args)


def hasValue(*args):
    return __.has_value(*args)


def has_value(*args):
    return __.has_value(*args)


def id_(*args):
    return __.id_(*args)


def identity(*args):
    return __.identity(*args)


def inE(*args):
    return __.in_e(*args)


def in_e(*args):
    return __.in_e(*args)


def inV(*args):
    return __.in_v(*args)


def in_v(*args):
    return __.in_v(*args)


def in_(*args):
    return __.in_(*args)


def index(*args):
    return __.index(*args)


def inject(*args):
    return __.inject(*args)


def is_(*args):
    return __.is_(*args)


def key(*args):
    return __.key(*args)


def label(*args):
    return __.label(*args)


def limit(*args):
    return __.limit(*args)


def local(*args):
    return __.local(*args)


def loops(*args):
    return __.loops(*args)


def map(*args):
    return __.map(*args)


def match(*args):
    return __.match(*args)


def math(*args):
    return __.math(*args)


def max_(*args):
    return __.max_(*args)


def mean(*args):
    return __.mean(*args)


def merge_e(*args):
    return __.merge_e(*args)


def merge_v(*args):
    return __.merge_v(*args)


def min_(*args):
    return __.min_(*args)


def not_(*args):
    return __.not_(*args)


def optional(*args):
    return __.optional(*args)


def or_(*args):
    return __.or_(*args)


def order(*args):
    return __.order(*args)


def otherV(*args):
    return __.other_v(*args)


def other_v(*args):
    return __.other_v(*args)


def out(*args):
    return __.out(*args)


def outE(*args):
    return __.out_e(*args)


def out_e(*args):
    return __.out_e(*args)


def outV(*args):
    return __.out_v(*args)


def out_v(*args):
    return __.out_v(*args)


def path(*args):
    return __.path(*args)


def project(*args):
    return __.project(*args)


def properties(*args):
    return __.properties(*args)


def property(*args):
    return __.property(*args)


def propertyMap(*args):
    return __.property_map(*args)


def property_map(*args):
    return __.property_map(*args)


def range_(*args):
    return __.range_(*args)


def repeat(*args):
    return __.repeat(*args)


def sack(*args):
    return __.sack(*args)


def sample(*args):
    return __.sample(*args)


def select(*args):
    return __.select(*args)


def sideEffect(*args):
    return __.side_effect(*args)


def side_effect(*args):
    return __.side_effect(*args)


def simplePath(*args):
    return __.simple_path(*args)


def simple_path(*args):
    return __.simple_path(*args)


def skip(*args):
    return __.skip(*args)


def store(*args):
    return __.store(*args)


def subgraph(*args):
    return __.subgraph(*args)


def sum_(*args):
    return __.sum_(*args)


def tail(*args):
    return __.tail(*args)


def timeLimit(*args):
    return __.time_limit(*args)


def time_limit(*args):
    return __.time_limit(*args)


def times(*args):
    return __.times(*args)


def to(*args):
    return __.to(*args)


def toE(*args):
    return __.to_e(*args)


def to_e(*args):
    return __.to_e(*args)


def toV(*args):
    return __.to_v(*args)


def to_v(*args):
    return __.to_v(*args)


def tree(*args):
    return __.tree(*args)


def unfold(*args):
    return __.unfold(*args)


def union(*args):
    return __.union(*args)


def until(*args):
    return __.until(*args)


def value(*args):
    return __.value(*args)


def valueMap(*args):
    return __.value_map(*args)


def value_map(*args):
    return __.value_map(*args)


def values(*args):
    return __.values(*args)


def where(*args):
    return __.where(*args)


statics.add_static('V', V)

statics.add_static('addE', addE)

statics.add_static('add_E', add_e)

statics.add_static('addV', addV)

statics.add_static('add_v', add_v)

statics.add_static('aggregate', aggregate)

statics.add_static('and_', and_)

statics.add_static('as_', as_)

statics.add_static('barrier', barrier)

statics.add_static('both', both)

statics.add_static('bothE', bothE)

statics.add_static('both_e', both_e)

statics.add_static('bothV', bothV)

statics.add_static('both_v', both_v)

statics.add_static('branch', branch)

statics.add_static('call', call)

statics.add_static('cap', cap)

statics.add_static('choose', choose)

statics.add_static('coalesce', coalesce)

statics.add_static('coin', coin)

statics.add_static('constant', constant)

statics.add_static('count', count)

statics.add_static('cyclicPath', cyclicPath)

statics.add_static('cyclicpath', cyclic_path)

statics.add_static('dedup', dedup)

statics.add_static('drop', drop)

statics.add_static('element', element)

statics.add_static('elementMap', elementMap)

statics.add_static('element_map', element_map)

statics.add_static('emit', emit)

statics.add_static('fail', fail)

statics.add_static('filter_', filter_)

statics.add_static('flatMap', flatMap)

statics.add_static('flat_map', flat_map)

statics.add_static('fold', fold)

statics.add_static('group', group)

statics.add_static('groupCount', groupCount)

statics.add_static('group_count', group_count)

statics.add_static('has', has)

statics.add_static('hasId', hasId)

statics.add_static('has_id', has_id)

statics.add_static('hasKey', hasKey)

statics.add_static('has_key', has_key_)

statics.add_static('hasLabel', hasLabel)

statics.add_static('has_label', has_label)

statics.add_static('hasNot', hasNot)

statics.add_static('has_not', has_not)

statics.add_static('hasValue', hasValue)

statics.add_static('has_value', has_value)

statics.add_static('id_', id_)

statics.add_static('identity', identity)

statics.add_static('inE', inE)

statics.add_static('in_e', in_e)

statics.add_static('in_v', in_v)

statics.add_static('in_', in_)

statics.add_static('index', index)

statics.add_static('inject', inject)

statics.add_static('is_', is_)

statics.add_static('key', key)

statics.add_static('label', label)

statics.add_static('limit', limit)

statics.add_static('local', local)

statics.add_static('loops', loops)

statics.add_static('map', map)

statics.add_static('match', match)

statics.add_static('math', math)

statics.add_static('max_', max_)

statics.add_static('mean', mean)

statics.add_static('merge_e', merge_e)

statics.add_static('merge_v', merge_v)

statics.add_static('min_', min_)

statics.add_static('not_', not_)

statics.add_static('optional', optional)

statics.add_static('or_', or_)

statics.add_static('order', order)

statics.add_static('otherV', otherV)

statics.add_static('other_v', other_v)

statics.add_static('out', out)

statics.add_static('outE', outE)

statics.add_static('out_e', out_e)

statics.add_static('outV', outV)

statics.add_static('out_v', out_v)

statics.add_static('path', path)

statics.add_static('project', project)

statics.add_static('properties', properties)

statics.add_static('property', property)

statics.add_static('propertyMap', propertyMap)

statics.add_static('property_map', property_map)

statics.add_static('range_', range_)

statics.add_static('repeat', repeat)

statics.add_static('sack', sack)

statics.add_static('sample', sample)

statics.add_static('select', select)

statics.add_static('sideEffect', sideEffect)

statics.add_static('side_effect', side_effect)

statics.add_static('simplePath', simplePath)

statics.add_static('simple_path', simple_path)

statics.add_static('skip', skip)

statics.add_static('store', store)

statics.add_static('subgraph', subgraph)

statics.add_static('sum_', sum_)

statics.add_static('tail', tail)

statics.add_static('timeLimit', timeLimit)

statics.add_static('time_limit', time_limit)

statics.add_static('times', times)

statics.add_static('to', to)

statics.add_static('toE', toE)

statics.add_static('to_e', to_e)

statics.add_static('toV', toV)

statics.add_static('to_v', to_v)

statics.add_static('tree', tree)

statics.add_static('unfold', unfold)

statics.add_static('union', union)

statics.add_static('until', until)

statics.add_static('value', value)

statics.add_static('valueMap', valueMap)

statics.add_static('value_map', value_map)

statics.add_static('values', values)

statics.add_static('where', where)
