kurrentdbclient 1.3.4__tar.gz → 1.3.6__tar.gz

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kurrentdbclient
-Version: 1.3.4
+Version: 1.3.6
 Summary: Python gRPC Client for KurrentDB
 License: BSD-3-Clause
 License-File: LICENSE
@@ -57,8 +57,8 @@ with the KurrentDB team, and are officially supported by Kurrent Inc.
 Although not all aspects of the KurrentDB gRPC API are implemented, most
 features are presented in an easy-to-use interface.
 
-These clients have been tested to work with KurrentDB versions 25.0, 25.1, 26.0,
-and 26.1, and EventStoreDB versions 23.10 and 24.10, with and without SSL/TLS,
+These clients have been tested to work with KurrentDB versions 25.0, 25.1, 26.0, 26.1,
+and 26.2, and EventStoreDB versions 23.10 and 24.10, with and without SSL/TLS,
 in both single-server and cluster modes, across Python versions 3.10, 3.11, 3.12,
 3.13, 3.14, and 3.15.
 

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/README.md

@@ -22,8 +22,8 @@ with the KurrentDB team, and are officially supported by Kurrent Inc.
 Although not all aspects of the KurrentDB gRPC API are implemented, most
 features are presented in an easy-to-use interface.
 
-These clients have been tested to work with KurrentDB versions 25.0, 25.1, 26.0,
-and 26.1, and EventStoreDB versions 23.10 and 24.10, with and without SSL/TLS,
+These clients have been tested to work with KurrentDB versions 25.0, 25.1, 26.0, 26.1,
+and 26.2, and EventStoreDB versions 23.10 and 24.10, with and without SSL/TLS,
 in both single-server and cluster modes, across Python versions 3.10, 3.11, 3.12,
 3.13, 3.14, and 3.15.
 

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/__init__.py

@@ -28,7 +28,7 @@ from kurrentdbclient.streams import (
     ReadResponse,
 )
 
-__version__ = "1.3.4"
+__version__ = "1.3.6"
 
 __all__ = [
     "DEFAULT_EXCLUDE_FILTER",

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/asyncio_client.py

@@ -65,6 +65,7 @@ from kurrentdbclient.exceptions import (
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
+    from uuid import UUID
 
     from kurrentdbclient.persistent import ConsumerStrategy, SubscriptionInfo
     from kurrentdbclient.projections import ProjectionState, ProjectionStatistics
@@ -80,6 +81,7 @@ def autoreconnect(f: _TCallable) -> _TCallable:
         client: AsyncKurrentDBClient, *args: Any, **kwargs: Any
     ) -> Any:
         await client.connect()
+        connection_id = client.connection_id
         try:
             return await f(client, *args, **kwargs)
 
@@ -92,7 +94,8 @@ def autoreconnect(f: _TCallable) -> _TCallable:
                 )
             ):
                 await client.reconnect(
-                    grpc_target(e.host, e.port) if e.host and e.port else None
+                    grpc_target(e.host, e.port) if e.host and e.port else None,
+                    connection_id=connection_id,
                 )
                 await asyncio.sleep(0.1)
                 return await f(client, *args, **kwargs)
@@ -100,13 +103,13 @@ def autoreconnect(f: _TCallable) -> _TCallable:
 
         except grpc.aio.UsageError as e:
             if "Channel is closed" in str(e):
-                await client.reconnect()
+                await client.reconnect(connection_id=connection_id)
                 await asyncio.sleep(0.1)
                 return await f(client, *args, **kwargs)
             raise  # pragma: no cover
 
         except ServiceUnavailableError:
-            await client.reconnect()
+            await client.reconnect(connection_id=connection_id)
             await asyncio.sleep(0.1)
             return await f(client, *args, **kwargs)
 
@@ -119,7 +122,7 @@ def retrygrpc(f: _TCallable) -> _TCallable:
         try:
             return await f(*args, **kwargs)
         except GrpcError:
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(0.5)
             return await f(*args, **kwargs)
 
     return cast(_TCallable, retrygrpc_decorator)
@@ -143,6 +146,11 @@ class AsyncKurrentDBClient(BaseKurrentDBClient):
         self._is_reconnection_required = Event()
         self._connection_lock = Lock()
 
+    @property
+    def connection_id(self) -> UUID:
+        assert self._connection is not None
+        return self._connection.connection_id
+
     async def connect(self) -> None:
         if self._connection is None:
             async with self._connection_lock:
@@ -163,8 +171,12 @@ class AsyncKurrentDBClient(BaseKurrentDBClient):
     def connection_target(self) -> str:
         return self.connection.grpc_target
 
-    async def reconnect(self, grpc_target: str | None = None) -> None:
-        self._is_reconnection_required.set()
+    async def reconnect(
+        self, grpc_target: str | None = None, connection_id: UUID | None = None
+    ) -> None:
+        # Avoid reconnecting if client already has a new connection.
+        if connection_id is None or connection_id == self.connection_id:
+            self._is_reconnection_required.set()
         async with self._connection_lock:
             if self._is_reconnection_required.is_set():
                 new = await self._connect(grpc_target)

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import json
 import random
 import sys
