airbyte-cdk 6.5.3rc2__py3-none-any.whl → 6.6.0__py3-none-any.whl

airbyte_cdk/sources/source.py

@@ -27,15 +27,19 @@ class ExperimentalClassWarning(DeprecationWarning):
 
 class BaseSource(BaseConnector[TConfig], ABC, Generic[TConfig, TState, TCatalog]):
     @abstractmethod
-    def read_state(self, state_path: str) -> TState:
-        ...
+    def read_state(self, state_path: str) -> TState: ...
 
     @abstractmethod
-    def read_catalog(self, catalog_path: str) -> TCatalog:
-        ...
+    def read_catalog(self, catalog_path: str) -> TCatalog: ...
 
     @abstractmethod
-    def read(self, logger: logging.Logger, config: TConfig, catalog: TCatalog, state: Optional[TState] = None) -> Iterable[AirbyteMessage]:
+    def read(
+        self,
+        logger: logging.Logger,
+        config: TConfig,
+        catalog: TCatalog,
+        state: Optional[TState] = None,
+    ) -> Iterable[AirbyteMessage]:
         """
         Returns a generator of the AirbyteMessages generated by reading the source with the given configuration, catalog, and state.
         """
@@ -69,8 +73,14 @@ class Source(
             if state_obj:
                 for state in state_obj:  # type: ignore  # `isinstance(state_obj, List)` ensures that this is a list
                     parsed_message = AirbyteStateMessageSerializer.load(state)
-                    if not parsed_message.stream and not parsed_message.data and not parsed_message.global_:
-                        raise ValueError("AirbyteStateMessage should contain either a stream, global, or state field")
+                    if (
+                        not parsed_message.stream
+                        and not parsed_message.data
+                        and not parsed_message.global_
+                    ):
+                        raise ValueError(
+                            "AirbyteStateMessage should contain either a stream, global, or state field"
+                        )
                     parsed_state_messages.append(parsed_message)
         return parsed_state_messages
 

airbyte_cdk/sources/streams/availability_strategy.py

@@ -20,7 +20,9 @@ class AvailabilityStrategy(ABC):
     """
 
     @abstractmethod
-    def check_availability(self, stream: Stream, logger: logging.Logger, source: Optional["Source"] = None) -> Tuple[bool, Optional[str]]:
+    def check_availability(
+        self, stream: Stream, logger: logging.Logger, source: Optional["Source"] = None
+    ) -> Tuple[bool, Optional[str]]:
         """
         Checks stream availability.
 
@@ -52,7 +54,9 @@ class AvailabilityStrategy(ABC):
         return next(slices)
 
     @staticmethod
-    def get_first_record_for_slice(stream: Stream, stream_slice: Optional[Mapping[str, Any]]) -> StreamData:
+    def get_first_record_for_slice(
+        stream: Stream, stream_slice: Optional[Mapping[str, Any]]
+    ) -> StreamData:
         """
         Gets the first record for a stream_slice of a stream.
 
@@ -70,7 +74,9 @@ class AvailabilityStrategy(ABC):
 
             # We wrap the return output of read_records() because some implementations return types that are iterable,
             # but not iterators such as lists or tuples
-            records_for_slice = iter(stream.read_records(sync_mode=SyncMode.full_refresh, stream_slice=stream_slice))
+            records_for_slice = iter(
+                stream.read_records(sync_mode=SyncMode.full_refresh, stream_slice=stream_slice)
+            )
 
             return next(records_for_slice)
         finally:

airbyte_cdk/sources/streams/call_rate.py

@@ -76,7 +76,9 @@ class AbstractCallRatePolicy(abc.ABC):
         """
 
     @abc.abstractmethod
-    def update(self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]) -> None:
+    def update(
+        self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]
+    ) -> None:
         """Update call rate counting with current values
 
         :param available_calls:
@@ -202,12 +204,20 @@ class UnlimitedCallRatePolicy(BaseCallRatePolicy):
     def try_acquire(self, request: Any, weight: int) -> None:
         """Do nothing"""
 
-    def update(self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]) -> None:
+    def update(
+        self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]
+    ) -> None:
         """Do nothing"""
 
 
 class FixedWindowCallRatePolicy(BaseCallRatePolicy):
-    def __init__(self, next_reset_ts: datetime.datetime, period: timedelta, call_limit: int, matchers: list[RequestMatcher]):
+    def __init__(
+        self,
+        next_reset_ts: datetime.datetime,
+        period: timedelta,
+        call_limit: int,
+        matchers: list[RequestMatcher],
+    ):
         """A policy that allows {call_limit} calls within a {period} time interval
 
         :param next_reset_ts: next call rate reset time point
