gremlinpython 3.6.8__py3-none-any.whl

gremlin_python/process/strategies.py

@@ -0,0 +1,239 @@
+#
+# 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.traversal import TraversalStrategy
+
+base_namespace = 'org.apache.tinkerpop.gremlin.process.traversal.strategy.'
+decoration_namespace = base_namespace + 'decoration.'
+finalization_namespace = base_namespace + 'finalization.'
+optimization_namespace = base_namespace + 'optimization.'
+verification_namespace = base_namespace + 'verification.'
+computer_decoration_namespace = 'org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.decoration.'
+
+#########################
+# DECORATION STRATEGIES #
+#########################
+
+
+class ConnectiveStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=decoration_namespace + 'ConnectiveStrategy')
+
+
+class ElementIdStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=decoration_namespace + 'ElementIdStrategy')
+
+
+# EventStrategy doesn't make sense outside JVM traversal machine
+
+class HaltedTraverserStrategy(TraversalStrategy):
+    def __init__(self, halted_traverser_factory=None):
+        TraversalStrategy.__init__(self, fqcn=decoration_namespace + 'HaltedTraverserStrategy')
+        if halted_traverser_factory is not None:
+            self.configuration["haltedTraverserFactory"] = halted_traverser_factory
+
+
+class OptionsStrategy(TraversalStrategy):
+    def __init__(self, options=None):
+        TraversalStrategy.__init__(self, configuration=options, fqcn=decoration_namespace + 'OptionsStrategy')
+
+
+class PartitionStrategy(TraversalStrategy):
+    def __init__(self, partition_key=None, write_partition=None, read_partitions=None, include_meta_properties=None):
+        TraversalStrategy.__init__(self, fqcn=decoration_namespace + 'PartitionStrategy')
+        if partition_key is not None:
+            self.configuration["partitionKey"] = partition_key
+        if write_partition is not None:
+            self.configuration["writePartition"] = write_partition
+        if read_partitions is not None:
+            self.configuration["readPartitions"] = read_partitions
+        if include_meta_properties is not None:
+            self.configuration["includeMetaProperties"] = include_meta_properties
+
+
+class SeedStrategy(TraversalStrategy):
+    def __init__(self, seed):
+        TraversalStrategy.__init__(self, fqcn="org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategy")
+        self.configuration["seed"] = seed
+
+
+class SubgraphStrategy(TraversalStrategy):
+
+    def __init__(self, vertices=None, edges=None, vertex_properties=None, check_adjacent_vertices=None):
+        TraversalStrategy.__init__(self, fqcn=decoration_namespace + 'SubgraphStrategy')
+        if vertices is not None:
+            self.configuration["vertices"] = vertices
+        if edges is not None:
+            self.configuration["edges"] = edges
+        if vertex_properties is not None:
+            self.configuration["vertexProperties"] = vertex_properties
+        if check_adjacent_vertices is not None:
+            self.configuration["checkAdjacentProperties"] = check_adjacent_vertices
+
+
+class VertexProgramStrategy(TraversalStrategy):
+    def __init__(self, graph_computer=None, workers=None, persist=None, result=None, vertices=None, edges=None,
+                 configuration=None):
+        TraversalStrategy.__init__(self, fqcn=computer_decoration_namespace + 'VertexProgramStrategy')
+        if graph_computer is not None:
+            self.configuration["graphComputer"] = graph_computer
+        if workers is not None:
+            self.configuration["workers"] = workers
+        if persist is not None:
+            self.configuration["persist"] = persist
+        if result is not None:
+            self.configuration["result"] = result
+        if vertices is not None:
+            self.configuration["vertices"] = vertices
+        if edges is not None:
+            self.configuration["edges"] = edges
+        if configuration is not None:
+            self.configuration.update(configuration)
+
+
+###########################
+# FINALIZATION STRATEGIES #
+###########################
+
+class MatchAlgorithmStrategy(TraversalStrategy):
+    def __init__(self, match_algorithm=None):
+        TraversalStrategy.__init__(self, fqcn=finalization_namespace + 'MatchAlgorithmStrategy')
+        if match_algorithm is not None:
+            self.configuration["matchAlgorithm"] = match_algorithm
+
+
+###########################
+# OPTIMIZATION STRATEGIES #
+###########################
+
+class AdjacentToIncidentStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'AdjacentToIncidentStrategy')
+
+
+class ByModulatorOptimizationStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn="org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ByModulatorOptimizationStrategy")
+
+
+class CountStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn="org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy")
+
+
+class FilterRankingStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'FilterRankingStrategy')
+
+
+class IdentityRemovalStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'IdentityRemovalStrategy')
+
+
+class IncidentToAdjacentStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'IncidentToAdjacentStrategy')
+
+
+class InlineFilterStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'InlineFilterStrategy')
+
+
+class LazyBarrierStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'LazyBarrierStrategy')
+
+
+class MatchPredicateStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'MatchPredicateStrategy')
+
+
+class OrderLimitStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'OrderLimitStrategy')
+
+
+class PathProcessorStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'PathProcessorStrategy')
+
+
+class PathRetractionStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'PathRetractionStrategy')
+
+
+class ProductiveByStrategy(TraversalStrategy):
+    def __init__(self, productiveKeys=None):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'ProductiveByStrategy')
+
+
+class CountStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'CountStrategy')
+
+
+class RepeatUnrollStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'RepeatUnrollStrategy')
+
+
+class GraphFilterStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'GraphFilterStrategy')
+
+
+
+class EarlyLimitStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=optimization_namespace + 'EarlyLimitStrategy')
+
+###########################
+# VERIFICATION STRATEGIES #
+###########################
+
+
+class LambdaRestrictionStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=verification_namespace + 'LambdaRestrictionStrategy')
+
+class ReadOnlyStrategy(TraversalStrategy):
+    def __init__(self):
+        TraversalStrategy.__init__(self, fqcn=verification_namespace + 'ReadOnlyStrategy')
+
+
+class EdgeLabelVerificationStrategy(TraversalStrategy):
+    def __init__(self, log_warning=False, throw_exception=False):
+        TraversalStrategy.__init__(self, fqcn=verification_namespace + 'EdgeLabelVerificationStrategy')
+        self.configuration["logWarning"] = log_warning
+        self.configuration["throwException"] = throw_exception
+
+
+class ReservedKeysVerificationStrategy(TraversalStrategy):
+    def __init__(self, log_warning=False, throw_exception=False, keys=["id", "label"]):
+        TraversalStrategy.__init__(self, fqcn=verification_namespace + 'ReservedKeysVerificationStrategy')
+        self.configuration["logWarning"] = log_warning
+        self.configuration["throwException"] = throw_exception
+        self.configuration["keys"] = keys

