gremlinpython 4.0.0b2__py3-none-any.whl → 4.0.0.dev1__py3-none-any.whl

gremlin_python/process/traversal.py

@@ -19,16 +19,18 @@
 
 import copy
 import math
+import re
 import threading
 import uuid
 import warnings
 
 from aenum import Enum
-from gremlin_python.structure.graph import Vertex, Edge, Path, Property
+from gremlin_python.structure.graph import Vertex, Edge, Path, Property, CompositePDT, PrimitivePDT
 
 from .. import statics
-from ..statics import long, SingleByte, short, bigint, BigDecimal
-from datetime import datetime
+from ..statics import long, SingleByte, SingleChar, short, bigint, BigDecimal
+from datetime import datetime, timedelta
+import base64
 
 
 class Traversal(object):
@@ -358,6 +360,8 @@ class P(object):
             return P("within", args[0])
         elif len(args) == 1 and type(args[0]) == set:
             return P("within", list(args[0]))
+        elif len(args) == 1 and isinstance(args[0], Traversal):
+            return P("within", args[0])
         else:
             return P("within", list(args))
 
@@ -367,6 +371,8 @@ class P(object):
             return P("without", args[0])
         elif len(args) == 1 and type(args[0]) == set:
             return P("without", list(args[0]))
+        elif len(args) == 1 and isinstance(args[0], Traversal):
+            return P("without", args[0])
         else:
             return P("without", list(args))
 
@@ -813,13 +819,13 @@ class GremlinLang(object):
         self.gremlin = []
         self.parameters = {}
         self.options_strategies = []
-        self.param_count = AtomicInteger()
+        self.pdt_registry = None
 
         if gremlin_lang is not None:
             self.gremlin = list(gremlin_lang.gremlin)
             self.parameters = dict(gremlin_lang.parameters)
             self.options_strategies = list(gremlin_lang.options_strategies)
-            self.param_count = gremlin_lang.param_count
+            self.pdt_registry = gremlin_lang.pdt_registry
 
     def _add_to_gremlin(self, string_name, *args):
 
@@ -844,6 +850,9 @@ class GremlinLang(object):
         if arg is None:
             return 'null'
 
+        if isinstance(arg, SingleChar):
+            return f'{arg!r}c'
+
         if isinstance(arg, str):
             return f'{arg!r}'  # use repr() format for canonical string rep
             # return f'"{arg}"'
@@ -879,6 +888,20 @@ class GremlinLang(object):
         if isinstance(arg, uuid.UUID):
             return f'UUID("{arg}")'
 
+        if isinstance(arg, timedelta):
+            is_negative = arg.total_seconds() < 0
+            abs_td = -arg if is_negative else arg
+            # Use integer components directly to avoid float precision loss
+            seconds = abs_td.days * 86400 + abs_td.seconds
+            nanos = abs_td.microseconds * 1000
+            if is_negative:
+                return f'Duration({seconds},{nanos},false)'
+            else:
+                return f'Duration({seconds},{nanos})'
+
+        if isinstance(arg, bytes):
+            return f'Binary("{base64.b64encode(arg).decode("ascii")}")'
+
         if isinstance(arg, Enum):
             tmp = str(arg)
             if tmp.endswith('_'):
@@ -888,6 +911,12 @@ class GremlinLang(object):
             else:
                 return tmp
 
+        if isinstance(arg, CompositePDT):
+            return f'PDT({self._arg_as_string(arg.name)},{self._process_dict(arg.fields)})'
+
+        if isinstance(arg, PrimitivePDT):
+            return f'PDT({self._arg_as_string(arg.name)},{self._arg_as_string(arg.value)})'
+
         if isinstance(arg, Vertex):
             return f'{self._arg_as_string(arg.id)}'
 
@@ -901,9 +930,8 @@ class GremlinLang(object):
 
         if isinstance(arg, GValue):
             key = arg.get_name()
-
-            if not key.isidentifier():
-                raise Exception(f'invalid parameter name {key}.')
+            if not re.fullmatch(r'(?:[^\W\d]|\$)(?:\w|\$)*', key):
+                raise Exception(f'Invalid parameter name [{key}].')
 
             if key in self.parameters:
                 if self.parameters[key] != arg.value:
@@ -921,18 +949,42 @@ class GremlinLang(object):
         if isinstance(arg, list):
             return self._process_list(arg)
 
