e6data-python-connector 3.0.1rc3__py3-none-any.whl → 3.0.2__py3-none-any.whl

e6data_python_connector/async_cluster_manager.py

@@ -123,10 +123,15 @@ class AsyncClusterManager:
         options = dict(grpc_options or {})
         if any(key.removeprefix('grpc.') in ('ssl_target_name_override', 'default_authority') for key in options):
             raise ValueError('TLS authority overrides are unsupported.')
-        limit = options.get('grpc.max_receive_message_length', 64 * 1024 * 1024)
-        if isinstance(limit, bool) or not isinstance(limit, int) or limit <= 0:
-            raise ValueError('A finite positive receive limit is required.')
-        options['grpc.max_receive_message_length'] = limit
+        for name in ('max_receive_message_length', 'max_send_message_length'):
+            limits = [options.pop(key) for key in (name, 'grpc.' + name) if key in options]
+            for limit in limits:
+                if (isinstance(limit, bool) or not isinstance(limit, int)
+                        or (limit != -1 and limit <= 0)):
+                    raise ValueError(name + ' must be -1 (unlimited) or a positive integer.')
+            if len(limits) == 2 and limits[0] != limits[1]:
+                raise ValueError('Conflicting ' + name + ' options.')
+            options['grpc.' + name] = limits[0] if limits else -1
         self._host, self._port = host, port
         self._user, self._password = user, password
         self._secure_channel, self._ssl_cert = secure_channel, ssl_cert

e6data_python_connector/async_connection.py

@@ -14,6 +14,9 @@ from .oauth_common import validate_positive_timeout, validate_token_endpoint
 from .server import e6x_engine_pb2 as pb, e6x_engine_pb2_grpc as bindings
 
 
+_UNSET_RECEIVE_MESSAGE_BYTES = object()
+
+
 @dataclass(frozen=True)
 class QueryRoute:
     target: str
@@ -50,7 +53,7 @@ class AsyncConnection:
                  token_url=None, oauth_scope=None, access_token=None,
                  client_auth_method='basic', *, operation_timeout=600.0,
                  oauth_timeout=10.0, cleanup_timeout=10.0, auto_resume_timeout=300.0,
-                 max_receive_message_bytes=64 * 1024 * 1024,
+                 max_receive_message_bytes=_UNSET_RECEIVE_MESSAGE_BYTES,
                  enable_result_batch_v2=False):
         from .result_decode_worker import is_decode_worker
         if is_decode_worker():
@@ -98,14 +101,31 @@ class AsyncConnection:
         for name, value in [('operation_timeout', operation_timeout), ('oauth_timeout', oauth_timeout),
                             ('cleanup_timeout', cleanup_timeout), ('auto_resume_timeout', auto_resume_timeout)]:
             settings[name] = validate_positive_timeout(value, name)
-        if isinstance(max_receive_message_bytes, bool) or not isinstance(max_receive_message_bytes, int) or max_receive_message_bytes <= 0:
-            raise ValueError('max_receive_message_bytes must be a positive integer.')
         options = dict(grpc_options or {})
-        for name in ('max_receive_message_length', 'grpc.max_receive_message_length'):
-            if name in options:
-                if options[name] != max_receive_message_bytes:
-                    raise ValueError('Set the finite receive limit using max_receive_message_bytes.')
-                del options[name]
+        receive_names = ('max_receive_message_length', 'grpc.max_receive_message_length')
+        receive_values = [options.pop(name) for name in receive_names if name in options]
+        for value in receive_values:
+            if (isinstance(value, bool) or not isinstance(value, int)
+                    or (value != -1 and value <= 0)):
+                raise ValueError('max_receive_message_length must be -1 (unlimited) or a positive integer.')
+        if len(receive_values) == 2 and receive_values[0] != receive_values[1]:
+            raise ValueError('Conflicting max_receive_message_length options.')
+        if max_receive_message_bytes is _UNSET_RECEIVE_MESSAGE_BYTES:
+            max_receive_message_bytes = receive_values[0] if receive_values else -1
+        if (isinstance(max_receive_message_bytes, bool) or not isinstance(max_receive_message_bytes, int)
+                or (max_receive_message_bytes != -1 and max_receive_message_bytes <= 0)):
+            raise ValueError('max_receive_message_bytes must be -1 (unlimited) or a positive integer.')
+        if receive_values and receive_values[0] != max_receive_message_bytes:
+            raise ValueError('Set the receive limit using max_receive_message_bytes; supplied options must agree.')
+        send_names = ('max_send_message_length', 'grpc.max_send_message_length')
+        send_values = [options.pop(name) for name in send_names if name in options]
+        for value in send_values:
+            if (isinstance(value, bool) or not isinstance(value, int)
+                    or (value != -1 and value <= 0)):
+                raise ValueError('max_send_message_length must be -1 (unlimited) or a positive integer.')
+        if len(send_values) == 2 and send_values[0] != send_values[1]:
+            raise ValueError('Conflicting max_send_message_length options.')
+        options['grpc.max_send_message_length'] = send_values[0] if send_values else -1
         # Authority overrides can disable meaningful server identity validation.
         if any(name.removeprefix('grpc.') in ('ssl_target_name_override', 'default_authority') for name in options):
             raise ValueError('TLS authority overrides are unsupported.')