gremlin_python/process/translator.py

@@ -0,0 +1,297 @@
+#
+# 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.
+#
+
+"""
+Class that can turn traversals back into Gremlin Groovy format text queries.
+Those queries can then be run in the Gremlin console or using the GLV submit(<String>) API or
+sent to any TinkerPop compliant HTTP endpoint.
+"""
+__author__ = 'Kelvin R. Lawrence (gfxman)'
+
+import math
+import numbers
+import re
+
+from gremlin_python.process.traversal import *
+from gremlin_python.process.strategies import *
+from gremlin_python.structure.graph import Vertex, Edge, VertexProperty
+from datetime import datetime
+
+
+class Translator:
+    """
+    Turn a bytecode object back into a textual query (Gremlin Groovy script).
+    """
+
+    # Dictionary used to reverse-map token IDs to strings
+    options = {
+        WithOptions.tokens: 'tokens',
+        WithOptions.none: 'none',
+        WithOptions.ids: 'ids',
+        WithOptions.labels: 'labels',
+        WithOptions.keys: 'keys',
+        WithOptions.values: 'values',
+        WithOptions.all: 'all',
+        WithOptions.indexer: 'indexer',
+        WithOptions.list: 'list',
+        WithOptions.map: 'map'
+    }
+
+    conn_p = ['and', 'or']
+
+    def __init__(self, traversal_source=None):
+        self.traversal_source = traversal_source
+
+    def get_traversal_source(self):
+        return self.traversal_source
+
+    def get_target_language(self):
+        return "gremlin-groovy"
+
+    def of(self, traversal_source):
+        self.traversal_source = traversal_source
+        return self
+
+    # Do any needed special processing for the representation
+    # of strings and dates and boolean.
+    def fixup(self, v):
+        if isinstance(v, str):
+            return f'{v!r}'  # use repr() format for canonical string rep
+        elif type(v) == datetime:
+            return self.process_date(v)
+        elif type(v) == bool:
+            return 'true' if v else 'false'
+        elif isinstance(v, numbers.Number):
+            return self.process_number(v)
+        elif isinstance(v, set):
+            return f'[{str(v)[1:-1]}]'
+        elif isinstance(v, P):
+            return self.process_predicate(v)
+        elif type(v) == Vertex:
+            return self.process_vertex(v)
+        elif type(v) == Edge:
+            return self.process_edge(v)
+        elif type(v) in [Merge]:  # on_create on_match out_v in_v
+            tmp = str(v)
+            return f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
+        elif v is None:
+            return 'null'
+        else:
+            return str(v)
+
+    # Turn a Python datetime into the equivalent new Date(...)
+    def process_date(self, date):
+        y = date.year - 1900
+        mo = date.month
+        d = date.day
+        h = date.hour
+        mi = date.minute
+        s = date.second
+        return f'new Date({y},{mo},{d},{h},{mi},{s})'
+
+    # Do special processing needed to format predicates that come in
+    # such as "gt(a)" correctly.
+    def process_predicate(self, p):
+        res = ''
+        if p.operator in self.conn_p:
+            res += f'{self.process_predicate(p.value)}.{p.operator}({self.process_predicate(p.other)})'
+        else:
+            res += f'{self.process_p_value(p)}'
+        return res
+
+    # process the value of the predicates
+    def process_p_value(self, p):
+        res = str(p).split('(')[0] + '('
+        if type(p.value) == list:
+            res += '['
+            for v in p.value:
+                res += self.fixup(v) + ','
+            res = (res[0:-1] + ']') if len(p.value) > 0 else (res + ']')
+        else:
+            res += self.fixup(p.value)
+            if p.other is not None:
+                res += f',{self.fixup(p.other)}'
+        res += ')'
+        return res
+
+    # Special processing to handle strategies
+    def process_strategy(self, s):
+        c = 0
+        res = ''
+        # if parameter is empty, only pass class name (referenced GroovyTranslator.java)
+        if not s.configuration:
+            res += s.strategy_name
+        else:
+            res = f'new {str(s)}('
+            for key in s.configuration:
+                res += ',' if c > 0 else ''
+                res += key + ':'
+                val = s.configuration[key]
+                if isinstance(val, Traversal):
+                    res += self.translate(val.bytecode, child=True)
+                else:
+                    res += self.fixup(val)
+                c += 1
+            res += ')'
+        return res
+        pass
+
+    # Special processing to handle vertices
+    def process_vertex(self, vertex):
+        return f'new ReferenceVertex({self.fixup(vertex.id)},\'{vertex.label}\')'
+
+    # Special processing to handle edges
+    def process_edge(self, edge):
+        return f'new ReferenceEdge({str(edge.id)},\'{edge.label}\',' \
+               f'new ReferenceVertex({str(edge.inV.id)},\'{edge.inV.label}\'),' \
+               f'new ReferenceVertex({str(edge.outV.id)},\'{edge.outV.label}\'))'
+
+    # Special processing to handle vertex property
+    def process_vertex_property(self, vp):
+        return f'new ReferenceVertexProperty({str(vp.id)},\'{vp.label}\',{self.fixup(vp.value)})'
+
+    # Special processing to handle lambda
+    def process_lambda(self, lam):
+        lambda_result = lam()
+        script = lambda_result if isinstance(lambda_result, str) else lambda_result[0]
+        return f'{script}' if re.match(r"^\{.*\}$", script, flags=re.DOTALL) else f'{{{script}}}'
+
+    def process_dict(self, d):
+        c = 0
+        res = '['
+        if len(d) == 0:
+            res += ':'
+        else:
+            for k, v in d.items():
+                wrap = not isinstance(k, str)
+                res += ',' if c > 0 else ''
+                res += '(' if wrap else ''
+                res += self.fixup(k)
+                res += ')' if wrap else ''
+                res += f':{self.fixup(v)}'
+                c += 1
+        res += ']'
+        return res
+
+    def process_number(self, n):
+        if isinstance(n, float):
+            # converting floats into doubles for script since python doesn't distinguish and java defaults to double
+            if math.isnan(n):
+                return "Double.NaN"
+            elif math.isinf(n) and n > 0:
+                return "Double.POSITIVE_INFINITY"
+            elif math.isinf(n) and n < 0:
+                return "Double.NEGATIVE_INFINITY"
+            else:
+                return f'{n}d'
+        return f'{n}'
+
+    def process_list(self, l):
+        c = 0
+        res = '['
+        for i in l:
+            res += ',' if c > 0 else ''
+            res += self.fixup(i)
+            c += 1
+        res += ']'
+        return res
+
+    # Special processing to handle bindings inside of traversals
+    def process_binding(self, binding):
+        return f'Bindings.instance().of(\'{binding.key}\', {str(binding.value)})'
+
+    # Main driver of the translation. Different parts of
+    # a Traversal are handled appropriately.
+    def do_translation(self, step):
+        script = ''
+        params = step[1:]
+        script += '.' + step[0] + '('
+        if len(params) > 0:
+            c = 0
+            with_opts = False
+            is_merge_op = (step[0] == 'mergeV') or (step[0] == 'mergeE')
+            for p in params:
+                script += ',' if c > 0 else ''
+                if with_opts:
+                    script += f'WithOptions.{self.options[p]}'
+                elif type(p) == Bytecode:
+                    script += self.translate(p, True)
+                elif isinstance(p, P):
+                    script += self.process_predicate(p)
+                elif type(p) == Vertex:
+                    script += self.process_vertex(p)
+                elif type(p) == Edge:
+                    script += self.process_edge(p)
+                elif type(p) == VertexProperty:
+                    script += self.process_vertex_property(p)
+                elif type(p) in [Cardinality, Pop, Operator, Scope, T]:
+                    tmp = str(p)
+                    script += tmp[0:-1] if tmp.endswith('_') else tmp
+                elif type(p) in [Merge]:  # on_create on_match out_v in_v
+                    is_merge_op = True
+                    tmp = str(p)
+                    script += f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
+                elif isinstance(p, TraversalStrategy):  # this will capture all strategies
+                    script += self.process_strategy(p)
+                elif type(p) == datetime:
+                    script += self.process_date(p)
+                elif p == WithOptions.tokens:
+                    script += 'WithOptions.tokens'
+                    with_opts = True
+                elif isinstance(p, str):
+                    script += f'{p!r}'  # use repr() format for canonical string rep
+                elif type(p) == bool:
+                    script += 'true' if p else 'false'
+                elif isinstance(p, type(lambda: None)) and p.__name__ == (lambda: None).__name__:
+                    script += self.process_lambda(p)
+                elif type(p) == Binding:
+                    script += self.process_binding(p)
+                elif p is None:
+                    script += '(Traversal) null' if is_merge_op else 'null'
+                elif isinstance(p, type):
+                    script += p.__name__
+                elif isinstance(p, dict):
+                    script += self.process_dict(p)
+                elif isinstance(p, numbers.Number):
+                    script += self.process_number(p)
+                elif isinstance(p, set):
+                    script += f'[{str(p)[1:-1]}] as Set' if len(p) > 0 else '[] as Set'
+                elif isinstance(p, list):
+                    script += self.process_list(p)
+                else:
+                    script += str(p)
+                c += 1
+        script += ')'
+        return script
+
+    # Translation starts here. There are two main parts to a 
+    # traversal. Source instructions such as "withSideEffect"
+    # and "withStrategies", and step instructions such as 
+    # "addV" and "repeat". If child is True we will generate
+    # anonymous traversal style syntax.
+    def translate(self, bytecode, child=False):
+        script = '__' if child else self.traversal_source
+
+        for step in bytecode.source_instructions:
+            script += self.do_translation(step)
+
+        for step in bytecode.step_instructions:
+            script += self.do_translation(step)
+
+        return script