@@ -62,6 +63,7 @@ from kurrentdbclient.events import (
     StreamStateCheck,
 )
 from kurrentdbclient.exceptions import (
+    AccessDeniedError,
     DiscoveryFailedError,
     FollowerNotFoundError,
     GrpcError,
@@ -81,6 +83,7 @@ from kurrentdbclient.gossip import (
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
+    from uuid import UUID
 
     from kurrentdbclient.persistent import (
         ConsumerStrategy,
@@ -116,9 +119,14 @@ def autoreconnect(f: _TCallable) -> _TCallable:
     def autoreconnect_decorator(*args: Any, **kwargs: Any) -> Any:
         client = args[0]
         assert isinstance(client, KurrentDBClient)
+        connection_id = client.connection_id
         try:
             return f(*args, **kwargs)
 
+        # TODO: Maybe refine the retry so that we do reconnect and try again when
+        #   there is connection failure after retrying without reconnecting because
+        #   the connection has changed. Need to think about this a bit more...
+
         except NodeIsNotLeaderError as e:
             if (
                 client.connection_spec.options.node_preference == NODE_PREFERENCE_LEADER
@@ -128,7 +136,8 @@ def autoreconnect(f: _TCallable) -> _TCallable:
                 )
             ):
                 client.reconnect(
-                    grpc_target(e.host, e.port) if e.host and e.port else None
+                    grpc_target(e.host, e.port) if e.host and e.port else None,
+                    connection_id=connection_id,
                 )
                 sleep(0.1)
                 return f(*args, **kwargs)
@@ -137,13 +146,13 @@ def autoreconnect(f: _TCallable) -> _TCallable:
         except ValueError as e:
             s = str(e)
             if "Channel closed!" in s or "Cannot invoke RPC on closed channel!" in s:
-                client.reconnect()
+                client.reconnect(connection_id=connection_id)
                 sleep(0.1)
                 return f(*args, **kwargs)
             raise  # pragma: no cover
 
         except ServiceUnavailableError:
-            client.reconnect()
+            client.reconnect(connection_id=connection_id)
             sleep(0.1)
             return f(*args, **kwargs)
 
@@ -322,6 +331,10 @@ class KurrentDBClient(BaseKurrentDBClient):
     def connection_target(self) -> str:
         return self._connection.grpc_target
 
+    @property
+    def connection_id(self) -> UUID:
+        return self._connection.connection_id
+
     @property
     def streams(self) -> StreamsService:
         return self._connection.streams
@@ -411,14 +424,22 @@ class KurrentDBClient(BaseKurrentDBClient):
 
         return connection
 
-    def reconnect(self, grpc_target: str | None = None) -> None:
-        self._is_reconnection_required.set()
+    def reconnect(
+        self, grpc_target: str | None = None, *, connection_id: UUID | None = None
+    ) -> None:
+        # Avoid reconnecting if client already has a new connection.
+        if connection_id is None or connection_id == self.connection_id:
+            self._is_reconnection_required.set()
+        # Single reconnection.
         with self._reconnection_lock:
             if self._is_reconnection_required.is_set():
                 new_conn = self._connect(grpc_target)
                 old_conn, self._connection = self._connection, new_conn
                 old_conn.close()
                 self._is_reconnection_required.clear()
+                # Exercise the connection (avoids delayed errors due to lazy channel)
+                with contextlib.suppress(AccessDeniedError):
+                    self._get_commit_position()
             else:  # pragma: no cover
                 # Todo: Test with concurrent writes to wrong node state.
                 pass
@@ -678,17 +699,19 @@ class KurrentDBClient(BaseKurrentDBClient):
         """
         Returns a sequence of recorded events from the named stream.
         """
-        with self.read_stream(
+        with self._read_stream(
             stream_name=stream_name,
             stream_position=stream_position,
             backwards=backwards,
             resolve_links=resolve_links,
             limit=limit,
             timeout=timeout,
-            credentials=credentials or self._call_credentials,
+            credentials=credentials,
         ) as events:
             return tuple(events)
 
+    @retrygrpc
+    @autoreconnect
     def read_stream(
         self,
         stream_name: str,
@@ -699,6 +722,30 @@ class KurrentDBClient(BaseKurrentDBClient):
         limit: int = sys.maxsize,
         timeout: float | None = None,
         credentials: grpc.CallCredentials | None = None,
+    ) -> AbstractReadResponse:
+        """
+        Reads recorded events from the named stream.
+        """
+        return self._read_stream(
+            stream_name=stream_name,
+            stream_position=stream_position,
+            backwards=backwards,
+            resolve_links=resolve_links,
+            limit=limit,
+            timeout=timeout,
+            credentials=credentials,
+        )
+
+    def _read_stream(
+        self,
+        stream_name: str,
+        *,
+        stream_position: int | None = None,
+        backwards: bool = False,
+        resolve_links: bool = False,
+        limit: int = sys.maxsize,
+        timeout: float | None = None,
+        credentials: grpc.CallCredentials | None = None,
     ) -> AbstractReadResponse:
         """
         Reads recorded events from the named stream.
@@ -714,6 +761,8 @@ class KurrentDBClient(BaseKurrentDBClient):
             credentials=credentials or self._call_credentials,
         )
 
+    @retrygrpc
+    @autoreconnect
     def read_all(
         self,
         *,
@@ -727,6 +776,36 @@ class KurrentDBClient(BaseKurrentDBClient):
         limit: int = sys.maxsize,
         timeout: float | None = None,
         credentials: grpc.CallCredentials | None = None,
+    ) -> AbstractReadResponse:
+        """
+        Reads recorded events in "all streams" in the database.
+        """
+        return self._read_all(
+            commit_position=commit_position,
+            backwards=backwards,
+            resolve_links=resolve_links,
+            filter_exclude=filter_exclude,
+            filter_include=filter_include,
+            filter_by_stream_name=filter_by_stream_name,
+            filter_by_prefix=filter_by_prefix,
+            limit=limit,
+            timeout=timeout,
+            credentials=credentials,
+        )
+
+    def _read_all(
+        self,
+        *,
+        commit_position: int | None = None,
+        backwards: bool = False,
+        resolve_links: bool = False,
+        filter_exclude: Sequence[str] = DEFAULT_EXCLUDE_FILTER,
+        filter_include: Sequence[str] = (),
+        filter_by_stream_name: bool = False,
+        filter_by_prefix: bool = False,
+        limit: int = sys.maxsize,
+        timeout: float | None = None,
+        credentials: grpc.CallCredentials | None = None,
     ) -> AbstractReadResponse:
         """
         Reads recorded events in "all streams" in the database.
@@ -745,6 +824,8 @@ class KurrentDBClient(BaseKurrentDBClient):
             credentials=credentials or self._call_credentials,
         )
 
+    @retrygrpc
+    @autoreconnect
     def read_index(
         self,
         index_name: str,
@@ -758,7 +839,7 @@ class KurrentDBClient(BaseKurrentDBClient):
         if not index_name.startswith("$idx-"):
             index_name = f"$idx-{index_name}"
 
-        return self.read_all(
+        return self._read_all(
             commit_position=commit_position,
             filter_include=(index_name,),
             filter_by_stream_name=True,
@@ -817,15 +898,34 @@ class KurrentDBClient(BaseKurrentDBClient):
         """
         Returns the current commit position of the database.
         """
-        read_response = self.streams.read(
+        return self._get_commit_position(
+            filter_exclude=filter_exclude,
+            filter_include=filter_include,
+            filter_by_stream_name=filter_by_stream_name,
+            timeout=timeout,
+            credentials=credentials,
+        )
+
+    def _get_commit_position(
+        self,
+        *,
+        filter_exclude: Sequence[str] = DEFAULT_EXCLUDE_FILTER,
+        filter_include: Sequence[str] = (),
+        filter_by_stream_name: bool = False,
+        timeout: float | None = None,
+        credentials: grpc.CallCredentials | None = None,
+    ) -> int:
+        """
+        Returns the current commit position of the database.
+        """
+        read_response = self._read_all(
             backwards=True,
             filter_exclude=filter_exclude,
             filter_include=filter_include,
             filter_by_stream_name=filter_by_stream_name,
             limit=1,
             timeout=timeout,
-            metadata=self._call_metadata,
-            credentials=credentials or self._call_credentials,
+            credentials=credentials,
         )
         recorded_events = tuple(read_response)
         if recorded_events:
@@ -905,6 +1005,45 @@ class KurrentDBClient(BaseKurrentDBClient):
         include_fell_behind: bool = False,
         timeout: float | None = None,
         credentials: grpc.CallCredentials | None = None,
+    ) -> AbstractCatchupSubscription:
+        """
+        Starts a catch-up subscription, from which all
+        recorded events in the database can be received.
+        """
+        return self._subscribe_to_all(
+            commit_position=commit_position,
+            from_end=from_end,
+            resolve_links=resolve_links,
+            filter_exclude=filter_exclude,
+            filter_include=filter_include,
+            filter_by_stream_name=filter_by_stream_name,
+            filter_by_prefix=filter_by_prefix,
+            include_checkpoints=include_checkpoints,
+            window_size=window_size,
+            checkpoint_interval_multiplier=checkpoint_interval_multiplier,
+            include_caught_up=include_caught_up,
+            include_fell_behind=include_fell_behind,
+            timeout=timeout,
+            credentials=credentials,
+        )
+
+    def _subscribe_to_all(
+        self,
+        *,
+        commit_position: int | None = None,
+        from_end: bool = False,
+        resolve_links: bool = False,
+        filter_exclude: Sequence[str] = DEFAULT_EXCLUDE_FILTER,
+        filter_include: Sequence[str] = (),
+        filter_by_stream_name: bool = False,
+        filter_by_prefix: bool = False,
+        include_checkpoints: bool = False,
+        window_size: int = DEFAULT_WINDOW_SIZE,
+        checkpoint_interval_multiplier: int = DEFAULT_CHECKPOINT_INTERVAL_MULTIPLIER,
+        include_caught_up: bool = False,
+        include_fell_behind: bool = False,
+        timeout: float | None = None,
+        credentials: grpc.CallCredentials | None = None,
     ) -> AbstractCatchupSubscription:
         """
         Starts a catch-up subscription, from which all
@@ -929,6 +1068,8 @@ class KurrentDBClient(BaseKurrentDBClient):
             credentials=credentials or self._call_credentials,
         )
 
+    @retrygrpc
+    @autoreconnect
     def subscribe_to_index(
         self,
         index_name: str,
@@ -941,7 +1082,7 @@ class KurrentDBClient(BaseKurrentDBClient):
         if not index_name.startswith("$idx-"):
             index_name = f"$idx-{index_name}"
 
-        return self.subscribe_to_all(
+        return self._subscribe_to_all(
             commit_position=commit_position,
             filter_include=(index_name,),
             filter_by_stream_name=True,
@@ -1421,6 +1562,24 @@ class KurrentDBClient(BaseKurrentDBClient):
         *,
         timeout: float | None = None,
         credentials: grpc.CallCredentials | None = None,
+    ) -> SubscriptionInfo:
+        """
+        Gets info for a persistent subscription.
+        """
+        return self._get_subscription_info(
+            group_name=group_name,
+            stream_name=stream_name,
+            timeout=timeout,
+            credentials=credentials,
+        )
+
+    def _get_subscription_info(
+        self,
+        group_name: str,
+        stream_name: str | None = None,
+        *,
+        timeout: float | None = None,
+        credentials: grpc.CallCredentials | None = None,
     ) -> SubscriptionInfo:
         """
         Gets info for a persistent subscription.
@@ -1754,7 +1913,7 @@ class KurrentDBClient(BaseKurrentDBClient):
         Updates a persistent subscription on one stream.
         """
 
-        info = self.get_subscription_info(
+        info = self._get_subscription_info(
             group_name=group_name,
             stream_name=stream_name,
             timeout=timeout,

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/common.py

@@ -30,8 +30,10 @@ import kurrentdbclient.protos.v2.streams.errors_pb2 as v2streams_errors_pb2
 from kurrentdbclient.events import RecordedEvent
 from kurrentdbclient.exceptions import (
     AbortedByServerError,
+    AccessDeniedError,
     AlreadyExistsError,
     CancelledByClientError,
+    CancelledError,
     ConsistencyCheckFailure,
     ConsistencyChecksFailedError,
     ConsumerTooSlowError,
@@ -109,13 +111,23 @@ class BaseGrpcStreamer:
 TGrpcStreamer = TypeVar("TGrpcStreamer", bound=BaseGrpcStreamer)
 
 
+class GrpcStreamersCollectionClosedError(Exception):
+    pass
+
+
 class BaseGrpcStreamers(Generic[TGrpcStreamer]):
     def __init__(self) -> None:
         self.map: WeakValueDictionary[int, TGrpcStreamer] = WeakValueDictionary()
         self.lock = threading.Lock()
+        self._is_closed = False
 
     def add(self, streamer: TGrpcStreamer) -> None:
+        # print(f"Adding streamer: {id(streamer)}")
         with self.lock:
+            if self._is_closed:
+                # This is hit by the test_replicate_github_issue_40 tests when
+                # run separately but for some reason not with the full suite
+                raise GrpcStreamersCollectionClosedError
             self.map[id(streamer)] = streamer
 
     def __iter__(self) -> Iterator[TGrpcStreamer]:
@@ -132,24 +144,42 @@ TGrpcStreamers = TypeVar("TGrpcStreamers", bound=BaseGrpcStreamers[Any])
 
 class GrpcStreamer(BaseGrpcStreamer, ABC):
     def __init__(self, grpc_streamers: GrpcStreamers) -> None:
-        self._grpc_streamers = grpc_streamers
-        self._grpc_streamers.add(self)
         self._is_stopped = False
+        self._is_cancelled = False
         self._is_stopped_lock = threading.Lock()
+        self._grpc_streamers = grpc_streamers
+        try:
+            self._grpc_streamers.add(self)
+        except GrpcStreamersCollectionClosedError:  # pragma: no cover
+            # This is hit by the test_replicate_github_issue_40 tests when
+            # run separately but for some reason not with the full suite
+            self.stop(cancel=True)
+
+    @property
+    def is_stopped(self) -> bool:
+        return self._is_stopped
+
+    @property
+    def is_cancelled(self) -> bool:
+        return self._is_cancelled
 
     @abstractmethod
-    def stop(self) -> None:
+    def stop(self, *, cancel: bool = False) -> None:
         """
         Stops the iterator(s) of streaming call.
         """
 
-    def _set_is_stopped(self) -> bool:
+    def _remove(self) -> None:
+        self._grpc_streamers.remove(self)
+
+    def _set_is_stopped(self, *, cancel: bool = False) -> bool:
         is_stopped = True
         if self._is_stopped is False:
             with self._is_stopped_lock:
                 if self._is_stopped is False:
                     is_stopped = False
                     self._is_stopped = True
+                    self._is_cancelled = cancel
                 else:  # pragma: no cover
                     pass
         return is_stopped
@@ -157,32 +187,57 @@ class GrpcStreamer(BaseGrpcStreamer, ABC):
 
 class GrpcStreamers(BaseGrpcStreamers[GrpcStreamer]):
     def close(self) -> None:
+        with self.lock:
+            self._is_closed = True
         for grpc_streamer in self:
-            # print("closing streamer")
-            grpc_streamer.stop()
-            # print("closed streamer")
+            grpc_streamer.stop(cancel=True)
 
 
 class AsyncGrpcStreamer(BaseGrpcStreamer, ABC):
     def __init__(self, grpc_streamers: AsyncGrpcStreamers) -> None:
         self._grpc_streamers = grpc_streamers
-        self._grpc_streamers.add(self)
         self._is_stopped = False
+        self._is_cancelled = False
         self._is_stopped_lock = asyncio.Lock()
 
+    async def add_to_steamers(self) -> None:
+        try:
+            self._grpc_streamers.add(self)
+        except GrpcStreamersCollectionClosedError:  # pragma: no cover
+            # This is hit by the test_replicate_github_issue_40 tests when
+            # run separately but for some reason not with the full suite
+            await self.stop(cancel=True)
+
+    @property
+    def is_stopped(self) -> bool:
+        return self._is_stopped
+
+    @property
+    def is_cancelled(self) -> bool:
+        return self._is_cancelled
+
     @abstractmethod
-    async def stop(self, *, timeout: float | None = None) -> None:
+    async def stop(
+        self,
+        *,
+        timeout: float | None = None,
+        cancel: bool = False,
+    ) -> None:
         """
         Stops the iterator(s) of streaming call.
         """
 
-    async def _set_is_stopped(self) -> bool:
+    def _remove(self) -> None:
+        self._grpc_streamers.remove(self)
+
+    async def _set_is_stopped(self, *, cancel: bool = False) -> bool:
         is_stopped = True
         if self._is_stopped is False:
             async with self._is_stopped_lock:
                 if self._is_stopped is False:
                     is_stopped = False
                     self._is_stopped = True
+                    self._is_cancelled = cancel
                 else:  # pragma: no cover
                     pass
         return is_stopped
@@ -190,9 +245,11 @@ class AsyncGrpcStreamer(BaseGrpcStreamer, ABC):
 
 class AsyncGrpcStreamers(BaseGrpcStreamers[AsyncGrpcStreamer]):
     async def close(self) -> None:
+        with self.lock:
+            self._is_closed = True
         for async_grpc_streamer in self:
             # print("closing streamer")
-            await async_grpc_streamer.stop(timeout=1)
+            await async_grpc_streamer.stop(timeout=1, cancel=True)
             # print("closed streamer")
 
 
@@ -295,65 +352,93 @@ def handle_rpc_error(e: grpc.RpcError) -> KurrentDBClientError:  # noqa: PLR0911
                         )
             return KurrentDBClientError(details_str)
 
+        # Handle error according the status code of the given error.
         if e.code() == grpc.StatusCode.UNKNOWN:
             if "Exception was thrown by handler" in details_str:
+                # This just happens from time to time in KurrentDB (various operations)
                 return ExceptionThrownByHandlerError(details_str)
+
+            # no cover >=26.2: start
             if (
                 "Envelope callback expected Updated, received Conflict instead"
                 in details_str
             ):
-                # Projections.Create does this....
+                # Projections.Create in when projection exists with same name.
+                # KurrentDB >=26.2 returns error with status code ALREADY_EXISTS.
                 return AlreadyExistsError(details_str)
+            # no cover >=26.2: stop
+
+            # no cover >=24.10: start
             if (
                 "Envelope callback expected Updated, received NotFound instead"
                 in details_str
             ):
                 # Projections.Update and Projections.Delete does this in < v24.6
-                return NotFoundError(details_str)  # pragma: no cover
+                return NotFoundError(details_str)
+            # no cover >=24.10: stop
+
+            # no cover >=24.10: start
             if (
                 "Envelope callback expected Statistics, received NotFound instead"
                 in details_str
             ):
                 # Projections.Statistics does this in < v24.6
-                return NotFoundError(details_str)  # pragma: no cover
+                return NotFoundError(details_str)
+            # no cover >=24.10: stop
+
+            # no cover >=24.10: start
             if (
                 "Envelope callback expected ProjectionState, received NotFound instead"
                 in details_str
             ):
                 # Projections.State does this in < v24.6
-                return NotFoundError(details_str)  # pragma: no cover
+                return NotFoundError(details_str)
+            # no cover >=24.10: stop
+
+            # no cover >=24.10: start
             if (
                 "Envelope callback expected ProjectionResult, received NotFound instead"
                 in details_str
             ):
                 # Projections.Result does this in < v24.6
                 return NotFoundError(details_str)  # pragma: no cover
+            # no cover >=24.10: stop
+
+            # no cover >=26.2: start
             if (
                 "Envelope callback expected Updated, received OperationFailed instead"
                 in details_str
             ):
-                # Projections.Delete does this....
+                # Projections.Delete does this when projection not stopped.
+                # KurrentDB >=26.2 returns error with status code FAILED_PRECONDITION.
                 return OperationFailedError(details_str)
+            # no cover >=26.2: stop
+
             # no cover <25.1: start
             if "Unexpected FilteredReadAllResult: InvalidPosition" in details_str:
                 # Commit position does not exist.
                 return InvalidCommitPositionError(details_str)
             # no cover <25.1: stop
-            return UnknownError(details_str)  # pragma: no cover
+
+            # Catch all other unknown errors.
+            return UnknownError(details_str)
 
         if e.code() == grpc.StatusCode.ABORTED:
             if "Consumer too slow" in details_str:
                 return ConsumerTooSlowError(details_str)
             return AbortedByServerError(details_str)
-        if (
-            e.code() == grpc.StatusCode.CANCELLED
-            and details_str == "Locally cancelled by application!"
-        ):
-            return CancelledByClientError(details_str)
+
+        if e.code() == grpc.StatusCode.CANCELLED:
+            if details_str == "Locally cancelled by application!":
+                return CancelledByClientError(details_str)
+            return CancelledError(details_str)
+
         if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
             return GrpcDeadlineExceededError(details_str)
+
         if e.code() == grpc.StatusCode.UNAUTHENTICATED:
             return UnauthenticatedError(details_str)
+
         if e.code() == grpc.StatusCode.UNAVAILABLE:
             if "SSL_ERROR" in details_str:
                 # root_certificates is None and CA cert not installed
@@ -365,8 +450,10 @@ def handle_rpc_error(e: grpc.RpcError) -> KurrentDBClientError:  # noqa: PLR0911
                 # given root_certificates is invalid
                 return SSLError(details_str)
             return ServiceUnavailableError(details_str)
+
         if e.code() == grpc.StatusCode.ALREADY_EXISTS:
             return AlreadyExistsError(details_str)
+
         if e.code() == grpc.StatusCode.NOT_FOUND:
             if details_str == "Leader info available":
                 trailing_metadata = {m[0]: m[1] for m in e.trailing_metadata()}  # type: ignore[index]
@@ -382,17 +469,24 @@ def handle_rpc_error(e: grpc.RpcError) -> KurrentDBClientError:  # noqa: PLR0911
                     ),
                 )
             return NotFoundError()
+
         if e.code() == grpc.StatusCode.FAILED_PRECONDITION:
             if details_str is not None and details_str.startswith(
                 "Maximum subscriptions reached"
             ):
                 return MaximumSubscriptionsReachedError(details_str)
-            # no cover: start
+            # no cover <26.2: start
+            # Projections.Delete does this in >=26.2 when projection not stopped.
             return FailedPreconditionError(details_str)
-            # no cover: stop
-        if e.code() == grpc.StatusCode.INTERNAL:  # pragma: no cover
+            # no cover <26.2: stop
+
+        if e.code() == grpc.StatusCode.PERMISSION_DENIED:
+            return AccessDeniedError(details_str)
+
+        if e.code() == grpc.StatusCode.INTERNAL:
             return InternalError(details_str)
-    return GrpcError(str(e))
+
+    return GrpcError(str(e))  # pragma: no cover
 
 
 def _convert_append_consistency_violations(
@@ -572,7 +666,7 @@ class RecordedEventIterator(
         self.stop()
 
     @abstractmethod
-    def stop(self) -> None:
+    def stop(self, *, cancel: bool = False) -> None:
         pass  # pragma: no cover
 
 

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/connection.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+from uuid import uuid4
 
 from kurrentdbclient.common import AsyncGrpcStreamers, GrpcStreamers
 from kurrentdbclient.gossip import AsyncGossipService, GossipService
@@ -21,6 +22,7 @@ if TYPE_CHECKING:
 class BaseKurrentDBConnection:
     def __init__(self, grpc_target: str):
         self._grpc_target = grpc_target
+        self.connection_id = uuid4()
 
     @property
     def grpc_target(self) -> str:
@@ -75,9 +77,7 @@ class KurrentDBConnection(BaseKurrentDBConnection):
         self._grpc_streamers.close()
         # self.grpc_channel.unsubscribe(self._receive_channel_connectivity_state)
         # sleep(0.1)  # Allow connectivity polling to stop.
-        # print("closing channel")
         self._grpc_channel.close()
-        # print("closed channel")
 
 
 class AsyncKurrentDBConnection(BaseKurrentDBConnection):

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/exceptions.py

@@ -61,9 +61,15 @@ class GrpcDeadlineExceededError(GrpcError, DeadlineExceededError):
     """
 
 
-class CancelledByClientError(KurrentDBClientError):
+class CancelledError(GrpcError):
     """
-    Raised when gRPC operation is cancelled.
+    Raised when gRPC operation is somehow cancelled.
+    """
+
+
+class CancelledByClientError(CancelledError):
+    """
+    Raised when gRPC operation is known to have been cancelled by client.
     """
 
 

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/instrumentation/opentelemetry/spanners.py

@@ -279,6 +279,7 @@ def span_read_stream(
     stream_name: str,
     *args: Any,
     **kwargs: Any,
+    # TODO: Can't this use AbstractAsyncReadResponse rather than AsyncReadResponse?
 ) -> OverloadedSpannerResponse[AbstractReadResponse, AsyncReadResponse]:
     span_name, span_kind = _get_span_name_and_kind(spanned_func)
     with _start_span(tracer, span_name, span_kind) as span:
@@ -294,6 +295,7 @@ def span_read_stream(
             if inspect.iscoroutine(response):
 
                 async def wrap_response() -> AsyncReadResponse:
+                    # TODO: Can this be AbstractAsyncReadResponse?
                     return cast(
                         AsyncReadResponse,
                         TracedAsyncReadResponse(
@@ -317,7 +319,8 @@ def span_read_stream(
                     span_name=span_name,
                     span_kind=span_kind,
                 )
-        except Exception as e:
+        except Exception as e:  # pragma: no cover
+            # Hard to cover this consistently due to timing of channel readiness.
             _set_span_error(span, e)
             raise
         else:
@@ -777,15 +780,8 @@ class TracedRecordedEventIterator(
                 span.end()
                 self._current_span = None
 
-    def stop(self) -> None:
-        self.response.stop()
-
-    def __enter__(self) -> Self:
-        self.response.__enter__()
-        return self
-
-    def __exit__(self, *args: object, **kwargs: Any) -> None:
-        return self.response.__exit__(*args, **kwargs)
+    def stop(self, *, cancel: bool = False) -> None:
+        self.response.stop(cancel=cancel)
 
     def __del__(self) -> None:
         current_span = self._current_span

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/persistent.py

@@ -597,20 +597,28 @@ class AsyncPersistentSubscription(
                         return recorded_event
                 else:  # pragma: no cover
                     pass
-        except BaseException:
-            await self.stop(timeout=1)
+        except BaseException as e:
+            was_cancelled = self._is_cancelled
+            await self.stop(timeout=1, cancel=True)
+            if was_cancelled and isinstance(e, StopAsyncIteration):
+                raise CancelledByClientError from e
             raise
 
-    async def stop(self, *, timeout: float | None = None) -> None:
+    async def stop(
+        self,
+        *,
+        timeout: float | None = None,
+        cancel: bool = False,
+    ) -> None:
         if self._is_context_manager_active:
             self._is_stopping = True
-        elif not await self._set_is_stopped():
+        elif not await self._set_is_stopped(cancel=cancel):
             try:
                 await self._read_reqs.stop(timeout=timeout)
             finally:
                 self._read_resp_stream_worker_task.cancel()
                 self._stream_stream_call.cancel()
-                self._grpc_streamers.remove(self)
+                self._remove()
                 try:
                     await self._read_resp_stream_worker_task
                 except asyncio.CancelledError:
@@ -660,6 +668,7 @@ class PersistentSubscription(
         self._read_reqs = read_reqs
         self._read_resps = read_resps
         self._is_stopping = False
+        self._is_cancelling = False
 
         try:
             first_read_resp = self._get_next_read_resp()
@@ -698,8 +707,14 @@ class PersistentSubscription(
         while True:
             try:
                 read_resp = self._get_next_read_resp()
-            except CancelledByClientError:
-                raise StopIteration from None
+            except CancelledByClientError as e:
+                # Grpc stream is cancelled.
+                self.stop(cancel=True)
+                if self._is_cancelled:
+                    # Response is stopped and cancelled.
+                    raise
+                # Response is stopped but not cancelled.
+                raise StopIteration from e
             content_oneof = read_resp.WhichOneof("content")
             if content_oneof == "event":
                 recorded_event = construct_recorded_event(read_resp.event)
@@ -733,13 +748,14 @@ class PersistentSubscription(
         self._grpc_streamers.remove(self)
         self._is_stopped = True
 
-    def stop(self) -> None:
+    def stop(self, *, cancel: bool = False) -> None:
         if self._is_context_manager_active:
             self._is_stopping = True
-        elif not self._set_is_stopped():
+            self._is_cancelling = cancel
+        elif not self._set_is_stopped(cancel=cancel):
             self._read_reqs.stop()
             self._read_resps.cancel()
-            self._grpc_streamers.remove(self)
+            self._remove()
 
     def ack(self, item: UUID | RecordedEvent) -> None:
         self._read_reqs.ack(event_id=self._get_event_id(item))
@@ -1505,6 +1521,7 @@ class AsyncPersistentSubscriptionsService(
             expected_group_name=group_name,
             stream_name=stream_name,
         )
+        await subscription.add_to_steamers()
         await subscription.init()
         return subscription
 

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/kurrentdbclient/streams.py

@@ -214,17 +214,25 @@ class AsyncReadResponse(BaseReadResponse, AsyncGrpcStreamer, AbstractAsyncReadRe
                 )
                 if recorded_event is not None:
                     return recorded_event
-        except BaseException:
-            await self.stop()
+        except BaseException as e:
+            was_cancelled = self._is_cancelled
+            await self.stop(cancel=True)
+            if was_cancelled and isinstance(e, StopAsyncIteration):
+                raise CancelledByClientError from e
             raise
 
-    async def stop(self, *, timeout: float | None = None) -> None:
+    async def stop(
+        self,
+        *,
+        timeout: float | None = None,
+        cancel: bool = False,
+    ) -> None:
         if self._is_context_manager_active:
             self._is_stopping = True
-        elif not await self._set_is_stopped():
+        elif not await self._set_is_stopped(cancel=cancel):
             self._read_resp_stream_worker_task.cancel()
             self._unary_stream_call.cancel()
-            self._grpc_streamers.remove(self)
+            self._remove()
             try:
                 await self._read_resp_stream_worker_task
             except asyncio.CancelledError:
@@ -284,10 +292,10 @@ class ReadResponse(GrpcStreamer, BaseReadResponse, AbstractReadResponse):
         stream_name: str | None,
         grpc_streamers: GrpcStreamers,
     ):
-        GrpcStreamer.__init__(self, grpc_streamers=grpc_streamers)
         BaseReadResponse.__init__(self, stream_name=stream_name)
         AbstractReadResponse.__init__(self)
         self._read_resps = read_resps
+        GrpcStreamer.__init__(self, grpc_streamers=grpc_streamers)
 
     def __next__(self) -> RecordedEvent:
         try:
@@ -298,12 +306,32 @@ class ReadResponse(GrpcStreamer, BaseReadResponse, AbstractReadResponse):
                 )
                 if recorded_event is not None:
                     return recorded_event
-        except CancelledByClientError:
-            self.stop()
-            raise StopIteration from None
-        except:
-            self.stop()
+        except StopIteration as e:
+            # Grpc stream is finished.
+            self.stop(cancel=False)
+            if self._is_cancelled:
+                # Grpc stream is finished but response is cancelled.
+                raise CancelledByClientError from e
+            # Grpc stream is finished but response is not cancelled.
             raise
+        except CancelledByClientError as e:
+            # Grpc stream is cancelled.
+            self.stop(cancel=True)
+            if self._is_cancelled:
+                # Response is stopped and cancelled.
+                raise
+            # Response is stopped but not cancelled.
+            raise StopIteration from e
+        except Exception as e:
+            # Some channel error.
+            if self._is_cancelled:
+                # Some channel error but response was cancelled.
+                # print("Was cancelled, got error:", e)
+                raise CancelledByClientError from e
+            # Some channel error but response was not cancelled.
+            # print(f"Not cancelled ({id(self)}), got error:", e)
+            self.stop(cancel=True)
+            raise e
 
     def _get_next_read_resp(self) -> streams_pb2.ReadResp:
         try:
@@ -314,10 +342,10 @@ class ReadResponse(GrpcStreamer, BaseReadResponse, AbstractReadResponse):
             assert isinstance(read_resp, streams_pb2.ReadResp)
             return read_resp
 
-    def stop(self) -> None:
-        if not self._set_is_stopped():
+    def stop(self, *, cancel: bool = False) -> None:
+        if not self._set_is_stopped(cancel=cancel):
             self._read_resps.cancel()
-            self._grpc_streamers.remove(self)
+            self._remove()
 
 
 class CatchupSubscription(ReadResponse, AbstractCatchupSubscription):
@@ -988,6 +1016,7 @@ class AsyncStreamsService(BaseStreamsService[AsyncGrpcStreamers]):
                 stream_name=stream_name,
                 grpc_streamers=self._grpc_streamers,
             )
+            await response.add_to_steamers()
         else:
             response = AsyncCatchupSubscription(
                 unary_stream_call=unary_stream_call,
@@ -997,6 +1026,7 @@ class AsyncStreamsService(BaseStreamsService[AsyncGrpcStreamers]):
                 include_fell_behind=include_fell_behind,
                 grpc_streamers=self._grpc_streamers,
             )
+            await response.add_to_steamers()
             try:
                 await response.check_confirmation()
             except BaseException:
@@ -1184,6 +1214,8 @@ class StreamsService(BaseStreamsService[GrpcStreamers]):
         )
 
         # Send the read request, and iterate over the response.
+        #  - if channel is closed, this raises ValueError('Channel closed!').
+        #  - although a fresh channel doesn't do this,
         read_resps = self._stub.Read(
             read_req,
             timeout=timeout,

{kurrentdbclient-1.3.4 → kurrentdbclient-1.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "kurrentdbclient"
-version = "1.3.4"
+version = "1.3.6"
 description = "Python gRPC Client for KurrentDB"
 license = { text = "BSD-3-Clause" }
 readme = "README.md"
@@ -204,7 +204,7 @@ branch = true
 omit = [
     "kurrentdbclient/protos/*"
 ]
-relative_files = true
+#relative_files = true
 
 [tool.coverage.report]
 fail_under = 100