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

gremlin_python/driver/resultset.py

@@ -16,10 +16,13 @@
 # specific language governing permissions and limitations
 # under the License.
 #
+import queue
 from concurrent.futures import Future
 
 __author__ = 'David M. Brown (davebshow@gmail.com)'
 
+_EXHAUSTED = object()
+
 
 class ResultSet:
 
@@ -45,7 +48,7 @@ class ResultSet:
 
     def __next__(self):
         result = self.one()
-        if not result:
+        if result is _EXHAUSTED:
             raise StopIteration
         return result
 
@@ -62,11 +65,14 @@ class ResultSet:
 
     def one(self):
         while not self.done.done():
-            if not self.stream.empty():
-                return self.stream.get_nowait()
+            try:
+                return self.stream.get(timeout=0.1)
+            except queue.Empty:
+                pass
         if not self.stream.empty():
             return self.stream.get_nowait()
-        return self.done.result()
+        self.done.result()
+        return _EXHAUSTED
 
     def all(self):
         future = Future()
@@ -79,7 +85,7 @@ class ResultSet:
             else:
                 results = []
                 while not self.stream.empty():
-                    results += self.stream.get_nowait()
+                    results.append(self.stream.get_nowait())
                 future.set_result(results)
 
         self.done.add_done_callback(cb)

gremlin_python/driver/serializer.py

@@ -17,81 +17,13 @@
 # under the License.
 #
 
-import base64
-import logging
-import struct
-import io
-
+from gremlin_python.driver.connection import GremlinServerError
 from gremlin_python.process.traversal import Traverser
-
-try:
-    import ujson as json
-    if int(json.__version__[0]) < 2:
-        logging.warning("Detected ujson version below 2.0.0. This is not recommended as precision may be lost.")
-except ImportError:
-    import json
-
-from gremlin_python.structure.io import graphbinaryV4, graphsonV4
+from gremlin_python.structure.io import graphbinaryV4
 from gremlin_python.structure.io.util import Marker
 
 __author__ = 'David M. Brown (davebshow@gmail.com), Lyndon Bauto (lyndonb@bitquilltech.com)'
 
-"""
-GraphSONV4
-"""
-
-class GraphSONSerializersV4(object):
-    """
-    Message serializer for GraphSON. Allow users to pass custom reader,
-    writer, and version kwargs for custom serialization. Otherwise,
-    use current GraphSON version as default.
-    """
-
-    # KEEP TRACK OF CURRENT DEFAULTS
-    DEFAULT_READER_CLASS = graphsonV4.GraphSONReader
-    DEFAULT_WRITER_CLASS = graphsonV4.GraphSONWriter
-    DEFAULT_VERSION = b"application/vnd.gremlin-v4.0+json"
-
-    def __init__(self, reader=None, writer=None, version=None):
-        if not version:
-            version = self.DEFAULT_VERSION
-        self._version = version
-        if not reader:
-            reader = self.DEFAULT_READER_CLASS()
-        self._graphson_reader = reader
-        if not writer:
-            writer = self.DEFAULT_WRITER_CLASS()
-        self._graphson_writer = writer
-
-    @property
-    def version(self):
-        """Read only property"""
-        return self._version
-
-    def serialize_message(self, request_message):
-        message = self.build_message(request_message.fields, request_message.gremlin)
-        return message
-
-    def build_message(self, fields, gremlin):
-        message = {
-            'gremlin': gremlin  # gremlin wil always be a gremlin lang string script
-        }
-        for k, v in fields.items():
-            message[k] = self._graphson_writer.to_dict(v)
-        return self.finalize_message(message)
-
-    def finalize_message(self, message):
-        message = json.dumps(message)
-        return message
-
-    def deserialize_message(self, message, is_first_chunk=False):
-        if is_first_chunk:
-            msg = json.loads(message if isinstance(message, str) else message.decode('utf-8'))
-            return self._graphson_reader.to_object(msg)
-        else:
-            # graphSON does not stream, all results are aggregated inside the first chunk
-            return ""
-
 """
 GraphBinaryV4
 """
@@ -100,23 +32,27 @@ class GraphBinarySerializersV4(object):
     DEFAULT_WRITER_CLASS = graphbinaryV4.GraphBinaryWriter
     DEFAULT_VERSION = b"application/vnd.graphbinary-v4.0"
 
-    max_int64 = 0xFFFFFFFFFFFFFFFF
-    header_struct = struct.Struct('>b32sBQQ')
-    header_pack = header_struct.pack
     int_pack = graphbinaryV4.int32_pack
-    int32_unpack = struct.Struct(">i").unpack
 
-    def __init__(self, reader=None, writer=None, version=None):
+    def __init__(self, reader=None, writer=None, version=None, pdt_registry=None):
         if not version:
             version = self.DEFAULT_VERSION
         self._version = version
         if not reader:
-            reader = self.DEFAULT_READER_CLASS()
+            reader = self.DEFAULT_READER_CLASS(pdt_registry=pdt_registry)
         self._graphbinary_reader = reader
         if not writer:
             writer = self.DEFAULT_WRITER_CLASS()
         self._graphbinary_writer = writer
-        self._bulked = False
+
+    def configure_pdt_registry(self, pdt_registry):
+        if self._graphbinary_reader.pdt_registry is None:
+            self._graphbinary_reader.pdt_registry = pdt_registry
+        else:
+            self._graphbinary_reader.pdt_registry._composite_adapters_by_name.update(pdt_registry._composite_adapters_by_name)
+            self._graphbinary_reader.pdt_registry._composite_adapters_by_class.update(pdt_registry._composite_adapters_by_class)
+            self._graphbinary_reader.pdt_registry._primitive_adapters_by_name.update(pdt_registry._primitive_adapters_by_name)
+            self._graphbinary_reader.pdt_registry._primitive_adapters_by_class.update(pdt_registry._primitive_adapters_by_class)
 
     @property
     def version(self):
@@ -153,58 +89,42 @@ class GraphBinarySerializersV4(object):
 
         return bytes(ba)
 
-    def deserialize_message(self, message, is_first_chunk=False):
-        if len(message) == 0:
-            return {'status': {'code': 204},
-                    'result': {'meta': {},
-                               'data': []}}
-
-        # for parsing string message via HTTP connections
-        b = io.BytesIO(base64.b64decode(message) if isinstance(message, str) else message)
-
-        if is_first_chunk:
-            b.read(1)  # version
-            self._bulked = b.read(1)[0] == 0x01
-
-        result, readable = self.read_payload(b)
-        if not readable:
-            return {
-                'result': {'meta': {},
-                           'data': result}
-            }
-        status_code = self.int32_unpack(b.read(4))[0]  # status code
-        status_msg = self._graphbinary_reader.to_object(b, graphbinaryV4.DataType.string, nullable=True)
-        status_ex = self._graphbinary_reader.to_object(b, graphbinaryV4.DataType.string, nullable=True)
-        # meta_attrs = self._graphbinary_reader.to_object(b, graphbinaryV4.DataType.map, nullable=False)
-
-        b.close()
-
-        msg = {'status': {'code': status_code,
-                          'message': status_msg,
-                          'exception': status_ex},
-               'result': {'meta': {},
-                          'data': result}}
-
-        return msg
-
-    def read_payload(self, buffer):
-        results = []
-        readable = True
-        while buffer.readable():  # find method or way to access readable bytes without using buffer.getvalue()
-            if buffer.tell() == len(buffer.getvalue()):
-                readable = False
+    def deserialize_response_stream(self, stream):
+        """
+        Yield each result item from a GraphBinary response stream as it is read
+        off the wire, then raise ``GremlinServerError`` if the trailing status
+        is not a success code. ``Connection._receive`` dispatches through this
+        method so custom response serializers can replace GraphBinary parsing.
+        """
+        reader = self._graphbinary_reader
+
+        # Response header: version byte + flags byte
+        stream.read(1)
+        flags = stream.read(1)[0]
+        bulked = flags == 0x01
+
+        while True:
+            obj = reader.to_object(stream)
+            if obj == Marker.end_of_stream():
                 break
-            if self._bulked:
-                item = self._graphbinary_reader.to_object(buffer)
-                if item == Marker.end_of_stream():
-                    self._bulked = False  # no more data expected, reset bulked flag
-                    break
-                bulk = self._graphbinary_reader.to_object(buffer)
-                results.append(Traverser(item, bulk))
+            if bulked:
+                bulk = reader.to_object(stream)
+                yield Traverser(obj, bulk)
             else:
-                data = self._graphbinary_reader.to_object(buffer)
-                if data == Marker.end_of_stream():
-                    break
-                results.append(data)
-
-        return results, readable
+                yield obj
+
+        # Trailer: status code, message, exception
+        status_code = graphbinaryV4.int32_unpack(stream.read(4))
+        msg_is_null = stream.read(1)[0] == 0x01
+        status_message = '' if msg_is_null else reader.to_object(
+            stream, graphbinaryV4.DataType.string, False)
+        exc_is_null = stream.read(1)[0] == 0x01
+        status_exception = '' if exc_is_null else reader.to_object(
+            stream, graphbinaryV4.DataType.string, False)
+
+        if status_code not in (200, 204):
+            raise GremlinServerError({
+                'code': status_code,
+                'message': status_message,
+                'exception': status_exception
+            })

gremlin_python/driver/transaction.py