@@ -235,7 +245,8 @@ class FixedWindowCallRatePolicy(BaseCallRatePolicy):
             if self._calls_num + weight > self._call_limit:
                 reset_in = self._next_reset_ts - datetime.datetime.now()
                 error_message = (
-                    f"reached maximum number of allowed calls {self._call_limit} " f"per {self._offset} interval, next reset in {reset_in}."
+                    f"reached maximum number of allowed calls {self._call_limit} "
+                    f"per {self._offset} interval, next reset in {reset_in}."
                 )
                 raise CallRateLimitHit(
                     error=error_message,
@@ -247,7 +258,9 @@ class FixedWindowCallRatePolicy(BaseCallRatePolicy):
 
             self._calls_num += weight
 
-    def update(self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]) -> None:
+    def update(
+        self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]
+    ) -> None:
         """Update call rate counters, by default, only reacts to decreasing updates of available_calls and changes to call_reset_ts.
         We ignore updates with available_calls > current_available_calls to support call rate limits that are lower than API limits.
 
@@ -260,12 +273,18 @@ class FixedWindowCallRatePolicy(BaseCallRatePolicy):
 
             if available_calls is not None and current_available_calls > available_calls:
                 logger.debug(
-                    "got rate limit update from api, adjusting available calls from %s to %s", current_available_calls, available_calls
+                    "got rate limit update from api, adjusting available calls from %s to %s",
+                    current_available_calls,
+                    available_calls,
                 )
                 self._calls_num = self._call_limit - available_calls
 
             if call_reset_ts is not None and call_reset_ts != self._next_reset_ts:
-                logger.debug("got rate limit update from api, adjusting reset time from %s to %s", self._next_reset_ts, call_reset_ts)
+                logger.debug(
+                    "got rate limit update from api, adjusting reset time from %s to %s",
+                    self._next_reset_ts,
+                    call_reset_ts,
+                )
                 self._next_reset_ts = call_reset_ts
 
     def _update_current_window(self) -> None:
@@ -292,7 +311,10 @@ class MovingWindowCallRatePolicy(BaseCallRatePolicy):
         """
         if not rates:
             raise ValueError("The list of rates can not be empty")
-        pyrate_rates = [PyRateRate(limit=rate.limit, interval=int(rate.interval.total_seconds() * 1000)) for rate in rates]
+        pyrate_rates = [
+            PyRateRate(limit=rate.limit, interval=int(rate.interval.total_seconds() * 1000))
+            for rate in rates
+        ]
         self._bucket = InMemoryBucket(pyrate_rates)
         # Limiter will create the background task that clears old requests in the bucket
         self._limiter = Limiter(self._bucket)
@@ -320,14 +342,18 @@ class MovingWindowCallRatePolicy(BaseCallRatePolicy):
                     time_to_wait=timedelta(milliseconds=time_to_wait),
                 )
 
-    def update(self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]) -> None:
+    def update(
+        self, available_calls: Optional[int], call_reset_ts: Optional[datetime.datetime]
+    ) -> None:
         """Adjust call bucket to reflect the state of the API server
 
         :param available_calls:
         :param call_reset_ts:
         :return:
         """