@@ -385,6 +405,8 @@ class AsyncConnection:
 
             self._cluster_manager = AsyncClusterManager(
                 self.host, self.port, user=self.username or '', password=self.password or '',
+                grpc_options={**self.grpc_options,
+                              'grpc.max_receive_message_length': self.max_receive_message_bytes},
                 secure_channel=self.secure, cluster_uuid=self.cluster_name,
                 ssl_cert=self.ssl_cert, metadata_provider=metadata_provider if self._oauth_enabled else None,
                 initial_strategy=self.strategy, auto_resume_timeout=self.auto_resume_timeout,

e6data_python_connector/async_connection_pool.py

@@ -189,6 +189,8 @@ class AsyncConnectionPool:
             from .async_cluster_manager import AsyncClusterManager
             self._cluster_manager = AsyncClusterManager(
                 config.host, config.port, user=config.username or '', password=config.password or '',
+                grpc_options={**config.grpc_options,
+                              'grpc.max_receive_message_length': config.max_receive_message_bytes},
                 secure_channel=config.secure, ssl_cert=config.ssl_cert,
                 cluster_uuid=config.cluster_name, initial_strategy='blue',
                 metadata_provider=self._resume_metadata if config._oauth_enabled else None,

e6data_python_connector/async_cursor.py

@@ -129,7 +129,7 @@ class AsyncCursor:
         if self._state == 'CLOSED':
             raise ProgrammingError('Cursor is closed.')
         if fetch and self._failure is not None:
-            raise self._failure
+            raise IncompleteResultError(self._failure.reason, query_id=self._failure.query_id)
         if fetch and self._state in ('EMPTY', 'SUBMISSION_UNKNOWN'):
             raise ProgrammingError('No complete query is available for fetching.')
 
@@ -172,12 +172,13 @@ class AsyncCursor:
         self._retire_prefetch()
         self._cancel_decode()
         if self._failure is None:
+            # Never raise this template: its traceback would retain decoded inputs.
             self._failure = IncompleteResultError(reason, query_id=self.query_id)
         if self._state != 'CLOSED':
             self._state = 'RESULT_FAILED'
         self._rows.clear()
         self._result_batches.clear()
-        return self._failure
+        return IncompleteResultError(self._failure.reason, query_id=self._failure.query_id)
 
     def _accept_rows(self, rows):
         self._rows.extend(rows)

e6data_python_connector/cluster_manager.py

@@ -205,9 +205,10 @@ class ClusterManager:
         self._timeout = time.time() + timeout
         self._secure_channel = secure_channel
         self.cluster_uuid = cluster_uuid
-        self._grpc_options = grpc_options
-        if grpc_options is None:
-            self._grpc_options = dict()
+        options = dict(grpc_options or ())
+        options.setdefault('grpc.max_receive_message_length', -1)
+        options.setdefault('grpc.max_send_message_length', -1)
+        self._grpc_options = list(options.items())
         self._debug = debug
         self._ssl_cert = ssl_cert
         self._metadata_provider = metadata_provider

e6data_python_connector/datainputstream.py

@@ -478,6 +478,8 @@ def read_values_from_array(query_columns_description: list, dis: DataInputStream
         try:
             if dtype == "LONG":
                 value_array.append(dis.read_long())
+            elif dtype == "INTERVAL_DAY_SECOND":
+                value_array.append(timedelta(microseconds=dis.read_long()))
             elif dtype == "DATE":
                 value_array.append(format_iso_date_from_epoch_micros(dis.read_long()))
             elif dtype == "DATETIME":
@@ -582,6 +584,15 @@ def get_column_from_chunk(vector: Vector, strict=False) -> list:
                     continue
                 value_array.append(vector.data.int64Data.data[
                                        row] if not vector.isConstantVector else vector.data.numericConstantData.data)
+        elif d_type == VectorType.INTERVAL_DAY_SECOND:
+            for row in range(vector.size):
+                if get_null(vector, row):
+                    value_array.append(None)
+                    continue
+                microseconds = (vector.data.int64Data.data[row]
+                                if not vector.isConstantVector
+                                else vector.data.numericConstantData.data)
+                value_array.append(timedelta(microseconds=microseconds))
         elif d_type == VectorType.DATE:
             # Use the JDBC-parity formatter so years > 9999 emit "+YYYYY-MM-DD"
             # instead of raising. Per-row try/except keeps a single bad value

e6data_python_connector/e6data_grpc.py

@@ -521,17 +521,18 @@ class Connection(object):
         if enable_result_batch_v2:
             from .result_decode import validate_decode_runtime
             validate_decode_runtime()
-            normalized = {}
-            for key, value in (grpc_options or {}).items():
-                key = key[5:] if key.startswith('grpc.') else key
-                if key in normalized and normalized[key] != value:
-                    raise ValueError('Conflicting gRPC options after prefix normalization.')
-                normalized[key] = value
-            limit = normalized.get('max_receive_message_length', 64 * 1024 * 1024)
-            if isinstance(limit, bool) or not isinstance(limit, int) or limit <= 0:
-                raise ValueError('V2 receive limit must be a finite positive integer.')
+        normalized = {}
+        for key, value in (grpc_options or {}).items():
+            key = key[5:] if key.startswith('grpc.') else key
+            if key in normalized and normalized[key] != value:
+                raise ValueError('Conflicting gRPC options after prefix normalization.')
+            normalized[key] = value
+        grpc_options = normalized
+        if enable_result_batch_v2:
+            limit = normalized.get('max_receive_message_length', -1)
+            if isinstance(limit, bool) or not isinstance(limit, int) or (limit != -1 and limit <= 0):
+                raise ValueError('V2 receive limit must be a positive integer or -1 for unlimited.')
             normalized['max_receive_message_length'] = limit
-            grpc_options = normalized
         if enable_result_batch_v2 and grpc_options is not None and 'grpc_prepare_timeout' in grpc_options:
             timeout = grpc_options['grpc_prepare_timeout']
             if (isinstance(timeout, bool) or not isinstance(timeout, (int, float))
@@ -696,7 +697,7 @@ class Connection(object):
             default_options = {
                 "keepalive_timeout_ms": 900000,  # Time in milliseconds to keep the connection alive.
                 "max_receive_message_length": -1,  # Maximum size of received messages.
-                "max_send_message_length": 300 * 1024 * 1024,  # Maximum size of sent messages (300 MB).
+                "max_send_message_length": -1,  # Unlimited sent message size.
                 "grpc_prepare_timeout": self.grpc_prepare_timeout,  # Timeout for prepare statement API call.
                 "keepalive_time_ms": 30000,  # Time in milliseconds between keep-alive pings.
                 "keepalive_permit_without_calls": 1,  # Allow keep-alives with no active RPCs.
@@ -1032,6 +1033,7 @@ class Connection(object):
                     cluster_uuid=self.cluster_name,
                     timeout=self.grpc_auto_resume_timeout_seconds,
                     debug=self._debug,
+                    grpc_options=self._get_grpc_options,
                     ssl_cert=self._ssl_cert
                 ).resume()
                 return status  # Return boolean status directly
@@ -1709,7 +1711,9 @@ class Cursor(DBAPICursor):
                 self._result_failure = IncompleteResultError(reason, query_id=self._query_id)
             self._data = None
             self._result_batches.clear()
-            return self._result_failure
+            # Keep the cached template free of tracebacks and response frames.
+            return IncompleteResultError(
+                self._result_failure.reason, query_id=self._result_failure.query_id)
 
     def _check_result(self):
         if self._result_batch_v2_enabled and (self._result_pid != os.getpid() or
@@ -1720,7 +1724,8 @@ class Cursor(DBAPICursor):
         if self._closed:
             raise ProgrammingError('Cursor is closed.')
         if self._result_failure is not None:
-            raise self._result_failure
+            raise IncompleteResultError(
+                self._result_failure.reason, query_id=self._result_failure.query_id)
 
     @property
     def query_id(self):

e6data_python_connector/e6x_vector/ttypes.py

@@ -35,6 +35,7 @@ class VectorType(object):
     NULL = 14
     TIMESTAMP_TZ = 15
     DECIMAL128 = 16
+    INTERVAL_DAY_SECOND = 17
 
     _VALUES_TO_NAMES = {
         0: "BINARY",
@@ -54,6 +55,7 @@ class VectorType(object):
         14: "NULL",
         15: "TIMESTAMP_TZ",
         16: "DECIMAL128",
+        17: "INTERVAL_DAY_SECOND",
     }
 
     _NAMES_TO_VALUES = {
@@ -74,6 +76,7 @@ class VectorType(object):
         "NULL": 14,
         "TIMESTAMP_TZ": 15,
         "DECIMAL128": 16,
+        "INTERVAL_DAY_SECOND": 17,
     }
 
 

e6data_python_connector/result_decode.py

@@ -32,6 +32,32 @@ class ResultDecodeError(ValueError):
     """A worker failed before a complete envelope could be published."""
 
 
+class _WorkerTransportError(ResultDecodeError):
+    """Only worker exit and pipe I/O failures permit a local sequential retry."""
+
+    def __init__(self, stage, index, pid, exitcode=None, exception_type=None):
+        self.stage = stage
+        self.index = index
+        self.pid = pid
+        self.exitcode = exitcode
+        self.exception_type = exception_type
+        super().__init__(
+            'Decode worker unavailable: stage=%s worker=%s pid=%s exitcode=%s error_type=%s.'
+            % (stage, index, pid, exitcode, exception_type))
+
+
+def _detached_error(error):
+    """Keep safe failure metadata without retaining result-bearing tracebacks."""
+    if isinstance(error, _WorkerTransportError):
+        return _WorkerTransportError(error.stage, error.index, error.pid,
+                                     error.exitcode, error.exception_type)
+    if isinstance(error, TimeoutError):
+        return TimeoutError('Result decoding deadline exceeded.')
+    if isinstance(error, ResultDecodeError):
+        return ResultDecodeError(str(error))
+    return ResultDecodeError('Result decoder failed (%s).' % type(error).__name__)
+
+
 class _DecodeOwner:
     """One lease's cancellation latch for one envelope, with identity semantics."""
 
@@ -81,6 +107,7 @@ class _Slot:
         self.error = None
 
     def io(self):
+        stage = 'handshake'
         try:
             ready = self.channel.recv()
             if not isinstance(ready, tuple) or len(ready) != 2 or ready[0] != 'ready':
@@ -94,16 +121,22 @@ class _Slot:
             # so it cannot wait forever on the now-empty queue.
             while self.runtime.state in ('starting', 'ready'):
                 job = self.jobs.get()
+                stage = 'send'
                 self.channel.send(job)
                 if job is None:
                     return
+                stage = 'receive'
                 result = self.channel.recv()
                 with self.runtime.condition:
                     self.result = result
                     self.runtime.condition.notify_all()
         except (Exception, SystemExit) as error:
             with self.runtime.condition:
-                self.error = error
+                if isinstance(error, (EOFError, OSError)):
+                    self.error = _WorkerTransportError(
+                        stage, self.index, self.pid, exception_type=type(error).__name__)
+                else:
+                    self.error = _detached_error(error)
                 self.runtime.condition.notify_all()
 
 
@@ -115,6 +148,7 @@ class _Runtime:
         self.state = 'starting'
         self.error = None
         self._active = None
+        self._active_cancelled = False
         self._sequence = 0
         self.cleanup_thread = None
         self.stopped = threading.Event()
@@ -125,17 +159,23 @@ class _Runtime:
     def pids(self):
         return tuple(slot.pid for slot in self.slots if slot.pid is not None)
 
-    def _worker_failed(self):
+    def _worker_failure(self):
+        # A protocol failure remains fatal even if another worker exits.
+        for slot in self.slots:
+            if slot.error is not None and not isinstance(slot.error, _WorkerTransportError):
+                return _detached_error(slot.error)
         for slot in self.slots:
-            if slot.error is not None:
-                return True
             if slot.process is not None and slot.pid is not None:
                 try:
                     if wait([slot.process.sentinel], timeout=0):
-                        return True
-                except (ValueError, OSError):
-                    return True
-        return False
+                        return _WorkerTransportError('exit', slot.index, slot.pid,
+                                                     exitcode=slot.process.exitcode)
+                except (ValueError, OSError) as error:
+                    return ResultDecodeError('Decode worker health check failed (%s).'
+                                             % type(error).__name__)
+            if slot.error is not None:
+                return _detached_error(slot.error)
+        return None
 
     def start(self, deadline):
         try:
@@ -144,7 +184,7 @@ class _Runtime:
                 _remaining(deadline)
                 with self.condition:
                     if self.error is not None:
-                        raise self.error
+                        raise _detached_error(self.error)
                     if self.state != 'starting':
                         raise ResultDecodeError('Decoder closed during worker startup.')
                 slot = _Slot(self, index)
@@ -164,20 +204,21 @@ class _Runtime:
             with self.condition:
                 while not all(slot.ready for slot in self.slots):
                     if self.error is not None:
-                        raise self.error
-                    if self._worker_failed():
-                        raise ResultDecodeError('Decode worker failed before startup completed.')
+                        raise _detached_error(self.error)
+                    failure = self._worker_failure()
+                    if failure is not None:
+                        raise failure
                     self.condition.wait(min(.02, _remaining(deadline)))
                 _remaining(deadline)
                 if self.error is not None:
-                    raise self.error
+                    raise _detached_error(self.error)
                 if self.state != 'starting':
                     raise ResultDecodeError('Decoder closed during worker startup.')
                 self.state = 'ready'
                 self.startup_done.set()
                 self.condition.notify_all()
         except BaseException as error:
-            self.startup_error = error
+            self.startup_error = _detached_error(error)
             self.startup_done.set()
             self.quarantine(error, deadline)
             self.stopped.wait(max(0, deadline - time.monotonic()))
@@ -188,13 +229,13 @@ class _Runtime:
             while not self.startup_done.is_set():
                 self.condition.wait(min(.02, _remaining(deadline)))
             if self.startup_error is not None:
-                raise self.startup_error
+                raise _detached_error(self.startup_error)
             # A runtime that failed after startup is usable only sequentially.
 
     def quarantine(self, error, deadline=None):
         with self.condition:
             if self.error is None:
-                self.error = error
+                self.error = _detached_error(error)
             self.state = 'failed'
             self.condition.notify_all()
             self._request_cleanup(deadline if deadline is not None else time.monotonic() + .5)
@@ -244,6 +285,13 @@ class _Runtime:
                 slot.thread.join()
             if slot.process is not None:
                 slot.process.close()
+            # No I/O thread can add another result or retain a queued job now.
+            slot.result = None
+            while True:
+                try:
+                    slot.jobs.get_nowait()
+                except queue.Empty:
+                    break
         with self.condition:
             self.state = 'closed'
             self.stopped.set()
@@ -258,6 +306,7 @@ class _Runtime:
                 owner.cancelled = True
             active = self._active
             if active is not None and active[0] is lease and (owner is None or active[1] is owner):
+                self._active_cancelled = True
                 self.quarantine(ResultDecodeError('Result decoding was cancelled.'))
 
     def release(self, lease, deadline, wait=True):
@@ -276,20 +325,26 @@ class _Runtime:
             _logger.debug('result_decode cleanup=%s workers=%d',
                           'stopped' if self.stopped.is_set() else 'pending', len(self.pids))
 
+    def _check_decode(self, lease, owner, deadline):
+        _remaining(deadline)
+        if lease._closed:
+            raise ValueError('Decoder lease is closed.')
+        if isinstance(owner, _DecodeOwner):
+            if owner.lease is not lease:
+                raise ValueError('Decode owner belongs to another lease.')
+            if owner.cancelled:
+                raise ResultDecodeError('Result decoding was cancelled.')
+        if (self._active is not None and self._active[0] is lease
+                and self._active[1] is owner and self._active_cancelled):
+            raise ResultDecodeError('Result decoding was cancelled.')
+
     def decode(self, lease, columns, payloads, deadline, owner):
         started = time.monotonic()
         mode, fallback = 'sequential', 'single_chunk'
         admitted = False
         try:
             with self.condition:
-                _remaining(deadline)
-                if lease._closed:
-                    raise ValueError('Decoder lease is closed.')
-                if isinstance(owner, _DecodeOwner):
-                    if owner.lease is not lease:
-                        raise ValueError('Decode owner belongs to another lease.')
-                    if owner.cancelled:
-                        raise ResultDecodeError('Result decoding was cancelled.')
+                self._check_decode(lease, owner, deadline)
                 if len(payloads) > 1:
                     if self.state != 'ready':
                         fallback = 'unavailable'
@@ -299,29 +354,52 @@ class _Runtime:
                         fallback = 'decimal_context'
                     else:
                         self._active = (lease, owner)
+                        self._active_cancelled = False
                         self._sequence += 1
                         token = self._sequence
                         admitted = True
                         mode, fallback = 'parallel', 'none'
             if not admitted:
                 chunks = decode_result_batches(columns, payloads)
-                _remaining(deadline)
-                return chunks
-            try:
-                return self._parallel(columns, payloads, deadline, token)
-            except BaseException as error:
-                self.quarantine(error, deadline)
-                raise
+            else:
+                original_flags = dict(decimal.getcontext().flags)
+                try:
+                    chunks = self._parallel(columns, payloads, deadline, token, lease, owner)
+                except _WorkerTransportError as error:
+                    # Retire both processes and I/O threads before decoding the
+                    # complete already-downloaded envelope in the caller.
+                    self.quarantine(error, deadline)
+                    _logger.warning('result_decode recovery=started %s', error)
+                    error.__traceback__ = None
+                    while not self.stopped.is_set():
+                        with self.condition:
+                            self._check_decode(lease, owner, deadline)
+                        self.stopped.wait(min(.02, _remaining(deadline)))
+                    with self.condition:
+                        self._check_decode(lease, owner, deadline)
+                    decimal.getcontext().flags = original_flags
+                    mode, fallback = 'sequential', 'worker_transport'
+                    chunks = decode_result_batches(columns, payloads)
+                    with self.condition:
+                        self._check_decode(lease, owner, deadline)
+                    _logger.debug('result_decode recovery=complete chunks=%d', len(payloads))
+                except BaseException as error:
+                    self.quarantine(error, deadline)
+                    raise
+            with self.condition:
+                self._check_decode(lease, owner, deadline)
+            return chunks
         finally:
             if admitted:
                 with self.condition:
                     self._active = None
+                    self._active_cancelled = False
                     self.condition.notify_all()
             _logger.debug('result_decode mode=%s wall_ms=%.3f chunks=%d workers=%d fallback=%s cleanup=%s',
                           mode, (time.monotonic() - started) * 1000, len(payloads),
                           2 if admitted else 0, fallback, self.state)
 
-    def _parallel(self, columns, payloads, deadline, token):
+    def _parallel(self, columns, payloads, deadline, token, lease, owner):
         # The existing vector decoder uses only the number of columns. Plain
         # positions preserve that contract without serializing FieldInfo objects.
         metadata = tuple(range(len(columns)))
@@ -330,39 +408,51 @@ class _Runtime:
         output = [None] * len(payloads)
         pending = {}
         next_index = 0
-        with self.condition:
-            while pending or next_index < len(payloads):
-                _remaining(deadline)
-                if self.error is not None:
-                    raise self.error
-                if self._worker_failed():
-                    raise ResultDecodeError('Decode worker exited before returning a complete result.')
-                for slot in self.slots:
-                    if slot.index in pending and slot.result is not None:
-                        result, slot.result = slot.result, None
-                        index = pending.pop(slot.index)
-                        if (not isinstance(result, tuple) or len(result) != 5 or
-                                result[1] != token or result[2] != index):
-                            raise ResultDecodeError('Decode worker returned an invalid job result.')
-                        flags = result[4]
-                        if not isinstance(flags, tuple) or any(name not in decimal_signals for name in flags):
-                            raise ResultDecodeError('Decode worker returned invalid decimal flags.')
-                        for name in flags:
-                            context.flags[decimal_signals[name]] = True
-                        if result[0] == 'error':
-                            raise ResultDecodeError('Result chunk decoding failed in worker (%s).' % result[3])
-                        if result[0] != 'result':
-                            raise ResultDecodeError('Decode worker returned an invalid result kind.')
-                        output[index] = result[3]
-                    if slot.index not in pending and next_index < len(payloads):
-                        index = next_index
-                        next_index += 1
-                        pending[slot.index] = index
-                        slot.jobs.put_nowait((token, index, metadata, payloads[index]))
-                if pending:
-                    self.condition.wait(min(.02, _remaining(deadline)))
-            _remaining(deadline)
-        return [rows for rows in output if rows]
+        result = None
+        try:
+            with self.condition:
+                while pending or next_index < len(payloads):
+                    self._check_decode(lease, owner, deadline)
+                    if self.error is not None:
+                        raise _detached_error(self.error)
+                    # Validate available replies before considering recovery, so
+                    # a worker/protocol error is never hidden by a second exit.
+                    for slot in self.slots:
+                        if slot.index in pending and slot.result is not None:
+                            result, slot.result = slot.result, None
+                            index = pending.pop(slot.index)
+                            if (not isinstance(result, tuple) or len(result) != 5 or
+                                    result[1] != token or result[2] != index):
+                                raise ResultDecodeError('Decode worker returned an invalid job result.')
+                            flags = result[4]
+                            if not isinstance(flags, tuple) or any(name not in decimal_signals for name in flags):
+                                raise ResultDecodeError('Decode worker returned invalid decimal flags.')
+                            for name in flags:
+                                context.flags[decimal_signals[name]] = True
+                            if result[0] == 'error':
+                                raise ResultDecodeError('Result chunk decoding failed in worker (%s).' % result[3])
+                            if result[0] != 'result':
+                                raise ResultDecodeError('Decode worker returned an invalid result kind.')
+                            output[index] = result[3]
+                    failure = self._worker_failure()
+                    if failure is not None:
+                        raise failure
+                    for slot in self.slots:
+                        if slot.index not in pending and next_index < len(payloads):
+                            index = next_index
+                            next_index += 1
+                            pending[slot.index] = index
+                            slot.jobs.put_nowait((token, index, metadata, payloads[index]))
+                    if pending:
+                        self.condition.wait(min(.02, _remaining(deadline)))
+                self._check_decode(lease, owner, deadline)
+                return [rows for rows in output if rows]
+        finally:
+            # Fatal errors may keep their traceback for the caller. Do not let
+            # that traceback also retain partial decoded output or pending jobs.
+            output.clear()
+            pending.clear()
+            result = None
 
 
 class DecoderLease:

{e6data_python_connector-3.0.1rc3.dist-info → e6data_python_connector-3.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e6data-python-connector
-Version: 3.0.1rc3
+Version: 3.0.2
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -489,11 +489,15 @@ workers use the explicit `spawn` method; the application's global multiprocessin
 start method is unchanged. An unguarded main script can run its other import
 side effects, so keep all application startup inside the guard.
 
-Both APIs default to a 64 MiB receive limit when V2 is enabled. A positive finite
-custom limit is allowed; unlimited receive sizes are rejected for V2. The sync
-flag-off path keeps its existing options. For async, set
-`max_receive_message_bytes`; any receive limit in `grpc_options` must agree.
-Choose limits from measured envelope sizes and the client's memory budget.
+Both APIs default to unlimited gRPC send and receive message sizes (`-1`).
+Explicit positive byte limits are still honored. For sync, set
+`max_receive_message_length` and `max_send_message_length` in `grpc_options`.
+For async, set the receive limit with `max_receive_message_bytes` or
+`max_receive_message_length` in `grpc_options`; if both are supplied, they must
+agree. Set `max_send_message_length` in `grpc_options` for the send limit.
+The receive limit applies to each message after transport decompression, not the
+total query result. Unlimited receiving does not limit client memory use;
+continuous downloading can retain serialized batches while decoding catches up.
 
 These examples use your existing `connection_options`, `sql`, and `consume`:
 
@@ -567,6 +571,15 @@ downloading is faster than decoding or application reads. Workers add Python
 objects and process copies; the receive limit is not a limit on total memory.
 `fetchall()` still retains the full result.
 
+If a decoder worker exits or its local pipe breaks, the connector stops the
+failed workers and decodes that complete serialized envelope once in the parent
+process. It uses the same deadline and makes no extra result RPC. Continuous
+downloading stays active and uncapped during this recovery. Later envelopes use
+sequential decoding until the decoder runtime is replaced through its normal
+lifecycle. Cancellation, expired deadlines, invalid worker replies, and errors
+reported while decoding data are still failures. Their original cause is kept
+on the first error delivered to the caller.
+
 Only a V2 `UNIMPLEMENTED` response switches that query to V1 and disables its
 optimizations. Other RPC failures reach the caller as the original
 `grpc.RpcError` or `grpc.aio.AioRpcError`. A failed pending RPC is raised when

{e6data_python_connector-3.0.1rc3.dist-info → e6data_python_connector-3.0.2.dist-info}/RECORD

@@ -1,26 +1,26 @@
 e6data_python_connector/__init__.py,sha256=gA6M_1qwKwJmGfhSa_-s694bkIcnxtJtdY1shIxL0Oc,188
 e6data_python_connector/aio.py,sha256=aqBWuQ1G7zVJfWAJDiEb3stTTq0w58ACmZlPFGR8Ym8,930
-e6data_python_connector/async_cluster_manager.py,sha256=eVcECgmwhsxh-NFmJI04Gg1734grMQXe-eMxp275jzw,12562
-e6data_python_connector/async_connection.py,sha256=6E7ZYFtYCiqhfWuaugzgD0nJdHjs5p8zFv0HtKlSbYI,29524
-e6data_python_connector/async_connection_pool.py,sha256=ySsFAAVTEwKPY62qYokL_6XuHy8lph_x12AW1ccKduM,18930
-e6data_python_connector/async_cursor.py,sha256=DsQcENHWA_mpMTPfcnpYVmoUibebGLZd7bRKUTOmXtg,41777
+e6data_python_connector/async_cluster_manager.py,sha256=iNJNVNpISyxgQik5d8wOUys-pZ3r6RAq99NPYemrIOk,12891
+e6data_python_connector/async_connection.py,sha256=xK5gEjeU8htu-IM21KDtRP3S3mKAPs0OxF3m_IPa-1Q,31106
+e6data_python_connector/async_connection_pool.py,sha256=E_51RwZ3YMQCANKmWCw0_GNkZehgeF2NFVJ5IaK-aAY,19083
+e6data_python_connector/async_cursor.py,sha256=RO0RW1lkM22p2RPdVxI1JkczXHvwNNSTpe8cvYiqy4w,41987
 e6data_python_connector/async_dialect.py,sha256=4rC8G2VRl7Wd91if5YSEgOdUI6Y02M7voowMF5gMT0Y,11004
 e6data_python_connector/async_oauth.py,sha256=0AHXJYKZ7m1FIZEt98R93ARLBbQoAOUSMVJn3fdXGQ0,11405
 e6data_python_connector/async_work.py,sha256=DJxCoacbiEgzZDcEUnpEQfXU32z05TOn_2stV0Xd2VY,3814
-e6data_python_connector/cluster_manager.py,sha256=jlU0pxdUTLUGZbMk_Ud7f1pZdCOMVbMdqRcbcM-84AA,28727
+e6data_python_connector/cluster_manager.py,sha256=k7LbzKaX1thKiELm057X7JuOAtglPLlmoG6KhaYCxvQ,28835
 e6data_python_connector/common.py,sha256=dPUbTuX0nKYjDfhVxCLevv6RCxi35DXZVgFbdM5S9vI,11748
 e6data_python_connector/connection_pool.py,sha256=GNweiefokl36ve8riwBlPaBbw5aApy0_Pjm0iqZdqbY,17918
 e6data_python_connector/constants.py,sha256=AwACS9iUaYj84oRRHj9Waep9LGbNHxcE07BABV7s45Y,1406
-e6data_python_connector/datainputstream.py,sha256=y81KzLaP8yKRxhmJVgXxGBmtRHEyg19b5lgD9SM_9z0,29750
+e6data_python_connector/datainputstream.py,sha256=3bEXVV9LtKivpdV8Yy8FHS3GIcp4lR8HFyLWXKBIVnA,30364
 e6data_python_connector/date_time_utils.py,sha256=yjUWIx2QiGtE6Tp8hGIzh7nwF4wtJr9teB8FQ99B4TA,21305
 e6data_python_connector/dialect.py,sha256=vylcvLT2vkTZDVYA3MSHvaxqf7S-A2F9sGlLT4v9vxE,13239
-e6data_python_connector/e6data_grpc.py,sha256=JdVb9ylVXhj6PzDfZUulx4V6glvt33LFrVdmVXfh7GY,120604
+e6data_python_connector/e6data_grpc.py,sha256=ecc4C7grrs7T38WNUnwEfRFEw9q2brVwqHu_Y97qeOw,120912
 e6data_python_connector/exceptions.py,sha256=jU4C0B6zs_mBgzZ6H85KRs6Qe7QuQaWFhQjN9Xfwa1A,1504
 e6data_python_connector/oauth.py,sha256=7bMe0Wj4EpWSwYER1ny7oPtx5jEvD6Us9N8ACJB1Heo,8168
 e6data_python_connector/oauth_cache.py,sha256=jdPqp2XV0EEGHgzcBRXhTHntk1rf4VXWZZVbjhlyuk8,8403
 e6data_python_connector/oauth_common.py,sha256=m-7sMmgGQDanMqmUv21ASB0rVTrFs-vi7PzVRp-61qM,2935
 e6data_python_connector/result_batch.py,sha256=idiV2MZ1exZRlb3HSD6PlIRFQYjPmajXHm_WXenvlrI,1642
-e6data_python_connector/result_decode.py,sha256=f7G-bQjyeTNR7DnqcZI3B_mZiV27DMkpGZcr3EsOWhY,19468
+e6data_python_connector/result_decode.py,sha256=5yFh4cdkwuXlsAhByMvVCji76JSy8KrUCi54HouEThM,24293
 e6data_python_connector/result_decode_worker.py,sha256=ih5ErdeKFU4vy9mqqH_bwbrP8Q9JwtKNSNGwn5Ya6d0,1978
 e6data_python_connector/result_prefetch.py,sha256=22oXTyekVYc90jci0HFr8VMBlrO5JJd8FuPKTCvsCrw,14835
 e6data_python_connector/strategy.py,sha256=whAC-C031XFirP71hXKqdiMTJRIUUEvc34tuo2W8k-0,6539
@@ -30,7 +30,7 @@ e6data_python_connector/cluster_server/cluster_pb2.py,sha256=BWxO5vG1SVkx2y-i6A6
 e6data_python_connector/cluster_server/cluster_pb2_grpc.py,sha256=tfnRKs2GQGwdSH8zxT40yveN4XnD9j7aWHGUfGkPHiM,5399
 e6data_python_connector/e6x_vector/__init__.py,sha256=YFcZTT8Cm-6Y4oTiCaqq0DT1lw2W09WqoEc5_pTAwW0,34
 e6data_python_connector/e6x_vector/constants.py,sha256=E5Gsf7749sDKQedzdEsv-98HXUqUF8qM_THivZ34YBI,388
-e6data_python_connector/e6x_vector/ttypes.py,sha256=EwA4hsTDGd_oC4wpmwpRWzKwuvrX9-_Uj2TNtirkmnw,63669
+e6data_python_connector/e6x_vector/ttypes.py,sha256=ZMaRvOOiDMOD-UnS_G5GOmUcdc0YiH1MCuzKHE8D1R0,63768
 e6data_python_connector/server/QueryEngineService.py,sha256=IDX2Yi9m_QFZ8L4FoiYrl8i7YL8GjTRonblKKFZsapU,198503
 e6data_python_connector/server/__init__.py,sha256=8eK3WgN4xfJiSNm4bUrnXb5ZgjMUEjdStbUahQQrJII,56
 e6data_python_connector/server/constants.py,sha256=QPD8cJw4a7t7JD4PTzbxj1CZKZ1lQ0TPK2Uzg72S9dE,366
@@ -38,7 +38,7 @@ e6data_python_connector/server/e6x_engine_pb2.py,sha256=gAtG-MclLOc_uSrn5vRVMNJx
 e6data_python_connector/server/e6x_engine_pb2.pyi,sha256=NCDX-xF2ZH1Q5k-hg27yuow1ILWsJTCAg8YD-qTQ5kY,34815
 e6data_python_connector/server/e6x_engine_pb2_grpc.py,sha256=stzKD9uSKRAOLdpFMD-owJvunnxrXvhvJnHRCGjmDzU,75778
 e6data_python_connector/server/ttypes.py,sha256=uWxwSp4m6e-7SeSEckbZtSduGYmfzXWM09iy5eltBPA,21227
-e6data_python_connector-3.0.1rc3.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+e6data_python_connector-3.0.2.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
 test/__init__.py,sha256=s574pVF7fqLitVI45JvBdqBMN8DBmzHG-1Te-QcnUU0,47
 test/analyze_38_nines.py,sha256=99QMuCDMUoxh5LV9JgceYSZKlChhNS_2kaV56EQBv-A,3608
 test/analyze_all_cases.py,sha256=mEeN6E_7tTl_HP4UXbQ3vREO81mqVEaxl_QPTxc6Z5Q,4079
@@ -75,7 +75,7 @@ test/test_mock_server.py,sha256=RKRIgngbt28QDje0i2ushZ4zZj_N5GeM6d4L5ExHorw,6061
 test/test_multiprocessing_fix.py,sha256=Ql0mDOvtptS3Dl3wbwPLZ_N90fdK1MG9eqk4WHSMIfU,4238
 test/test_new_implementation.py,sha256=tjmQ4xLCmButPWIoIZm_DeWei8QkwI13XmbBlr3mBwY,5518
 test/test_oauth_authentication.py,sha256=grfkmnv_DbBTtpiBDguwpL71EtUNAMvdg5hl9k5j7z0,27199
-test/test_oauth_auto_resume.py,sha256=OcVDOJwV1gWBbSJ1ffjtX3U-FSOcoj3AmBfdMaS6-9k,21715
+test/test_oauth_auto_resume.py,sha256=OacdlcF8xCtoY6KmiFMXBPSEq4-lnBogu5n3qATvmpI,22060
 test/test_oauth_resume_integration.py,sha256=8tedzK-s7PsRqYKWRjNCJk8nvSw9QPq8PXjnObaH4Q0,11448
 test/test_pool_concurrency_simple.py,sha256=BMzEYgqNEH7UYE4PnNpvky0S_7ejlLOkiOjVfuo-JPw,20338
 test/test_pool_threading_multiprocessing.py,sha256=VxXW4YDlX09NfbIWTr05Knc7OvB4E58kW_1UqonUPPE,24085
@@ -111,8 +111,8 @@ test/integration/test_result_batch_v2.py,sha256=f2Wiqhfcq7wMNT4hSOVYSLXUIoYV9FZV
 test/integration/test_shared_token_issuance.py,sha256=PSsjZBlLq58v1Fw8scSaRwmtNkO49LcDQfG9_jmSkPM,4761
 test/integration/test_sync_oauth_lifecycle.py,sha256=HqQk1HBm0vyQmS1xMggXSSn0Pg5LJ7xnlxx2zpnRl3k,831
 test/integration/token_observation.py,sha256=uDrTFJeg8UalhJYo76c-i0Xm1SkO5bq5rlT4OP72vp4,1995
-e6data_python_connector-3.0.1rc3.dist-info/METADATA,sha256=jYtiZBwqNOrIFFUypmHYxNtFDrPCR_wDwtCXGez_EBk,39137
-e6data_python_connector-3.0.1rc3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-e6data_python_connector-3.0.1rc3.dist-info/entry_points.txt,sha256=KWgkagF_tw3w5RhD2tVXqrIHn8ibNg2e53LdPz78t1k,151
-e6data_python_connector-3.0.1rc3.dist-info/top_level.txt,sha256=uOWV7xMMlZxe030EIU4bGUuKJ-W78lKxX4YHA7YFclw,29
-e6data_python_connector-3.0.1rc3.dist-info/RECORD,,
+e6data_python_connector-3.0.2.dist-info/METADATA,sha256=5EgZgPYWhjtrz7Fmn_MmmZ1VGQGjK8rLZ0rWE0Le3vk,40031
+e6data_python_connector-3.0.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+e6data_python_connector-3.0.2.dist-info/entry_points.txt,sha256=KWgkagF_tw3w5RhD2tVXqrIHn8ibNg2e53LdPz78t1k,151
+e6data_python_connector-3.0.2.dist-info/top_level.txt,sha256=uOWV7xMMlZxe030EIU4bGUuKJ-W78lKxX4YHA7YFclw,29
+e6data_python_connector-3.0.2.dist-info/RECORD,,

test/test_oauth_auto_resume.py

@@ -349,7 +349,9 @@ def test_legacy_suspend_resume_baseline(cached, active):
     connector._set_active_strategy(cached)
     state = ['suspended']
     seen = []
-    connection = make_connection(access_token=None, username='fixture-user', password='fixture-password')
+    connection = make_connection(access_token=None, username='fixture-user', password='fixture-password',
+                                 grpc_options={'max_receive_message_length': 4096,
+                                               'max_send_message_length': 8192})
     def authenticate(request, metadata):
         assert request.user == 'fixture-user'
         assert request.password == 'fixture-password'
@@ -361,7 +363,10 @@ def test_legacy_suspend_resume_baseline(cached, active):
         if headers['strategy'] != active:
             raise rpc_error(grpc.StatusCode.UNKNOWN, 'status: 456')
         return engine_pb.AuthenticateResponse(sessionId='legacy-session')
-    def resume(_):
+    def resume(manager):
+        options = dict(manager._grpc_options)
+        assert options['grpc.max_receive_message_length'] == 4096
+        assert options['grpc.max_send_message_length'] == 8192
         state[0] = 'active'
         return True
     connection._client = SimpleNamespace(authenticate=authenticate)