@@ -0,0 +1,178 @@
+#
+# 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
+
+from gremlin_python.driver.remote_connection import RemoteConnection, RemoteTraversal
+
+log = logging.getLogger("gremlinpython")
+
+
+class Transaction:
+    """Controls an explicit remote transaction. A thin wrapper around a Client
+    that adds transaction lifecycle (begin/commit/rollback/close) and attaches
+    a transactionId to every request.
+
+    Created via Client.transact() or g.tx(). The traversal source (g alias)
+    is inherited from the Client and cannot be changed.
+
+    Transactions are short-lived and single-use. After commit or rollback,
+    the transaction ID is invalid and the object cannot be reused.
+
+    This class is NOT thread-safe.
+    """
+
+    def __init__(self, client):
+        self._client = client
+        self._transaction_id = None
+        self._is_open = False
+        self._failed = False
+
+    def begin(self):
+        """Starts the transaction and returns a transaction-bound GraphTraversalSource.
+
+        The returned GTS can be used to submit traversals within this transaction.
+        Users of the driver-level API (client.transact()) may ignore the return
+        value and use submit() directly instead.
+
+        begin() is idempotent: calling it while a transaction is already open does not
+        send a second begin to the server and does not raise - it reuses the existing
+        transaction ID and returns a source bound to the same transaction. A transaction
+        is single-use, so calling begin() after it has been closed raises.
+        """
+        if self._failed:
+            raise Exception("Transaction is closed and cannot be reused; begin a new transaction")
+
+        # idempotent: if a transaction is already open, reuse the existing transactionId without
+        # sending a second begin to the server, and return a source bound to the same transaction
+        if not self._is_open:
+            try:
+                result = self._client.submit("g.tx().begin()")
+                results = result.all().result()
+            except Exception:
+                self._failed = True
+                raise
+
+            if not results:
+                self._failed = True
+                raise Exception("Server did not return transaction ID")
+
+            result_map = results[0]
+            if isinstance(result_map, dict):
+                self._transaction_id = result_map.get('transactionId')
+            else:
+                self._failed = True
+                raise Exception("Server did not return transaction ID in expected format")
+
+            if not self._transaction_id:
+                self._failed = True
+                raise Exception("Server returned empty transaction ID")
+
+            self._is_open = True
+            self._client.track_transaction(self)
+
+        # Return a GraphTraversalSource bound to this transaction via
+        # TransactionRemoteConnection. Inline imports avoid circular dependencies
+        # between driver/ and process/ packages.
+        from gremlin_python.process.graph_traversal import GraphTraversalSource
+        from gremlin_python.process.traversal import TraversalStrategies, GremlinLang
+        from gremlin_python.driver.remote_connection import RemoteStrategy
+
+        tx_connection = TransactionRemoteConnection(self)
+        strategies = TraversalStrategies()
+        strategies.add_strategies([RemoteStrategy(tx_connection)])
+        return GraphTraversalSource(None, strategies, GremlinLang())
+
+    def submit(self, gremlin, parameters=None, request_options=None):
+        """Submits a gremlin-lang string within this transaction.
+
+        The transactionId is automatically attached. Has the same signature
+        as Client.submit() so both can be used interchangeably.
+        """
+        if not self._is_open:
+            raise Exception("Transaction is not open")
+        opts = {'transactionId': self._transaction_id}
+        if request_options:
+            opts.update(request_options)
+        return self._client.submit(gremlin, parameters=parameters, request_options=opts)
+
+    def commit(self):
+        """Commits the transaction."""
+        self._close_transaction("g.tx().commit()")
+
+    def rollback(self):
+        """Rolls back the transaction."""
+        self._close_transaction("g.tx().rollback()")
+
+    def _close_transaction(self, script):
+        if not self._is_open:
+            raise Exception("Transaction is not open")
+        self._client.submit(script, request_options={'transactionId': self._transaction_id}).all().result()
+        self._is_open = False
+        self._failed = True  # Terminal state: transaction cannot be reused
+        self._client.untrack_transaction(self)
+
+    @property
+    def is_open(self):
+        return self._is_open
+
+    @property
+    def transaction_id(self):
+        return self._transaction_id
+
+    def close(self):
+        if self._is_open:
+            self.rollback()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._is_open:
+            self.rollback()
+        return False
+
+
+class TransactionRemoteConnection(RemoteConnection):
+    """A RemoteConnection that attaches transactionId to all requests submitted
+    through the traversal API (g.tx().begin() -> gtx.addV()...).
+
+    This bridges the traversal machinery (which calls RemoteConnection.submit)
+    to the Transaction (which injects the transactionId).
+    """
+
+    def __init__(self, transaction):
+        super().__init__(
+            transaction._client._url,
+            transaction._client._traversal_source)
+        self._transaction = transaction
+
+    def submit(self, gremlin_lang):
+        if not self._transaction.is_open:
+            raise Exception("Transaction is not open")
+
+        from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
+        request_options = DriverRemoteConnection.extract_request_options(gremlin_lang)
+        request_options['transactionId'] = self._transaction.transaction_id
+
+        result_set = self._transaction._client.submit(
+            gremlin_lang.get_gremlin(), request_options=request_options)
+        return RemoteTraversal(result_set)
+
+    def is_closed(self):
+        return not self._transaction.is_open

gremlin_python/driver/useragent.py

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