-        if available_calls is not None and call_reset_ts is None:  # we do our best to sync buckets with API
+        if (
+            available_calls is not None and call_reset_ts is None
+        ):  # we do our best to sync buckets with API
             if available_calls == 0:
                 with self._limiter.lock:
                     items_to_add = self._bucket.count() < self._bucket.rates[0].limit
@@ -350,7 +376,9 @@ class AbstractAPIBudget(abc.ABC):
     """
 
     @abc.abstractmethod
-    def acquire_call(self, request: Any, block: bool = True, timeout: Optional[float] = None) -> None:
+    def acquire_call(
+        self, request: Any, block: bool = True, timeout: Optional[float] = None
+    ) -> None:
         """Try to get a call from budget, will block by default
 
         :param request:
@@ -375,7 +403,9 @@ class AbstractAPIBudget(abc.ABC):
 class APIBudget(AbstractAPIBudget):
     """Default APIBudget implementation"""
 
-    def __init__(self, policies: list[AbstractCallRatePolicy], maximum_attempts_to_acquire: int = 100000) -> None:
+    def __init__(
+        self, policies: list[AbstractCallRatePolicy], maximum_attempts_to_acquire: int = 100000
+    ) -> None:
         """Constructor
 
         :param policies: list of policies in this budget
@@ -392,7 +422,9 @@ class APIBudget(AbstractAPIBudget):
                 return policy
         return None
 
-    def acquire_call(self, request: Any, block: bool = True, timeout: Optional[float] = None) -> None:
+    def acquire_call(
+        self, request: Any, block: bool = True, timeout: Optional[float] = None
+    ) -> None:
         """Try to get a call from budget, will block by default.
         Matchers will be called sequentially in the same order they were added.
         The first matcher that returns True will
@@ -417,7 +449,9 @@ class APIBudget(AbstractAPIBudget):
         """
         pass
 
-    def _do_acquire(self, request: Any, policy: AbstractCallRatePolicy, block: bool, timeout: Optional[float]) -> None:
+    def _do_acquire(
+        self, request: Any, policy: AbstractCallRatePolicy, block: bool, timeout: Optional[float]
+    ) -> None:
         """Internal method to try to acquire a call credit
 
         :param request:
@@ -439,14 +473,20 @@ class APIBudget(AbstractAPIBudget):
                     else:
                         time_to_wait = exc.time_to_wait
 
-                    time_to_wait = max(timedelta(0), time_to_wait)  # sometimes we get negative duration
-                    logger.info("reached call limit %s. going to sleep for %s", exc.rate, time_to_wait)
+                    time_to_wait = max(
+                        timedelta(0), time_to_wait
+                    )  # sometimes we get negative duration
+                    logger.info(
+                        "reached call limit %s. going to sleep for %s", exc.rate, time_to_wait
+                    )
                     time.sleep(time_to_wait.total_seconds())
                 else:
                     raise
 
         if last_exception:
-            logger.info("we used all %s attempts to acquire and failed", self._maximum_attempts_to_acquire)
+            logger.info(
+                "we used all %s attempts to acquire and failed", self._maximum_attempts_to_acquire
+            )
             raise last_exception
 
 
@@ -481,9 +521,13 @@ class HttpAPIBudget(APIBudget):
             reset_ts = self.get_reset_ts_from_response(response)
             policy.update(available_calls=available_calls, call_reset_ts=reset_ts)
 
-    def get_reset_ts_from_response(self, response: requests.Response) -> Optional[datetime.datetime]:
+    def get_reset_ts_from_response(
+        self, response: requests.Response
+    ) -> Optional[datetime.datetime]:
         if response.headers.get(self._ratelimit_reset_header):
-            return datetime.datetime.fromtimestamp(int(response.headers[self._ratelimit_reset_header]))
+            return datetime.datetime.fromtimestamp(
+                int(response.headers[self._ratelimit_reset_header])
+            )
         return None
 
     def get_calls_left_from_response(self, response: requests.Response) -> Optional[int]:

airbyte_cdk/sources/streams/checkpoint/checkpoint_reader.py

@@ -53,7 +53,9 @@ class IncrementalCheckpointReader(CheckpointReader):
     before syncing data.
     """
 
-    def __init__(self, stream_state: Mapping[str, Any], stream_slices: Iterable[Optional[Mapping[str, Any]]]):
+    def __init__(
+        self, stream_state: Mapping[str, Any], stream_slices: Iterable[Optional[Mapping[str, Any]]]
+    ):
         self._state: Optional[Mapping[str, Any]] = stream_state
         self._stream_slices = iter(stream_slices)
         self._has_slices = False
@@ -87,7 +89,12 @@ class CursorBasedCheckpointReader(CheckpointReader):
     that belongs to the Concurrent CDK.
     """
 
-    def __init__(self, cursor: Cursor, stream_slices: Iterable[Optional[Mapping[str, Any]]], read_state_from_cursor: bool = False):
+    def __init__(
+        self,
+        cursor: Cursor,
+        stream_slices: Iterable[Optional[Mapping[str, Any]]],
+        read_state_from_cursor: bool = False,
+    ):
         self._cursor = cursor
         self._stream_slices = iter(stream_slices)
         # read_state_from_cursor is used to delineate that partitions should determine when to stop syncing dynamically according
@@ -153,7 +160,11 @@ class CursorBasedCheckpointReader(CheckpointReader):
                         next_slice = self.read_and_convert_slice()
                         state_for_slice = self._cursor.select_state(next_slice)
                         has_more = state_for_slice == FULL_REFRESH_COMPLETE_STATE
-                return StreamSlice(cursor_slice=state_for_slice or {}, partition=next_slice.partition, extra_fields=next_slice.extra_fields)
+                return StreamSlice(
+                    cursor_slice=state_for_slice or {},
+                    partition=next_slice.partition,
+                    extra_fields=next_slice.extra_fields,
+                )
             else:
                 state_for_slice = self._cursor.select_state(self.current_slice)
                 if state_for_slice == FULL_REFRESH_COMPLETE_STATE:
@@ -173,7 +184,9 @@ class CursorBasedCheckpointReader(CheckpointReader):
                     )
                 # The reader continues to process the current partition if it's state is still in progress
                 return StreamSlice(
-                    cursor_slice=state_for_slice or {}, partition=self.current_slice.partition, extra_fields=self.current_slice.extra_fields
+                    cursor_slice=state_for_slice or {},
+                    partition=self.current_slice.partition,
+                    extra_fields=self.current_slice.extra_fields,
                 )
         else:
             # Unlike RFR cursors that iterate dynamically according to how stream state is updated, most cursors operate
