gremlinpython 3.6.8__py3-none-any.whl → 3.7.3__py3-none-any.whl

gremlin_python/__version__.py

@@ -16,5 +16,5 @@ KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.
 '''
-version   = '3.6.8'
-timestamp = 1730222094
+version   = '3.7.3'
+timestamp = 1730223986

gremlin_python/driver/driver_remote_connection.py

@@ -177,7 +177,7 @@ class DriverRemoteConnection(RemoteConnection):
                                  if x[0] == "withStrategies" and type(x[1]) is OptionsStrategy), None)
         request_options = None
         if options_strategy:
-            allowed_keys = ['evaluationTimeout', 'scriptEvaluationTimeout', 'batchSize', 'requestId', 'userAgent']
+            allowed_keys = ['evaluationTimeout', 'scriptEvaluationTimeout', 'batchSize', 'requestId', 'userAgent', 'materializeProperties']
             request_options = {allowed: options_strategy[1].configuration[allowed] for allowed in allowed_keys
                                if allowed in options_strategy[1].configuration}
         return request_options

gremlin_python/driver/useragent.py

@@ -18,7 +18,7 @@
 #
 import platform
 
-gremlin_version = "3.6.8"  # DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
+gremlin_version = "3.7.3"  # DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
 
 def _generate_user_agent():
     application_name = "NotAvailable"

gremlin_python/process/graph_traversal.py

@@ -180,7 +180,7 @@ class GraphTraversalSource(object):
         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):
+                      edges=None, configuration=None):
         return self.with_strategies(
             VertexProgramStrategy(graph_computer, workers, result, persist, vertices, edges, configuration))
 
@@ -243,6 +243,11 @@ class GraphTraversalSource(object):
         traversal.bytecode.add_step("call", *args)
         return traversal
 
+    def union(self, *args):
+        traversal = self.get_graph_traversal()
+        traversal.bytecode.add_step("union", *args)
+        return traversal
+
 
 class GraphTraversal(Traversal):
     def __init__(self, graph, traversal_strategies, bytecode):
@@ -274,6 +279,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("V", *args)
         return self
 
+    def E(self, *args):
+        self.bytecode.add_step("E", *args)
+        return self
+
     def addE(self, *args):
         warnings.warn(
             "gremlin_python.process.GraphTraversal.addE will be replaced by "
@@ -300,14 +309,30 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("aggregate", *args)
         return self
 
+    def all_(self, *args):
+        self.bytecode.add_step("all", *args)
+        return self
+
     def and_(self, *args):
         self.bytecode.add_step("and", *args)
         return self
 
+    def any_(self, *args):
+        self.bytecode.add_step("any", *args)
+        return self
+
     def as_(self, *args):
         self.bytecode.add_step("as", *args)
         return self
 
+    def as_date(self, *args):
+        self.bytecode.add_step("asDate", *args)
+        return self
+
+    def as_string(self, *args):
+        self.bytecode.add_step("asString", *args)
+        return self
+
     def barrier(self, *args):
         self.bytecode.add_step("barrier", *args)
         return self
@@ -366,6 +391,18 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("coin", *args)
         return self
 
+    def combine(self, *args):
+        self.bytecode.add_step("combine", *args)
+        return self
+
+    def concat(self, *args):
+        self.bytecode.add_step("concat", *args)
+        return self
+
+    def conjoin(self, *args):
+        self.bytecode.add_step("conjoin", *args)
+        return self
+
     def connectedComponent(self, *args):
         warnings.warn(
             "gremlin_python.process.GraphTraversalSource.connectedComponent will be replaced by "
@@ -396,10 +433,26 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("cyclicPath", *args)
         return self
 
+    def date_add(self, *args):
+        self.bytecode.add_step("dateAdd", *args)
+        return self
+
+    def date_diff(self, *args):
+        self.bytecode.add_step("dateDiff", *args)
+        return self
+
     def dedup(self, *args):
         self.bytecode.add_step("dedup", *args)
         return self
 
+    def difference(self, *args):
+        self.bytecode.add_step("difference", *args)
+        return self
+
+    def disjunct(self, *args):
+        self.bytecode.add_step("disjunct", *args)
+        return self
+
     def drop(self, *args):
         self.bytecode.add_step("drop", *args)
         return self
@@ -446,6 +499,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("fold", *args)
         return self
 
+    def format_(self, *args):
+        self.bytecode.add_step("format", *args)
+        return self
+
     def from_(self, *args):
         self.bytecode.add_step("from", *args)
         return self
@@ -566,6 +623,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("inject", *args)
         return self
 
+    def intersect(self, *args):
+        self.bytecode.add_step("intersect", *args)
+        return self
+
     def is_(self, *args):
         self.bytecode.add_step("is", *args)
         return self
@@ -578,6 +639,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("label", *args)
         return self
 
+    def length(self, *args):
+        self.bytecode.add_step("length", *args)
+        return self
+
     def limit(self, *args):
         self.bytecode.add_step("limit", *args)
         return self
@@ -590,6 +655,14 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("loops", *args)
         return self
 
+    def lTrim(self, *args):
+        self.bytecode.add_step("lTrim", *args)
+        return self
+
+    def l_trim(self, *args):
+        self.bytecode.add_step("lTrim", *args)
+        return self
+
     def map(self, *args):
         self.bytecode.add_step("map", *args)
         return self
@@ -610,6 +683,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("mean", *args)
         return self
 
+    def merge(self, *args):
+        self.bytecode.add_step("merge", *args)
+        return self
+
     def merge_e(self, *args):
         self.bytecode.add_step("mergeE", *args)
         return self
@@ -709,6 +786,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("peerPressure", *args)
         return self
 
+    def product(self, *args):
+        self.bytecode.add_step("product", *args)
+        return self
+
     def profile(self, *args):
         self.bytecode.add_step("profile", *args)
         return self
@@ -752,6 +833,22 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("repeat", *args)
         return self
 
+    def replace(self, *args):
+        self.bytecode.add_step("replace", *args)
+        return self
+
+    def reverse(self, *args):
+        self.bytecode.add_step("reverse", *args)
+        return self
+
+    def rTrim(self, *args):
+        self.bytecode.add_step("rTrim", *args)
+        return self
+
+    def r_trim(self, *args):
+        self.bytecode.add_step("rTrim", *args)
+        return self
+
     def sack(self, *args):
         self.bytecode.add_step("sack", *args)
         return self
@@ -801,6 +898,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("skip", *args)
         return self
 
+    def split(self, *args):
+        self.bytecode.add_step("split", *args)
+        return self
+
     def store(self, *args):
         self.bytecode.add_step("store", *args)
         return self
@@ -809,6 +910,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("subgraph", *args)
         return self
 
+    def substring(self, *args):
+        self.bytecode.add_step("substring", *args)
+        return self
+
     def sum_(self, *args):
         self.bytecode.add_step("sum", *args)
         return self
@@ -847,6 +952,14 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("toE", *args)
         return self
 
+    def to_lower(self, *args):
+        self.bytecode.add_step("toLower", *args)
+        return self
+
+    def to_upper(self, *args):
+        self.bytecode.add_step("toUpper", *args)
+        return self
+
     def toV(self, *args):
         warnings.warn(
             "gremlin_python.process.GraphTraversalSource.toV will be replaced by "
@@ -862,6 +975,10 @@ class GraphTraversal(Traversal):
         self.bytecode.add_step("tree", *args)
         return self
 
+    def trim(self, *args):
+        self.bytecode.add_step("trim", *args)
+        return self
+
     def unfold(self, *args):
         self.bytecode.add_step("unfold", *args)
         return self
@@ -926,6 +1043,10 @@ class __(object, metaclass=MagicType):
     def __(cls, *args):
         return __.inject(*args)
 
+    @classmethod
+    def E(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).E(*args)
+
     @classmethod
     def V(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).V(*args)
@@ -958,14 +1079,30 @@ class __(object, metaclass=MagicType):
     def aggregate(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).aggregate(*args)
 
+    @classmethod
+    def all_(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).all_(*args)
+
     @classmethod
     def and_(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).and_(*args)
 
+    @classmethod
+    def any_(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).any_(*args)
+
     @classmethod
     def as_(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).as_(*args)
 
+    @classmethod
+    def as_date(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).as_date(*args)
+
+    @classmethod
+    def as_string(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).as_string(*args)
+
     @classmethod
     def barrier(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).barrier(*args)
@@ -1022,6 +1159,18 @@ class __(object, metaclass=MagicType):
     def coin(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).coin(*args)
 
+    @classmethod
+    def combine(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).combine(*args)
+
+    @classmethod
+    def concat(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).concat(*args)
+
+    @classmethod
+    def conjoin(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).conjoin(*args)
+
     @classmethod
     def constant(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).constant(*args)
@@ -1042,10 +1191,26 @@ class __(object, metaclass=MagicType):
     def cyclic_path(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).cyclic_path(*args)
 
+    @classmethod
+    def date_add(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).date_add(*args)
+
+    @classmethod
+    def date_diff(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).date_diff(*args)
+
     @classmethod
     def dedup(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).dedup(*args)
 
+    @classmethod
+    def difference(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).difference(*args)
+
+    @classmethod
+    def disjunct(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).disjunct(*args)
+
     @classmethod
     def drop(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).drop(*args)
@@ -1094,6 +1259,10 @@ class __(object, metaclass=MagicType):
     def fold(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).fold(*args)
 
+    @classmethod
+    def format_(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).format_(*args)
+
     @classmethod
     def group(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).group(*args)
@@ -1218,6 +1387,10 @@ class __(object, metaclass=MagicType):
     def inject(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).inject(*args)
 
+    @classmethod
+    def intersect(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).intersect(*args)
+
     @classmethod
     def is_(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).is_(*args)
@@ -1230,6 +1403,10 @@ class __(object, metaclass=MagicType):
     def label(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).label(*args)
 
+    @classmethod
+    def length(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).length(*args)
+
     @classmethod
     def limit(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).limit(*args)
@@ -1242,6 +1419,18 @@ class __(object, metaclass=MagicType):
     def loops(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).loops(*args)
 
+    @classmethod
+    def ltrim(cls, *args):
+        warnings.warn(
+            "gremlin_python.process.__.ltrim will be replaced by "
+            "gremlin_python.process.__.l_trim.",
+            DeprecationWarning)
+        return cls.l_trim(*args)
+    
+    @classmethod
+    def l_trim(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).l_trim(*args)
+
     @classmethod
     def map(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).map(*args)
@@ -1262,6 +1451,10 @@ class __(object, metaclass=MagicType):
     def mean(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).mean(*args)
 
+    @classmethod
+    def merge(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).merge(*args)
+
     @classmethod
     def merge_e(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).merge_e(*args)
@@ -1334,6 +1527,10 @@ class __(object, metaclass=MagicType):
     def path(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).path(*args)
 
+    @classmethod
+    def product(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).product(*args)
+
     @classmethod
     def project(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).project(*args)
@@ -1366,6 +1563,26 @@ class __(object, metaclass=MagicType):
     def repeat(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).repeat(*args)
 
+    @classmethod
+    def replace(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).replace(*args)
+
+    @classmethod
+    def reverse(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).reverse(*args)
+
+    @classmethod
+    def rTrim(cls, *args):
+        warnings.warn(
+            "gremlin_python.process.__.rTrim will be replaced by "
+            "gremlin_python.process.__.r_trim.",
+            DeprecationWarning)
+        return cls.r_trim(*args)
+
+    @classmethod
+    def r_trim(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).r_trim(*args)
+
     @classmethod
     def sack(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).sack(*args)
@@ -1406,6 +1623,10 @@ class __(object, metaclass=MagicType):
     def skip(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).skip(*args)
 
+    @classmethod
+    def split(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).split(*args)
+
     @classmethod
     def store(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).store(*args)
@@ -1414,6 +1635,10 @@ class __(object, metaclass=MagicType):
     def subgraph(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).subgraph(*args)
 
+    @classmethod
+    def substring(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).substring(*args)
+
     @classmethod
     def sum_(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).sum_(*args)
@@ -1454,6 +1679,14 @@ class __(object, metaclass=MagicType):
     def to_e(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).to_e(*args)
 
+    @classmethod
+    def to_lower(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).to_lower(*args)
+
+    @classmethod
+    def to_upper(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).to_upper(*args)
+
     @classmethod
     def toV(cls, *args):
         warnings.warn(
@@ -1470,6 +1703,10 @@ class __(object, metaclass=MagicType):
     def tree(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).tree(*args)
 
+    @classmethod
+    def trim(cls, *args):
+        return cls.graph_traversal(None, None, Bytecode()).trim(*args)
+
     @classmethod
     def unfold(cls, *args):
         return cls.graph_traversal(None, None, Bytecode()).unfold(*args)
@@ -1582,6 +1819,10 @@ class Transaction:
         return session
 
 
+def E(*args):
+    return __.E(*args)
+
+
 def V(*args):
     return __.V(*args)
 
@@ -1614,6 +1855,14 @@ def as_(*args):
     return __.as_(*args)
 
 
+def as_date(*args):
+    return __.as_date(*args)
+
+
+def as_string(*args):
+    return __.as_string(*args)
+
+
 def barrier(*args):
     return __.barrier(*args)
 
@@ -1662,6 +1911,10 @@ def coin(*args):
     return __.coin(*args)
 
 
+def concat(*args):
+    return __.concat(*args)
+
+
 def constant(*args):
     return __.constant(*args)
 
@@ -1678,6 +1931,14 @@ def cyclic_path(*args):
     return __.cyclic_path(*args)
 
 
+def date_add(*args):
+    return __.date_add(*args)
+
+
+def date_diff(*args):
+    return __.date_diff(*args)
+
+
 def dedup(*args):
     return __.dedup(*args)
 
@@ -1722,6 +1983,10 @@ def fold(*args):
     return __.fold(*args)
 
 
+def format_(*args):
+    return __.format_(*args)
+
+
 def group(*args):
     return __.group(*args)
 
@@ -1826,6 +2091,10 @@ def label(*args):
     return __.label(*args)
 
 
+def length(*args):
+    return __.length(*args)
+
+
 def limit(*args):
     return __.limit(*args)
 
@@ -1838,6 +2107,14 @@ def loops(*args):
     return __.loops(*args)
 
 
+def ltrim(*args):
+    return __.l_trim(*args)
+
+
+def l_trim(*args):
+    return __.l_trim(*args)
+
+
 def map(*args):
     return __.map(*args)
 
@@ -1946,6 +2223,22 @@ def repeat(*args):
     return __.repeat(*args)
 
 
+def replace(*args):
+    return __.replace(*args)
+
+
+def reverse(*args):
+    return __.reverse(*args)
+
+
+def rTrim(*args):
+    return __.r_trim(*args)
+
+
+def r_trim(*args):
+    return __.r_trim(*args)
+
+
 def sack(*args):
     return __.sack(*args)
 
@@ -1978,6 +2271,10 @@ def skip(*args):
     return __.skip(*args)
 
 
+def split(*args):
+    return __.split(*args)
+
+
 def store(*args):
     return __.store(*args)
 
@@ -1986,6 +2283,10 @@ def subgraph(*args):
     return __.subgraph(*args)
 
 
+def substring(*args):
+    return __.substring(*args)
+
+
 def sum_(*args):
     return __.sum_(*args)
 
@@ -2018,6 +2319,14 @@ def to_e(*args):
     return __.to_e(*args)
 
 
+def to_lower(*args):
+    return __.to_lower(*args)
+
+
+def to_upper(*args):
+    return __.to_upper(*args)
+
+
 def toV(*args):
     return __.to_v(*args)
 
@@ -2030,6 +2339,10 @@ def tree(*args):
     return __.tree(*args)
 
 
+def trim(*args):
+    return __.trim(*args)
+
+
 def unfold(*args):
     return __.unfold(*args)
 
@@ -2078,6 +2391,10 @@ statics.add_static('and_', and_)
 
 statics.add_static('as_', as_)
 
+statics.add_static('as_date', as_date)
+
+statics.add_static('as_string', as_string)
+
 statics.add_static('barrier', barrier)
 
 statics.add_static('both', both)
@@ -2102,6 +2419,8 @@ statics.add_static('coalesce', coalesce)
 
 statics.add_static('coin', coin)
 
+statics.add_static('concat', concat)
+
 statics.add_static('constant', constant)
 
 statics.add_static('count', count)
@@ -2110,6 +2429,10 @@ statics.add_static('cyclicPath', cyclicPath)
 
 statics.add_static('cyclicpath', cyclic_path)
 
+statics.add_static('date_add', date_add)
+
+statics.add_static('date_diff', date_diff)
+
 statics.add_static('dedup', dedup)
 
 statics.add_static('drop', drop)
@@ -2132,6 +2455,8 @@ statics.add_static('flat_map', flat_map)
 
 statics.add_static('fold', fold)
 
+statics.add_static('format_', format_)
+
 statics.add_static('group', group)
 
 statics.add_static('groupCount', groupCount)
@@ -2182,12 +2507,18 @@ statics.add_static('key', key)
 
 statics.add_static('label', label)
 
+statics.add_static('length', length)
+
 statics.add_static('limit', limit)
 
 statics.add_static('local', local)
 
 statics.add_static('loops', loops)
 
+statics.add_static('ltrim', ltrim)
+
+statics.add_static('l_trim', l_trim)
+
 statics.add_static('map', map)
 
 statics.add_static('match', match)
@@ -2242,6 +2573,14 @@ statics.add_static('range_', range_)
 
 statics.add_static('repeat', repeat)
 
+statics.add_static('replace', replace)
+
+statics.add_static('reverse', reverse)
+
+statics.add_static('rTrim', rTrim)
+
+statics.add_static('r_trim', r_trim)
+
 statics.add_static('sack', sack)
 
 statics.add_static('sample', sample)
@@ -2258,10 +2597,14 @@ statics.add_static('simple_path', simple_path)
 
 statics.add_static('skip', skip)
 
+statics.add_static('split', split)
+
 statics.add_static('store', store)
 
 statics.add_static('subgraph', subgraph)
 
+statics.add_static('substring', substring)
+
 statics.add_static('sum_', sum_)
 
 statics.add_static('tail', tail)
@@ -2280,10 +2623,16 @@ statics.add_static('to_e', to_e)
 
 statics.add_static('toV', toV)
 
+statics.add_static('to_lower', to_lower)
+
+statics.add_static('to_upper', to_upper)
+
 statics.add_static('to_v', to_v)
 
 statics.add_static('tree', tree)
 
+statics.add_static('trim', trim)
+
 statics.add_static('unfold', unfold)
 
 statics.add_static('union', union)

gremlin_python/process/traversal.py

@@ -194,6 +194,13 @@ GryoVersion = Enum('GryoVersion', ' V1_0 V3_0')
 statics.add_static('V1_0', GryoVersion.V1_0)
 statics.add_static('V3_0', GryoVersion.V3_0)
 
+DT = Enum('DT', ' second minute hour day')
+
+statics.add_static('second', DT.second)
+statics.add_static('minute', DT.minute)
+statics.add_static('hour', DT.hour)
+statics.add_static('day', DT.day)
+
 Merge = Enum('Merge', ' on_create on_match out_v in_v')
 
 statics.add_static('on_create', Merge.on_create)
@@ -817,6 +824,24 @@ class Bytecode(object):
             return Bytecode._create_graph_op("tx", "rollback")
 
 
+class CardinalityValue(Bytecode):
+    def __init__(self, cardinality, val):
+        super().__init__()
+        self.add_source("CardinalityValueTraversal", cardinality, val)
+
+    @classmethod
+    def single(cls, val):
+        return CardinalityValue(Cardinality.single, val)
+
+    @classmethod
+    def list_(cls, val):
+        return CardinalityValue(Cardinality.list_, val)
+
+    @classmethod
+    def set_(cls, val):
+        return CardinalityValue(Cardinality.set_, val)
+
+
 '''
 BINDINGS
 '''

gremlin_python/structure/graph.py

@@ -43,9 +43,10 @@ class Graph(object):
 
 
 class Element(object):
-    def __init__(self, id, label):
+    def __init__(self, id, label, properties=None):
         self.id = id
         self.label = label
+        self.properties = properties
 
     def __eq__(self, other):
         return isinstance(other, self.__class__) and self.id == other.id
@@ -55,16 +56,16 @@ class Element(object):
 
 
 class Vertex(Element):
-    def __init__(self, id, label="vertex"):
-        Element.__init__(self, id, label)
+    def __init__(self, id, label="vertex", properties=None):
+        Element.__init__(self, id, label, properties)
 
     def __repr__(self):
         return "v[" + str(self.id) + "]"
 
 
 class Edge(Element):
-    def __init__(self, id, outV, label, inV):
-        Element.__init__(self, id, label)
+    def __init__(self, id, outV, label, inV, properties=None):
+        Element.__init__(self, id, label, properties)
         self.outV = outV
         self.inV = inV
 
@@ -73,8 +74,8 @@ class Edge(Element):
 
 
 class VertexProperty(Element):
-    def __init__(self, id, label, value, vertex):
-        Element.__init__(self, id, label)
+    def __init__(self, id, label, value, vertex, properties=None):
+        Element.__init__(self, id, label, properties)
         self.value = value
         self.key = self.label
         self.vertex = vertex

gremlin_python/structure/io/graphbinaryV1.py

@@ -33,7 +33,7 @@ from gremlin_python import statics
 from gremlin_python.statics import FloatType, BigDecimal, FunctionType, ShortType, IntType, LongType, BigIntType, \
                                    TypeType, DictType, ListType, SetType, SingleByte, ByteBufferType, GremlinType, \
                                    SingleChar
-from gremlin_python.process.traversal import Barrier, Binding, Bytecode, Cardinality, Column, Direction, Merge, \
+from gremlin_python.process.traversal import Barrier, Binding, Bytecode, Cardinality, Column, Direction, DT, Merge, \
                                              Operator, Order, Pick, Pop, P, Scope, TextP, Traversal, Traverser, \
                                              TraversalStrategy, T
 from gremlin_python.process.graph_traversal import GraphTraversal
@@ -97,6 +97,7 @@ class DataType(Enum):
     metrics = 0x2c
     traversalmetrics = 0x2d
     merge = 0x2e
+    dt = 0x2f
     char = 0x80
     duration = 0x81
     inetaddress = 0x82            # todo
@@ -601,8 +602,11 @@ class EdgeIO(_GraphBinaryTypeIO):
         edgelbl = r.to_object(b, DataType.string, False)
         inv = Vertex(r.read_object(b), r.to_object(b, DataType.string, False))
         outv = Vertex(r.read_object(b), r.to_object(b, DataType.string, False))
-        edge = Edge(edgeid, outv, edgelbl, inv)
-        b.read(4)
+        b.read(2)
+        props = r.read_object(b)
+        # null properties are returned as empty lists
+        properties = [] if props is None else props
+        edge = Edge(edgeid, outv, edgelbl, inv, properties)
         return edge
 
 
@@ -680,8 +684,12 @@ class VertexIO(_GraphBinaryTypeIO):
 
     @classmethod
     def _read_vertex(cls, b, r):
-        vertex = Vertex(r.read_object(b), r.to_object(b, DataType.string, False))
-        b.read(2)
+        vertex_id = r.read_object(b)
+        vertex_label = r.to_object(b, DataType.string, False)
+        props = r.read_object(b)
+        # null properties are returned as empty lists
+        properties = [] if props is None else props
+        vertex = Vertex(vertex_id, vertex_label, properties)
         return vertex
 
 
@@ -707,7 +715,10 @@ class VertexPropertyIO(_GraphBinaryTypeIO):
     @classmethod
     def _read_vertexproperty(cls, b, r):
         vp = VertexProperty(r.read_object(b), r.to_object(b, DataType.string, False), r.read_object(b), None)
-        b.read(4)
+        b.read(2)
+        properties = r.read_object(b)
+        # null properties are returned as empty lists
+        vp.properties = [] if properties is None else properties
         return vp
 
 
@@ -918,6 +929,11 @@ class PSerializer(_GraphBinaryTypeIO):
         return to_extend
 
 
+class DTIO(_EnumIO):
+    graphbinary_type = DataType.dt
+    python_type = DT
+
+
 class MergeIO(_EnumIO):
     graphbinary_type = DataType.merge
     python_type = Merge

gremlin_python/structure/io/graphsonV2d0.py

@@ -585,7 +585,12 @@ class VertexDeserializer(_GraphSONTypeIO):
 
     @classmethod
     def objectify(cls, d, reader):
-        return Vertex(reader.to_object(d["id"]), d.get("label", "vertex"))
+        properties = None
+        if "properties" in d:
+            properties = reader.to_object(d["properties"])
+            if properties is not None:
+                properties = [item for sublist in properties.values() for item in sublist]
+        return Vertex(reader.to_object(d["id"]), d.get("label", "vertex"), properties)
 
 
 class EdgeDeserializer(_GraphSONTypeIO):
@@ -593,10 +598,16 @@ class EdgeDeserializer(_GraphSONTypeIO):
 
     @classmethod
     def objectify(cls, d, reader):
+        properties = None
+        if "properties" in d:
+            properties = reader.to_object(d["properties"])
+            if properties is not None:
+                properties = list(properties.values())
         return Edge(reader.to_object(d["id"]),
                     Vertex(reader.to_object(d["outV"]), d.get("outVLabel", "vertex")),
                     d.get("label", "edge"),
-                    Vertex(reader.to_object(d["inV"]), d.get("inVLabel", "vertex")))
+                    Vertex(reader.to_object(d["inV"]), d.get("inVLabel", "vertex")),
+                    properties)
 
 
 class VertexPropertyDeserializer(_GraphSONTypeIO):
@@ -604,11 +615,17 @@ class VertexPropertyDeserializer(_GraphSONTypeIO):
 
     @classmethod
     def objectify(cls, d, reader):
+        properties = None
+        if "properties" in d:
+            properties = reader.to_object(d["properties"])
+            if properties is not None:
+                properties = list(map(lambda x: Property(x[0], x[1], None), properties.items()))
         vertex = Vertex(reader.to_object(d.get("vertex"))) if "vertex" in d else None
         return VertexProperty(reader.to_object(d["id"]),
                               d["label"],
                               reader.to_object(d["value"]),
-                              vertex)
+                              vertex,
+                              properties)
 
 
 class PropertyDeserializer(_GraphSONTypeIO):

gremlin_python/structure/io/graphsonV3d0.py

@@ -685,7 +685,12 @@ class VertexDeserializer(_GraphSONTypeIO):
 
     @classmethod
     def objectify(cls, d, reader):
-        return Vertex(reader.to_object(d["id"]), d.get("label", "vertex"))
+        properties = None
+        if "properties" in d:
+            properties = reader.to_object(d["properties"])
+            if properties is not None:
+                properties = [item for sublist in properties.values() for item in sublist]
+        return Vertex(reader.to_object(d["id"]), d.get("label", "vertex"), properties)
 
 
 class EdgeDeserializer(_GraphSONTypeIO):
@@ -693,10 +698,16 @@ class EdgeDeserializer(_GraphSONTypeIO):
 
     @classmethod
     def objectify(cls, d, reader):
+        properties = None
+        if "properties" in d:
+            properties = reader.to_object(d["properties"])
+            if properties is not None:
+                properties = list(properties.values())
         return Edge(reader.to_object(d["id"]),
                     Vertex(reader.to_object(d["outV"]), d.get("outVLabel", "vertex")),
                     d.get("label", "edge"),
-                    Vertex(reader.to_object(d["inV"]), d.get("inVLabel", "vertex")))
+                    Vertex(reader.to_object(d["inV"]), d.get("inVLabel", "vertex")),
+                    properties)
 
 
 class VertexPropertyDeserializer(_GraphSONTypeIO):
@@ -704,11 +715,17 @@ class VertexPropertyDeserializer(_GraphSONTypeIO):
 
     @classmethod
     def objectify(cls, d, reader):
+        properties = None
+        if "properties" in d:
+            properties = reader.to_object(d["properties"])
+            if properties is not None:
+                properties = list(map(lambda x: Property(x[0], x[1], None), properties.items()))
         vertex = Vertex(reader.to_object(d.get("vertex"))) if "vertex" in d else None
         return VertexProperty(reader.to_object(d["id"]),
                               d["label"],
                               reader.to_object(d["value"]),
-                              vertex)
+                              vertex,
+                              properties)
 
 
 class PropertyDeserializer(_GraphSONTypeIO):

{gremlinpython-3.6.8.dist-info → gremlinpython-3.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gremlinpython
-Version: 3.6.8
+Version: 3.7.3
 Summary: Gremlin-Python for Apache TinkerPop
 Home-page: https://tinkerpop.apache.org
 Maintainer: Apache TinkerPop

{gremlinpython-3.6.8.dist-info → gremlinpython-3.7.3.dist-info}/RECORD

@@ -1,37 +1,37 @@
 gremlin_python/__init__.py,sha256=rbOOdo_19nz_mHTXVc5p8ZXLI5pUGMfXLKQiw7Olu7g,850
-gremlin_python/__version__.py,sha256=V9sO74fY-Dma9JPUYdCQxr_0DHYkwZjy4rIAvFfkTG8,804
+gremlin_python/__version__.py,sha256=4GOYiVUI9q2mOGod7Kr4QvZP3Py3bWvpTm5gbtlr4YY,804
 gremlin_python/statics.py,sha256=BXnrfx25Todku_U0ddd-zB4eyQMf2paT5uuN9znK2fQ,2849
 gremlin_python/driver/__init__.py,sha256=rbOOdo_19nz_mHTXVc5p8ZXLI5pUGMfXLKQiw7Olu7g,850
 gremlin_python/driver/client.py,sha256=s-6cV2C0EMpvmyZZXWTq8kiFZEFLdn_HmWMF05mrSzU,8166
 gremlin_python/driver/connection.py,sha256=9Jia02-47hzX7ElMhMWBCKrrvOm1eUnmOOnl_S730PE,3857
-gremlin_python/driver/driver_remote_connection.py,sha256=73Ig2kkDnSOKgAdKpd0oOZ1ZSnOfjwDoeyJbUaEsO1U,8827
+gremlin_python/driver/driver_remote_connection.py,sha256=8htMF-TYd0FJDQciL_nzTsVbzkgWO8lCBivx6qv2LU8,8852
 gremlin_python/driver/protocol.py,sha256=SqDZWeu3p2WHCzv8k1u2Q1icg2AIl03OhkWsB4KoBnw,11785
 gremlin_python/driver/remote_connection.py,sha256=DtglObhiyLDIgLKIcv7enDuXd9KiCJVLXWAvreBQ4wA,3014
 gremlin_python/driver/request.py,sha256=IlqBmQlT2UU95xbY6z1ajlmNQeDZ4ePzT4uF8M0USFk,953
 gremlin_python/driver/resultset.py,sha256=_-13igfH1zQ72mgreDptPmUaXnadnprERVQTSZWeIl4,2669
 gremlin_python/driver/serializer.py,sha256=wFCPAltRB2F0p9ZFyD0x2thoBmI81gPFZhAkV5XLBOQ,10244
 gremlin_python/driver/transport.py,sha256=aEXb9oS1SMI9oKWYINnWuYhYaosi6FdsOJ7oj6FzkkY,1246
-gremlin_python/driver/useragent.py,sha256=0-bUZrDZzmtHGwgcsmGKCXNwBtZ7nuQ8DaV5q29QypE,1588
+gremlin_python/driver/useragent.py,sha256=DCwuOjy9BGDAN73cUskm3rQICtMemOtwAzecyYCXXU8,1588
 gremlin_python/driver/aiohttp/__init__.py,sha256=xzdixoKYCJCe4aRILYqdartQi4Py5fcQWqif3zzyUC8,787
 gremlin_python/driver/aiohttp/transport.py,sha256=hHeozoAkkCLgbHqZxCC0lqZTNk6tg4OqF1JqPc7B8HQ,11269
 gremlin_python/process/__init__.py,sha256=rbOOdo_19nz_mHTXVc5p8ZXLI5pUGMfXLKQiw7Olu7g,850
 gremlin_python/process/anonymous_traversal.py,sha256=A8evyPIAciRGiauDqUbyo4XnG3QTdO28l-TF2K7Ir2g,2448
-gremlin_python/process/graph_traversal.py,sha256=f_k1Jw9wZ5CN155lBzz497uGffZkh_OAEHN45IzKdZ4,61094
+gremlin_python/process/graph_traversal.py,sha256=g9TUBp5plcQPkc2nqU5Q93Tg07Q6PrgZRWvdY6WEax0,69311
 gremlin_python/process/strategies.py,sha256=95WIhzvvqejCEDOlhICGji9HgkwTUySGKt-yNCBTTh8,9474
 gremlin_python/process/translator.py,sha256=NuaA2WfepvgDm3DrNa_u2Qvz70s9t6ICbFltPglQwBI,11147
-gremlin_python/process/traversal.py,sha256=m4oHkVKxzXM4YD03cRljbzskEwClZP58XB4djpzL7Sw,22454
+gremlin_python/process/traversal.py,sha256=3xYpSeZyCxziA2nP3ZEhwfpcnDFBsy0t8utIYy4PG2c,23122
 gremlin_python/structure/__init__.py,sha256=zo5zR3kruv1h4_A80IxZ1IZrS0Ud5lVjpGm0PxBAP20,852
-gremlin_python/structure/graph.py,sha256=JdyP2yiZKK2EnkTn4wIiy-bZb8iGLCvneC8T_VaZgvo,4365
+gremlin_python/structure/graph.py,sha256=hBSsn6tYU4qRhCc53SKrcUu8VfSwvtL2m-PE2n9VZS4,4506
 gremlin_python/structure/io/__init__.py,sha256=zo5zR3kruv1h4_A80IxZ1IZrS0Ud5lVjpGm0PxBAP20,852
-gremlin_python/structure/io/graphbinaryV1.py,sha256=Ti_eR70jOmJnapiyTq1qhkt90CKfXPWEhqwnhBef5tY,37104
-gremlin_python/structure/io/graphsonV2d0.py,sha256=qylO27tVWE3GmCFBL0rC27T456enGJqkB358Ly4BypQ,21405
-gremlin_python/structure/io/graphsonV3d0.py,sha256=cP7BdkD7gnhD_lWPpq9VzozxSpBZ5SXsoJymMpjzSUc,24727
+gremlin_python/structure/io/graphbinaryV1.py,sha256=TS2_y6e0IcM8eIjTh_jve7wSgErkazrCQwJqUKo_dn0,37708
+gremlin_python/structure/io/graphsonV2d0.py,sha256=uR8qG8H35RxNpqhamT79w6WEHz5ITyyXD5u881C0J-U,22196
+gremlin_python/structure/io/graphsonV3d0.py,sha256=hJcz8KlHhS_BAwvwKC3dA24POZYK22a3W-AETdksCT4,25518
 gremlin_python/structure/io/util.py,sha256=x0OEkGGX2ajgOuSbz1j3dO3_IlOPnPLV4m6SGAmNAeM,1846
-gremlinpython-3.6.8.data/data/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-gremlinpython-3.6.8.data/data/NOTICE,sha256=h-5PKu8VoRZYtIoIbQYwvbtBWDK16kNDtp0e1Lu-WXc,170
-gremlinpython-3.6.8.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-gremlinpython-3.6.8.dist-info/METADATA,sha256=BdlJSLjRLchHG0RyVDos1vE5_g10K91dbSZXMz3rYIs,6436
-gremlinpython-3.6.8.dist-info/NOTICE,sha256=h-5PKu8VoRZYtIoIbQYwvbtBWDK16kNDtp0e1Lu-WXc,170
-gremlinpython-3.6.8.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-gremlinpython-3.6.8.dist-info/top_level.txt,sha256=VVeR1g-oOCZBmKIaVzZ7fF2BYrnqOWpw7C2H71ksTAU,15
-gremlinpython-3.6.8.dist-info/RECORD,,
+gremlinpython-3.7.3.data/data/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+gremlinpython-3.7.3.data/data/NOTICE,sha256=h-5PKu8VoRZYtIoIbQYwvbtBWDK16kNDtp0e1Lu-WXc,170
+gremlinpython-3.7.3.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+gremlinpython-3.7.3.dist-info/METADATA,sha256=4N290HG4TLjL5fH4eSnNs8t8KPw2JgczPG3JafpBYmI,6436
+gremlinpython-3.7.3.dist-info/NOTICE,sha256=h-5PKu8VoRZYtIoIbQYwvbtBWDK16kNDtp0e1Lu-WXc,170
+gremlinpython-3.7.3.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+gremlinpython-3.7.3.dist-info/top_level.txt,sha256=VVeR1g-oOCZBmKIaVzZ7fF2BYrnqOWpw7C2H71ksTAU,15
+gremlinpython-3.7.3.dist-info/RECORD,,