-        if hasattr(arg, '__class__'):
-            try:
-                return arg.__name__
-            except AttributeError:
-                pass
-
-        return self._as_parameter(arg)
-
-    def _as_parameter(self, arg):
-        param_name = f'_{self.param_count.get_and_increment()}'
-        self.parameters[param_name] = arg
-        return param_name
+        # Strategy instances render as their name (e.g. "ReadOnlyStrategy") for withoutStrategies.
+        # Class objects render as their __name__ (e.g. strategy classes passed directly).
+        # These replace the old hasattr(arg, '__class__') check which was too broad since every
+        # Python object has __class__, making it a silent escape hatch for anything with __name__.
+        if isinstance(arg, TraversalStrategy):
+            return arg.strategy_name
+
+        if isinstance(arg, type):
+            return arg.__name__
+
+        # Registry-based dehydration — a registered adapter intentionally takes
+        # precedence over the @provider_defined decorator fallback below, allowing
+        # explicit adapters to override decorator-derived behavior.
+        if self.pdt_registry is not None:
+            primitive_adapter = self.pdt_registry.get_primitive_adapter_by_class(type(arg))
+            if primitive_adapter is not None and primitive_adapter['to_value'] is not None:
+                value = primitive_adapter['to_value'](arg)
+                return self._arg_as_string(PrimitivePDT(primitive_adapter['type_name'], value))
+            adapter = self.pdt_registry.get_composite_adapter_by_class(type(arg))
+            if adapter is not None and adapter['serialize'] is not None:
+                fields = adapter['serialize'](arg)
+                return self._arg_as_string(CompositePDT(adapter['type_name'], fields))
+
+        # Auto-dehydrate @provider_defined decorated objects
+        if hasattr(arg, '_pdt_name'):
+            included = getattr(arg, '_pdt_included_fields', None)
+            excluded = getattr(arg, '_pdt_excluded_fields', None)
+            fields = [f for f in vars(arg) if not f.startswith('_')]
+            if included:
+                fields = [f for f in fields if f in included]
+            elif excluded:
+                fields = [f for f in fields if f not in excluded]
+            pdt = CompositePDT(arg._pdt_name, {f: getattr(arg, f) for f in fields})
+            return self._arg_as_string(pdt)
+
+        raise TypeError(f'GremlinLang contains at least one type [{type(arg).__name__}] that cannot be represented as text.')
 
     # Do special processing needed to format predicates that come in
     # such as "gt(a)" correctly.
@@ -949,13 +1001,22 @@ class GremlinLang(object):
         c = 0
         res = [str(p).split('(')[0] + '(']
         if isinstance(p.value, list):
-            res.append('[')
-            for v in p.value:
-                if c > 0:
-                    res.append(',')
-                res.append(self._arg_as_string(v))
-                c += 1
-            res.append(']')
+            # If all elements are Traversals, serialize as comma-separated args (no brackets)
+            # This matches the server grammar: within(trav1, trav2) via genericArgumentVarargs
+            if len(p.value) > 0 and all(isinstance(v, Traversal) for v in p.value):
+                for v in p.value:
+                    if c > 0:
+                        res.append(',')
+                    res.append(self._arg_as_string(v))
+                    c += 1
+            else:
+                res.append('[')
+                for v in p.value:
+                    if c > 0:
+                        res.append(',')
+                    res.append(self._arg_as_string(v))
+                    c += 1
+                res.append(']')
         else:
             res.append(self._arg_as_string(p.value))
             if p.other is not None:
@@ -1011,11 +1072,23 @@ class GremlinLang(object):
     def get_parameters(self):
         return self.parameters
 
-    def add_g(self, g):
-        self.parameters['g'] = g
+    def get_parameters_as_string(self):
+        return GremlinLang.convert_parameters_to_string(self.parameters)
 
-    def reset(self):
-        self.param_count.set(0)
+    @staticmethod
+    def convert_parameters_to_string(params):
+        """Converts a parameter map to a gremlin-lang map literal string.
+
+        Raises TypeError if any value is an unsupported type.
+        """
+        if params is None or len(params) == 0:
+            return '[:]'
+
+        helper = GremlinLang()
+        parts = []
+        for k, v in params.items():
+            parts.append(f'{helper._arg_as_string(k)}:{helper._arg_as_string(v)}')
+        return '[' + ','.join(parts) + ']'
 
     def add_source(self, source_name, *args):
 
@@ -1062,7 +1135,7 @@ class GremlinLang(object):
 
     def __eq__(self, other):
         if isinstance(other, self.__class__):
-            return ''.join(self.gremlin) == ''.join(self.gremlin) and self.parameters == other.parameters
+            return ''.join(self.gremlin) == ''.join(other.gremlin) and self.parameters == other.parameters
         else:
             return False
 
@@ -1111,30 +1184,14 @@ class GremlinLang(object):
         return (''.join(self.gremlin) if len(self.gremlin) > 0 else "") + \
             (str(self.parameters) if len(self.parameters) > 0 else "")
 
-    # TODO to be removed or updated once HTTP transaction is implemented
-    # @staticmethod
-    # def _create_graph_op(name, *values):
-    #     bc = Bytecode()
-    #     bc.add_source(name, *values)
-    #     return bc
-    #
-    # @staticmethod
-    # class GraphOp:
-    #     @staticmethod
-    #     def commit():
-    #         return Bytecode._create_graph_op("tx", "commit")
-    #
-    #     @staticmethod
-    #     def rollback():
-    #         return Bytecode._create_graph_op("tx", "rollback")
 
 
 class GValue:
     def __init__(self, name, value):
+        if isinstance(value, GValue):
+            raise Exception('GValues cannot be nested')
         if name is None:
-            raise Exception("The parameter name cannot be None.")
-        if name.startswith('_'):
-            raise Exception(f'invalid GValue name {name}. Should not start with _.')
+            raise Exception('GValue name cannot be null.')
         self.name = name
         self.value = value
 
@@ -1147,6 +1204,12 @@ class GValue:
     def get(self):
         return self.value
 
+    def __repr__(self):
+        return f'{self.name}={self.value}'
+
+    def __str__(self):
+        return f'{self.name}={self.value}'
+
 
 class CardinalityValue(GremlinLang):
     def __init__(self, cardinality, val):