@@ -218,8 +231,17 @@ class LegacyCursorBasedCheckpointReader(CursorBasedCheckpointReader):
     }
     """
 
-    def __init__(self, cursor: Cursor, stream_slices: Iterable[Optional[Mapping[str, Any]]], read_state_from_cursor: bool = False):
-        super().__init__(cursor=cursor, stream_slices=stream_slices, read_state_from_cursor=read_state_from_cursor)
+    def __init__(
+        self,
+        cursor: Cursor,
+        stream_slices: Iterable[Optional[Mapping[str, Any]]],
+        read_state_from_cursor: bool = False,
+    ):
+        super().__init__(
+            cursor=cursor,
+            stream_slices=stream_slices,
+            read_state_from_cursor=read_state_from_cursor,
+        )
 
     def next(self) -> Optional[Mapping[str, Any]]:
         try:
@@ -228,7 +250,9 @@ class LegacyCursorBasedCheckpointReader(CursorBasedCheckpointReader):
             if "partition" in dict(self.current_slice):
                 raise ValueError("Stream is configured to use invalid stream slice key 'partition'")
             elif "cursor_slice" in dict(self.current_slice):
-                raise ValueError("Stream is configured to use invalid stream slice key 'cursor_slice'")
+                raise ValueError(
+                    "Stream is configured to use invalid stream slice key 'cursor_slice'"
+                )
 
             # We convert StreamSlice to a regular mapping because legacy connectors operate on the basic Mapping object. We
             # also duplicate all fields at the top level for backwards compatibility for existing Python sources

airbyte_cdk/sources/streams/checkpoint/substream_resumable_full_refresh_cursor.py

@@ -5,7 +5,9 @@ from typing import Any, Mapping, MutableMapping, Optional
 
 from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.streams.checkpoint import Cursor
-from airbyte_cdk.sources.streams.checkpoint.per_partition_key_serializer import PerPartitionKeySerializer
+from airbyte_cdk.sources.streams.checkpoint.per_partition_key_serializer import (
+    PerPartitionKeySerializer,
+)
 from airbyte_cdk.sources.types import Record, StreamSlice, StreamState
 from airbyte_cdk.utils import AirbyteTracedException
 
@@ -97,7 +99,9 @@ class SubstreamResumableFullRefreshCursor(Cursor):
         if not stream_slice:
             raise ValueError("A partition needs to be provided in order to extract a state")
 
-        return self._per_partition_state.get(self._to_partition_key(stream_slice.partition), {}).get("cursor")
+        return self._per_partition_state.get(
+            self._to_partition_key(stream_slice.partition), {}
+        ).get("cursor")
 
     def _to_partition_key(self, partition: Mapping[str, Any]) -> str:
         return self._partition_serializer.to_partition_key(partition)

airbyte_cdk/sources/streams/concurrent/adapters.py

@@ -6,9 +6,17 @@ import copy
 import json
 import logging
 from functools import lru_cache
-from typing import Any, Callable, Iterable, List, Mapping, MutableMapping, Optional, Tuple, Union
-
-from airbyte_cdk.models import AirbyteLogMessage, AirbyteMessage, AirbyteStream, ConfiguredAirbyteStream, Level, SyncMode, Type
+from typing import Any, Iterable, List, Mapping, MutableMapping, Optional, Tuple, Union
+
+from airbyte_cdk.models import (
+    AirbyteLogMessage,
+    AirbyteMessage,
+    AirbyteStream,
+    ConfiguredAirbyteStream,
+    Level,
+    SyncMode,
+    Type,
+)
 from airbyte_cdk.sources import AbstractSource, Source
 from airbyte_cdk.sources.connector_state_manager import ConnectorStateManager
 from airbyte_cdk.sources.message import MessageRepository
@@ -16,15 +24,23 @@ from airbyte_cdk.sources.source import ExperimentalClassWarning
 from airbyte_cdk.sources.streams import Stream
 from airbyte_cdk.sources.streams.availability_strategy import AvailabilityStrategy
 from airbyte_cdk.sources.streams.concurrent.abstract_stream_facade import AbstractStreamFacade
-from airbyte_cdk.sources.streams.concurrent.availability_strategy import AbstractAvailabilityStrategy, AlwaysAvailableAvailabilityStrategy
+from airbyte_cdk.sources.streams.concurrent.availability_strategy import (
+    AbstractAvailabilityStrategy,
+    AlwaysAvailableAvailabilityStrategy,
+)
 from airbyte_cdk.sources.streams.concurrent.cursor import Cursor, FinalStateCursor
 from airbyte_cdk.sources.streams.concurrent.default_stream import DefaultStream
 from airbyte_cdk.sources.streams.concurrent.exceptions import ExceptionWithDisplayMessage
-from airbyte_cdk.sources.streams.concurrent.helpers import get_cursor_field_from_stream, get_primary_key_from_stream
+from airbyte_cdk.sources.streams.concurrent.helpers import (
+    get_cursor_field_from_stream,
+    get_primary_key_from_stream,
+)
 from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
 from airbyte_cdk.sources.streams.concurrent.partitions.partition_generator import PartitionGenerator
 from airbyte_cdk.sources.streams.concurrent.partitions.record import Record
-from airbyte_cdk.sources.streams.concurrent.state_converters.datetime_stream_state_converter import DateTimeStreamStateConverter
+from airbyte_cdk.sources.streams.concurrent.state_converters.datetime_stream_state_converter import (
+    DateTimeStreamStateConverter,
+)
 from airbyte_cdk.sources.streams.core import StreamData
 from airbyte_cdk.sources.types import StreamSlice
 from airbyte_cdk.sources.utils.schema_helpers import InternalConfig
@@ -75,7 +91,9 @@ class StreamFacade(AbstractStreamFacade[DefaultStream], Stream):
                 partition_generator=StreamPartitionGenerator(
                     stream,
                     message_repository,
-                    SyncMode.full_refresh if isinstance(cursor, FinalStateCursor) else SyncMode.incremental,
+                    SyncMode.full_refresh
+                    if isinstance(cursor, FinalStateCursor)
+                    else SyncMode.incremental,
                     [cursor_field] if cursor_field is not None else None,
                     state,
                     cursor,
@@ -97,14 +115,23 @@ class StreamFacade(AbstractStreamFacade[DefaultStream], Stream):
 
     @property
     def state(self) -> MutableMapping[str, Any]:
-        raise NotImplementedError("This should not be called as part of the Concurrent CDK code. Please report the problem to Airbyte")
+        raise NotImplementedError(
+            "This should not be called as part of the Concurrent CDK code. Please report the problem to Airbyte"
+        )
 
     @state.setter
     def state(self, value: Mapping[str, Any]) -> None:
         if "state" in dir(self._legacy_stream):
             self._legacy_stream.state = value  # type: ignore  # validating `state` is attribute of stream using `if` above
 
-    def __init__(self, stream: DefaultStream, legacy_stream: Stream, cursor: Cursor, slice_logger: SliceLogger, logger: logging.Logger):
+    def __init__(
+        self,
+        stream: DefaultStream,
+        legacy_stream: Stream,
+        cursor: Cursor,
+        slice_logger: SliceLogger,
+        logger: logging.Logger,
+    ):
         """
         :param stream: The underlying AbstractStream
         """
@@ -141,7 +168,10 @@ class StreamFacade(AbstractStreamFacade[DefaultStream], Stream):
                 # This shouldn't happen if the ConcurrentCursor was used
                 state = "unknown; no state attribute was available on the cursor"
             yield AirbyteMessage(
-                type=Type.LOG, log=AirbyteLogMessage(level=Level.ERROR, message=f"Cursor State at time of exception: {state}")
+                type=Type.LOG,
+                log=AirbyteLogMessage(
+                    level=Level.ERROR, message=f"Cursor State at time of exception: {state}"
+                ),
             )
             raise exc
 
@@ -180,7 +210,9 @@ class StreamFacade(AbstractStreamFacade[DefaultStream], Stream):
     def supports_incremental(self) -> bool:
         return self._legacy_stream.supports_incremental
 
-    def check_availability(self, logger: logging.Logger, source: Optional["Source"] = None) -> Tuple[bool, Optional[str]]:
+    def check_availability(
+        self, logger: logging.Logger, source: Optional["Source"] = None
+    ) -> Tuple[bool, Optional[str]]:
         """
         Verifies the stream is available. Delegates to the underlying AbstractStream and ignores the parameters
         :param logger: (ignored)
