e6data-python-connector 3.0.1rc4__tar.gz → 3.0.3rc1__tar.gz

{e6data_python_connector-3.0.1rc4/e6data_python_connector.egg-info → e6data_python_connector-3.0.3rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e6data-python-connector
-Version: 3.0.1rc4
+Version: 3.0.3rc1
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.

{e6data_python_connector-3.0.1rc4 → e6data_python_connector-3.0.3rc1}/e6data_python_connector/async_cluster_manager.py

@@ -50,6 +50,9 @@ class _ResumeState:
     def acknowledged(self):
         self.pending = 'acknowledged'
 
+    def rejected(self):
+        self.pending = None
+
 
 class _ResumeFlight:
     """One phase deadline, independently bounded shielded waiters."""
@@ -167,6 +170,8 @@ class AsyncClusterManager:
                 _remaining(deadline)
             return await self._flight.wait(self._recover, deadline)
         except (TimeoutError, grpc.RpcError) as error:
+            if isinstance(error, grpc.RpcError) and error.code() == grpc.StatusCode.FAILED_PRECONDITION:
+                raise OperationalError('Cluster recovery failed: {}'.format(error.details())) from error
             raise OperationalError('Cluster recovery failed; a dispatched resume may still complete.') from error
 
     async def _metadata(self, strategy, deadline, rejected_token=None):
@@ -199,6 +204,8 @@ class AsyncClusterManager:
                     self.last_successful_strategy = strategy
                     return response
                 except grpc.RpcError as error:
+                    if operation == 'resume' and error.code() == grpc.StatusCode.FAILED_PRECONDITION:
+                        self._mutation.rejected()
                     if (error.code() == grpc.StatusCode.UNAUTHENTICATED and not refreshed
                             and self._metadata_provider is not None):
                         refreshed = True

e6data_python_connector-3.0.3rc1/e6data_python_connector/calendar_interval.py

@@ -0,0 +1,29 @@
+"""Lossless calendar intervals returned by MAKE_INTERVAL."""
+from typing import NamedTuple
+
+
+class CalendarInterval(NamedTuple):
+    """Months and calendar days are independent of elapsed microseconds."""
+
+    months: int
+    days: int
+    microseconds: int
+
+    def __str__(self):
+        month_sign = -1 if self.months < 0 else 1
+        time_sign = -1 if self.microseconds < 0 else 1
+        months = abs(self.months)
+        micros = abs(self.microseconds)
+        values = (month_sign * (months // 12), month_sign * (months % 12),
+                  self.days, time_sign * (micros // 3600000000),
+                  time_sign * (micros // 60000000 % 60))
+        parts = [f"{value} {unit}" for value, unit in
+                 zip(values, ("years", "months", "days", "hours", "minutes")) if value]
+        seconds = micros % 60000000
+        if seconds:
+            whole, fraction = divmod(seconds, 1000000)
+            text = str(whole)
+            if fraction:
+                text += f".{fraction:06d}".rstrip('0')
+            parts.append(f"{'-' if time_sign < 0 else ''}{text} seconds")
+        return ' '.join(parts) if parts else '0 seconds'

{e6data_python_connector-3.0.1rc4 → e6data_python_connector-3.0.3rc1}/e6data_python_connector/cluster_manager.py

@@ -571,6 +571,8 @@ class ClusterManager:
                 except _InactiveRpcError as e:
                     if self._debug:
                         logger.error(f"Failed to send resume request: {e}")
+                    if e.code() == grpc.StatusCode.FAILED_PRECONDITION:
+                        raise
                     return False
             elif current_status.status == 'active':
                 if self._debug:

{e6data_python_connector-3.0.1rc4 → e6data_python_connector-3.0.3rc1}/e6data_python_connector/datainputstream.py

@@ -10,6 +10,7 @@ from thrift.transport import TTransport
 
 from e6data_python_connector.e6x_vector.ttypes import Chunk, Vector, VectorType
 from e6data_python_connector.constants import ZONE
+from e6data_python_connector.calendar_interval import CalendarInterval
 from e6data_python_connector.date_time_utils import (
     floor_div,
     floor_mod,
@@ -478,6 +479,10 @@ def read_values_from_array(query_columns_description: list, dis: DataInputStream
         try:
             if dtype == "LONG":
                 value_array.append(dis.read_long())
+            elif dtype == "CALENDAR_INTERVAL":
+                value_array.append(CalendarInterval(dis.read_int(), dis.read_int(), 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 +587,27 @@ 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.CALENDAR_INTERVAL:
+            payload = getattr(vector.data, 'calendarIntervalData', None)
+            for row in range(vector.size):
+                if get_null(vector, row):
+                    value_array.append(None)
+                    continue
+                index = 0 if vector.isConstantVector else row
+                components = (payload.months, payload.days, payload.microseconds) if payload else ()
+                if not components or any(values is None or index >= len(values) or values[index] is None
+                                         for values in components):
+                    raise ValueError("Incomplete CALENDAR_INTERVAL vector payload")
+                value_array.append(CalendarInterval(*(values[index] for values in components)))
+        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-3.0.1rc4 → e6data_python_connector-3.0.3rc1}/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
+        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))

{e6data_python_connector-3.0.1rc4 → e6data_python_connector-3.0.3rc1}/e6data_python_connector/e6x_vector/ttypes.py

@@ -35,6 +35,8 @@ class VectorType(object):
     NULL = 14
     TIMESTAMP_TZ = 15
     DECIMAL128 = 16
+    INTERVAL_DAY_SECOND = 17
+    CALENDAR_INTERVAL = 18
 
     _VALUES_TO_NAMES = {
         0: "BINARY",
@@ -54,6 +56,8 @@ class VectorType(object):
         14: "NULL",
         15: "TIMESTAMP_TZ",
         16: "DECIMAL128",
+        17: "INTERVAL_DAY_SECOND",
+        18: "CALENDAR_INTERVAL",
     }
 
     _NAMES_TO_VALUES = {
@@ -74,6 +78,8 @@ class VectorType(object):
         "NULL": 14,
         "TIMESTAMP_TZ": 15,
         "DECIMAL128": 16,
+        "INTERVAL_DAY_SECOND": 17,
+        "CALENDAR_INTERVAL": 18,
     }
 
 
@@ -232,12 +238,13 @@ class Data(object):
      - timeData
      - decimal128Data
      - numericDecimal128ConstantData
+     - calendarIntervalData
 
     """
     thrift_spec = None
 
 
-    def __init__(self, boolData = None, int32Data = None, int64Data = None, dateData = None, float32Data = None, float64Data = None, varcharData = None, boolConstantData = None, dateConstantData = None, nullConstantData = None, numericConstantData = None, numericDecimalConstantData = None, temporalIntervalConstantData = None, timeConstantData = None, varcharConstantData = None, timeData = None, decimal128Data = None, numericDecimal128ConstantData = None,):
+    def __init__(self, boolData = None, int32Data = None, int64Data = None, dateData = None, float32Data = None, float64Data = None, varcharData = None, boolConstantData = None, dateConstantData = None, nullConstantData = None, numericConstantData = None, numericDecimalConstantData = None, temporalIntervalConstantData = None, timeConstantData = None, varcharConstantData = None, timeData = None, decimal128Data = None, numericDecimal128ConstantData = None, calendarIntervalData = None,):
         self.boolData = boolData
         self.int32Data = int32Data
         self.int64Data = int64Data
@@ -256,6 +263,7 @@ class Data(object):
         self.timeData = timeData
         self.decimal128Data = decimal128Data
         self.numericDecimal128ConstantData = numericDecimal128ConstantData
+        self.calendarIntervalData = calendarIntervalData
 
     def read(self, iprot):
         if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
@@ -374,6 +382,12 @@ class Data(object):
                     self.numericDecimal128ConstantData.read(iprot)
                 else:
                     iprot.skip(ftype)
+            elif fid == 23:
+                if ftype == TType.STRUCT:
+                    self.calendarIntervalData = CalendarIntervalData()
+                    self.calendarIntervalData.read(iprot)
+                else:
+                    iprot.skip(ftype)
             else:
                 iprot.skip(ftype)
             iprot.readFieldEnd()
@@ -457,6 +471,10 @@ class Data(object):
             oprot.writeFieldBegin('numericDecimal128ConstantData', TType.STRUCT, 18)
             self.numericDecimal128ConstantData.write(oprot)
             oprot.writeFieldEnd()
+        if self.calendarIntervalData is not None:
+            oprot.writeFieldBegin('calendarIntervalData', TType.STRUCT, 23)
+            self.calendarIntervalData.write(oprot)
+            oprot.writeFieldEnd()
         oprot.writeFieldStop()
         oprot.writeStructEnd()
 
@@ -1738,6 +1756,111 @@ class Chunk(object):
 
     def __ne__(self, other):
         return not (self == other)
+
+
+class CalendarIntervalData(object):
+    """
+    Attributes:
+     - months
+     - days
+     - microseconds
+
+    """
+    thrift_spec = None
+
+
+    def __init__(self, months = None, days = None, microseconds = None,):
+        self.months = months
+        self.days = days
+        self.microseconds = microseconds
+
+    def read(self, iprot):
+        if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None:
+            iprot._fast_decode(self, iprot, [self.__class__, self.thrift_spec])
+            return
+        iprot.readStructBegin()
+        while True:
+            (fname, ftype, fid) = iprot.readFieldBegin()
+            if ftype == TType.STOP:
+                break
+            if fid == 1:
+                if ftype == TType.LIST:
+                    self.months = []
+                    (_etype87, _size84) = iprot.readListBegin()
+                    for _i88 in range(_size84):
+                        _elem89 = iprot.readI32()
+                        self.months.append(_elem89)
+                    iprot.readListEnd()
+                else:
+                    iprot.skip(ftype)
+            elif fid == 2:
+                if ftype == TType.LIST:
+                    self.days = []
+                    (_etype93, _size90) = iprot.readListBegin()
+                    for _i94 in range(_size90):
+                        _elem95 = iprot.readI32()
+                        self.days.append(_elem95)
+                    iprot.readListEnd()
+                else:
+                    iprot.skip(ftype)
+            elif fid == 3:
+                if ftype == TType.LIST:
+                    self.microseconds = []
+                    (_etype99, _size96) = iprot.readListBegin()
+                    for _i100 in range(_size96):
+                        _elem101 = iprot.readI64()
+                        self.microseconds.append(_elem101)
+                    iprot.readListEnd()
+                else:
+                    iprot.skip(ftype)
+            else:
+                iprot.skip(ftype)
+            iprot.readFieldEnd()
+        iprot.readStructEnd()
+
+    def write(self, oprot):
+        self.validate()
+        if oprot._fast_encode is not None and self.thrift_spec is not None:
+            oprot.trans.write(oprot._fast_encode(self, [self.__class__, self.thrift_spec]))
+            return
+        oprot.writeStructBegin('CalendarIntervalData')
+        if self.months is not None:
+            oprot.writeFieldBegin('months', TType.LIST, 1)
+            oprot.writeListBegin(TType.I32, len(self.months))
+            for iter102 in self.months:
+                oprot.writeI32(iter102)
+            oprot.writeListEnd()
+            oprot.writeFieldEnd()
+        if self.days is not None:
+            oprot.writeFieldBegin('days', TType.LIST, 2)
+            oprot.writeListBegin(TType.I32, len(self.days))
+            for iter103 in self.days:
+                oprot.writeI32(iter103)
+            oprot.writeListEnd()
+            oprot.writeFieldEnd()
+        if self.microseconds is not None:
+            oprot.writeFieldBegin('microseconds', TType.LIST, 3)
+            oprot.writeListBegin(TType.I64, len(self.microseconds))
+            for iter104 in self.microseconds:
+                oprot.writeI64(iter104)
+            oprot.writeListEnd()
+            oprot.writeFieldEnd()
+        oprot.writeFieldStop()
+        oprot.writeStructEnd()
+
+    def validate(self):
+        return
+
+    def __repr__(self):
+        L = ['%s=%r' % (key, value)
+             for key, value in self.__dict__.items()]
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not (self == other)
 all_structs.append(Vector)
 Vector.thrift_spec = (
     None,  # 0
@@ -1770,6 +1893,11 @@ Data.thrift_spec = (
     (16, TType.STRUCT, 'timeData', [TimeData, None], None, ),  # 16
     (17, TType.STRUCT, 'decimal128Data', [Decimal128Data, None], None, ),  # 17
     (18, TType.STRUCT, 'numericDecimal128ConstantData', [NumericDecimal128ConstantData, None], None, ),  # 18
+    None,  # 19
+    None,  # 20
+    None,  # 21
+    None,  # 22
+    (23, TType.STRUCT, 'calendarIntervalData', [CalendarIntervalData, None], None, ),  # 23
 )
 all_structs.append(BoolData)
 BoolData.thrift_spec = (
@@ -1871,5 +1999,12 @@ Chunk.thrift_spec = (
     (1, TType.I32, 'size', None, None, ),  # 1
     (2, TType.LIST, 'vectors', (TType.STRUCT, [Vector, None], False), None, ),  # 2
 )
+all_structs.append(CalendarIntervalData)
+CalendarIntervalData.thrift_spec = (
+    None,  # 0
+    (1, TType.LIST, 'months', (TType.I32, None, False), None, ),  # 1
+    (2, TType.LIST, 'days', (TType.I32, None, False), None, ),  # 2
+    (3, TType.LIST, 'microseconds', (TType.I64, None, False), None, ),  # 3
+)
 fix_spec(all_structs)
 del all_structs

{e6data_python_connector-3.0.1rc4 → e6data_python_connector-3.0.3rc1/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: e6data-python-connector
-Version: 3.0.1rc4
+Version: 3.0.3rc1
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.

{e6data_python_connector-3.0.1rc4 → e6data_python_connector-3.0.3rc1}/e6data_python_connector.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ e6data_python_connector/async_cursor.py
 e6data_python_connector/async_dialect.py
 e6data_python_connector/async_oauth.py
 e6data_python_connector/async_work.py
+e6data_python_connector/calendar_interval.py
 e6data_python_connector/cluster_manager.py
 e6data_python_connector/common.py
 e6data_python_connector/connection_pool.py
@@ -115,6 +116,7 @@ test/integration/test_async_queries.py
 test/integration/test_async_resume.py
 test/integration/test_async_sqlalchemy.py
 test/integration/test_async_token_lifecycle.py
+test/integration/test_cluster_resume_errors.py
 test/integration/test_e2e_auth_boundary.py
 test/integration/test_e2e_oauth_continuation.py
 test/integration/test_e2e_readonly_matrix.py

{e6data_python_connector-3.0.1rc4 → e6data_python_connector-3.0.3rc1}/setup.py

@@ -12,7 +12,7 @@
 
 import setuptools
 
-VERSION = (3, 0, '1rc4',)
+VERSION = (3, 0, '3rc1',)
 
 
 def get_long_desc():

e6data_python_connector-3.0.3rc1/test/integration/test_cluster_resume_errors.py

@@ -0,0 +1,179 @@
+"""Real RPC regressions on an explicitly prepared, exclusive-use cluster.
+
+The operator must suspend the cluster and disable auto-resume before opting in.
+These tests observe real requests and never alter responses or cluster settings.
+"""
+import asyncio
+import os
+from pathlib import Path
+
+import grpc
+import pytest
+
+from e6data_python_connector import Connection
+from e6data_python_connector.aio import AsyncConnection
+from e6data_python_connector.async_cluster_manager import AsyncClusterManager
+from e6data_python_connector.cluster_manager import ClusterManager
+from e6data_python_connector.exceptions import OperationalError
+
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture
+def rejected_resume_config(live_config):
+    if os.environ.get('E6_RESUME_REJECTION_AUTHORIZED') != '1':
+        pytest.skip('Requires an exclusive suspended target with auto-resume disabled')
+    if not live_config.connection_kwargs.get('password'):
+        pytest.skip('This regression requires the legacy password authentication path')
+    return live_config
+
+
+def _manager_options(config):
+    settings = config.connection_kwargs
+    return dict(host=settings['host'], port=settings['port'],
+                user=settings['username'], password=settings['password'],
+                secure_channel=settings.get('secure', False),
+                cluster_uuid=settings.get('cluster_name'),
+                ssl_cert=settings.get('ssl_cert'),
+                grpc_options=settings.get('grpc_options'), timeout=15)
+
+
+class _ObservedSyncManager(ClusterManager):
+    """Observe inherited real RPCs without replacing the transport."""
+
+    def _try_cluster_request(self, operation):
+        self.operations.append(operation)
+        try:
+            return super()._try_cluster_request(operation)
+        except grpc.RpcError as error:
+            self.errors.append(error)
+            raise
+
+
+class _ObservedAsyncManager(AsyncClusterManager):
+    """Observe inherited real RPCs without replacing the transport."""
+
+    async def _request(self, client, operation, deadline):
+        self.operations.append(operation)
+        try:
+            return await super()._request(client, operation, deadline)
+        except grpc.RpcError as error:
+            self.errors.append(error)
+            raise
+
+
+def _observed_manager(manager_type, config, *, timeout=15, debug=False):
+    options = _manager_options(config)
+    options.update(timeout=timeout, debug=debug)
+    manager = manager_type(**options)
+    manager.operations = []
+    manager.errors = []
+    return manager
+
+
+def _assert_disabled(error):
+    assert error.code() == grpc.StatusCode.FAILED_PRECONDITION
+    assert 'disabled' in error.details().lower()
+
+
+def test_sync_active_cluster_does_not_dispatch_resume(live_config):
+    if os.environ.get('E6_RESUME_ACTIVE_AUTHORIZED') != '1':
+        pytest.skip('Requires an explicitly prepared active target')
+    if not live_config.connection_kwargs.get('password'):
+        pytest.skip('This regression requires the legacy password authentication path')
+    manager = _observed_manager(_ObservedSyncManager, live_config, debug=True)
+    try:
+        assert manager.resume() is True
+        assert manager.operations == ['status']
+        assert manager.errors == []
+    finally:
+        if hasattr(manager, '_channel'):
+            manager._channel.close()
+
+
+def test_sync_resume_preserves_original_terminal_error(rejected_resume_config):
+    manager = _observed_manager(_ObservedSyncManager, rejected_resume_config)
+    try:
+        with pytest.raises(grpc.RpcError) as raised:
+            manager.resume()
+        _assert_disabled(raised.value)
+        assert raised.value is manager.errors[-1]
+        assert manager.operations == ['status', 'resume']
+    finally:
+        if hasattr(manager, '_channel'):
+            manager._channel.close()
+
+
+def test_sync_query_preserves_disabled_resume_error(rejected_resume_config):
+    options = dict(rejected_resume_config.connection_kwargs, auto_resume=True)
+    with pytest.raises(grpc.RpcError) as raised:
+        with Connection(**options) as connection:
+            with connection.cursor() as cursor:
+                cursor.execute(rejected_resume_config.read_only_sql)
+    _assert_disabled(raised.value)
+
+
+def test_async_resume_preserves_terminal_reason_and_cause(rejected_resume_config):
+    async def run():
+        manager = _observed_manager(_ObservedAsyncManager, rejected_resume_config)
+        try:
+            with pytest.raises(OperationalError) as raised:
+                await manager.resume()
+            cause = raised.value.__cause__
+            _assert_disabled(cause)
+            assert cause is manager.errors[-1]
+            assert cause.details() in str(raised.value)
+            assert manager.operations == ['status', 'resume']
+        finally:
+            await manager.close()
+    asyncio.run(run())
+
+
+def test_async_rejected_resume_allows_a_later_attempt(rejected_resume_config):
+    async def run():
+        manager = _observed_manager(_ObservedAsyncManager, rejected_resume_config)
+        try:
+            for _ in range(2):
+                with pytest.raises(OperationalError) as raised:
+                    await manager.resume()
+                _assert_disabled(raised.value.__cause__)
+                assert manager._mutation.pending is None
+            assert manager.operations == ['status', 'resume', 'status', 'resume']
+        finally:
+            await manager.close()
+    asyncio.run(run())
+
+
+def test_async_same_manager_recovers_after_reenable(rejected_resume_config):
+    signal_value = os.environ.get('E6_RESUME_REENABLE_SIGNAL')
+    if not signal_value:
+        pytest.skip('Requires operator re-enable coordination through a fresh signal path')
+    signal = Path(signal_value)
+    assert signal.is_absolute()
+    rejected, enabled = Path(str(signal) + '.rejected'), Path(str(signal) + '.enabled')
+    assert not rejected.exists() and not enabled.exists(), 'Use a fresh signal path'
+
+    async def run():
+        manager = _observed_manager(_ObservedAsyncManager, rejected_resume_config, timeout=300)
+        try:
+            with pytest.raises(OperationalError) as raised:
+                await manager.resume()
+            _assert_disabled(raised.value.__cause__)
+            assert manager._mutation.pending is None
+            rejected.touch(mode=0o600)
+            async with asyncio.timeout(180):
+                while not enabled.exists():
+                    await asyncio.sleep(.25)
+            assert await manager.resume()
+            assert manager._mutation.pending is None
+            assert manager.operations.count('resume') == 2
+            async with AsyncConnection(**rejected_resume_config.connection_kwargs) as connection:
+                async with connection.cursor() as cursor:
+                    await cursor.execute(rejected_resume_config.read_only_sql)
+                    assert [list(row) for row in await cursor.fetchall()] == rejected_resume_config.expected_rows
+        finally:
+            await manager.close()
+            rejected.unlink(missing_ok=True)
+            enabled.unlink(missing_ok=True)
+    asyncio.run(run())