@@ -264,7 +296,9 @@ class StreamPartition(Partition):
             ):
                 if isinstance(record_data, Mapping):
                     data_to_return = dict(record_data)
-                    self._stream.transformer.transform(data_to_return, self._stream.get_json_schema())
+                    self._stream.transformer.transform(
+                        data_to_return, self._stream.get_json_schema()
+                    )
                     yield Record(data_to_return, self)
                 else:
                     self._message_repository.emit_message(record_data)
@@ -329,9 +363,17 @@ class StreamPartitionGenerator(PartitionGenerator):
         self._cursor = cursor
 
     def generate(self) -> Iterable[Partition]:
-        for s in self._stream.stream_slices(sync_mode=self._sync_mode, cursor_field=self._cursor_field, stream_state=self._state):
+        for s in self._stream.stream_slices(
+            sync_mode=self._sync_mode, cursor_field=self._cursor_field, stream_state=self._state
+        ):
             yield StreamPartition(
-                self._stream, copy.deepcopy(s), self.message_repository, self._sync_mode, self._cursor_field, self._state, self._cursor
+                self._stream,
+                copy.deepcopy(s),
+                self.message_repository,
+                self._sync_mode,
+                self._cursor_field,
+                self._state,
+                self._cursor,
             )
 
 
@@ -348,7 +390,7 @@ class CursorPartitionGenerator(PartitionGenerator):
 
     def __init__(
         self,
-        stream_factory: Callable[[], Stream],
+        stream: Stream,
         message_repository: MessageRepository,
         cursor: Cursor,
         connector_state_converter: DateTimeStreamStateConverter,
@@ -358,12 +400,12 @@ class CursorPartitionGenerator(PartitionGenerator):
         """
         Initialize the CursorPartitionGenerator with a stream, sync mode, and cursor.
 
-        :param stream_factory: The stream factory that created the stream to delegate to for partition generation.
+        :param stream: The stream to delegate to for partition generation.
         :param message_repository: The message repository to use to emit non-record messages.
         :param sync_mode: The synchronization mode.
         :param cursor: A Cursor object that maintains the state and the cursor field.
         """
-        self._stream_factory = stream_factory
+        self._stream = stream
         self.message_repository = message_repository
         self._sync_mode = SyncMode.full_refresh
         self._cursor = cursor
@@ -382,8 +424,16 @@ class CursorPartitionGenerator(PartitionGenerator):
         :return: An iterable of StreamPartition objects.
         """
 
-        start_boundary = self._slice_boundary_fields[self._START_BOUNDARY] if self._slice_boundary_fields else "start"
-        end_boundary = self._slice_boundary_fields[self._END_BOUNDARY] if self._slice_boundary_fields else "end"
+        start_boundary = (
+            self._slice_boundary_fields[self._START_BOUNDARY]
+            if self._slice_boundary_fields
+            else "start"
+        )
+        end_boundary = (
+            self._slice_boundary_fields[self._END_BOUNDARY]
+            if self._slice_boundary_fields
+            else "end"
+        )
 
         for slice_start, slice_end in self._cursor.generate_slices():
             stream_slice = StreamSlice(
@@ -395,7 +445,7 @@ class CursorPartitionGenerator(PartitionGenerator):
             )
 
             yield StreamPartition(
-                self._stream_factory(),
+                self._stream,
                 copy.deepcopy(stream_slice),
                 self.message_repository,
                 self._sync_mode,
@@ -405,12 +455,17 @@ class CursorPartitionGenerator(PartitionGenerator):
             )
 
 
-@deprecated("Availability strategy has been soft deprecated. Do not use. Class is subject to removal", category=ExperimentalClassWarning)
+@deprecated(
+    "Availability strategy has been soft deprecated. Do not use. Class is subject to removal",
+    category=ExperimentalClassWarning,
+)
 class AvailabilityStrategyFacade(AvailabilityStrategy):
     def __init__(self, abstract_availability_strategy: AbstractAvailabilityStrategy):
         self._abstract_availability_strategy = abstract_availability_strategy
 
-    def check_availability(self, stream: Stream, logger: logging.Logger, source: Optional["Source"] = None) -> Tuple[bool, Optional[str]]:
+    def check_availability(
+        self, stream: Stream, logger: logging.Logger, source: Optional["Source"] = None
+    ) -> Tuple[bool, Optional[str]]:
         """
         Checks stream availability.