airbyte-cdk 6.8.1rc8__py3-none-any.whl → 6.8.1rc10__py3-none-any.whl

airbyte_cdk/sources/file_based/availability_strategy/default_file_based_availability_strategy.py

@@ -2,6 +2,8 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
+from __future__ import annotations
+
 import logging
 import traceback
 from typing import TYPE_CHECKING, Optional, Tuple
@@ -25,12 +27,15 @@ if TYPE_CHECKING:
 
 
 class DefaultFileBasedAvailabilityStrategy(AbstractFileBasedAvailabilityStrategy):
-    def __init__(self, stream_reader: AbstractFileBasedStreamReader):
+    def __init__(self, stream_reader: AbstractFileBasedStreamReader) -> None:
         self.stream_reader = stream_reader
 
-    def check_availability(
-        self, stream: "AbstractFileBasedStream", logger: logging.Logger, _: Optional[Source]
-    ) -> Tuple[bool, Optional[str]]:  # type: ignore[override]
+    def check_availability(  # type: ignore[override]  # Signature doesn't match base class
+        self,
+        stream: AbstractFileBasedStream,
+        logger: logging.Logger,
+        _: Optional[Source],
+    ) -> Tuple[bool, Optional[str]]:
         """
         Perform a connection check for the stream (verify that we can list files from the stream).
 
@@ -44,7 +49,10 @@ class DefaultFileBasedAvailabilityStrategy(AbstractFileBasedAvailabilityStrategy
         return True, None
 
     def check_availability_and_parsability(
-        self, stream: "AbstractFileBasedStream", logger: logging.Logger, _: Optional[Source]
+        self,
+        stream: AbstractFileBasedStream,
+        logger: logging.Logger,
+        _: Optional[Source],
     ) -> Tuple[bool, Optional[str]]:
         """
         Perform a connection check for the stream.
@@ -82,7 +90,7 @@ class DefaultFileBasedAvailabilityStrategy(AbstractFileBasedAvailabilityStrategy
 
         return True, None
 
-    def _check_list_files(self, stream: "AbstractFileBasedStream") -> RemoteFile:
+    def _check_list_files(self, stream: AbstractFileBasedStream) -> RemoteFile:
         """
         Check that we can list files from the stream.
 
@@ -102,7 +110,10 @@ class DefaultFileBasedAvailabilityStrategy(AbstractFileBasedAvailabilityStrategy
         return file
 
     def _check_parse_record(
-        self, stream: "AbstractFileBasedStream", file: RemoteFile, logger: logging.Logger
+        self,
+        stream: AbstractFileBasedStream,
+        file: RemoteFile,
+        logger: logging.Logger,
     ) -> None:
         parser = stream.get_parser()
 

airbyte_cdk/sources/file_based/file_types/avro_parser.py

@@ -3,7 +3,7 @@
 #
 
 import logging
-from typing import Any, Dict, Iterable, Mapping, Optional, Tuple
+from typing import Any, Dict, Iterable, Mapping, Optional, Tuple, cast
 
 import fastavro
 
@@ -64,18 +64,20 @@ class AvroParser(FileTypeParser):
             raise ValueError(f"Expected ParquetFormat, got {avro_format}")
 
         with stream_reader.open_file(file, self.file_read_mode, self.ENCODING, logger) as fp:
-            avro_reader = fastavro.reader(fp)
+            avro_reader = fastavro.reader(fp)  # type: ignore [arg-type]
             avro_schema = avro_reader.writer_schema
-        if not avro_schema["type"] == "record":
-            unsupported_type = avro_schema["type"]
+        if not avro_schema["type"] == "record":  # type: ignore [index, call-overload]
+            unsupported_type = avro_schema["type"]  # type: ignore [index, call-overload]
             raise ValueError(
                 f"Only record based avro files are supported. Found {unsupported_type}"
             )
         json_schema = {
-            field["name"]: AvroParser._convert_avro_type_to_json(
-                avro_format, field["name"], field["type"]
+            field["name"]: AvroParser._convert_avro_type_to_json(  # type: ignore [index]
+                avro_format,
+                field["name"],  # type: ignore [index]
+                field["type"],  # type: ignore [index]
             )
-            for field in avro_schema["fields"]
+            for field in avro_schema["fields"]  # type: ignore [index, call-overload]
         }
         return json_schema
 
@@ -180,18 +182,19 @@ class AvroParser(FileTypeParser):
         line_no = 0
         try:
             with stream_reader.open_file(file, self.file_read_mode, self.ENCODING, logger) as fp:
-                avro_reader = fastavro.reader(fp)
+                avro_reader = fastavro.reader(fp)  # type: ignore [arg-type]
                 schema = avro_reader.writer_schema
                 schema_field_name_to_type = {
-                    field["name"]: field["type"] for field in schema["fields"]
+                    field["name"]: cast(dict[str, Any], field["type"])  # type: ignore [index]
+                    for field in schema["fields"]  # type: ignore [index, call-overload]  # If schema is not dict, it is not subscriptable by strings
                 }
                 for record in avro_reader:
                     line_no += 1
                     yield {
                         record_field: self._to_output_value(
                             avro_format,
-                            schema_field_name_to_type[record_field],
-                            record[record_field],
+                            schema_field_name_to_type[record_field],  # type: ignore [index] # Any not subscriptable
+                            record[record_field],  # type: ignore [index] # Any not subscriptable
                         )
                         for record_field, record_value in schema_field_name_to_type.items()
                     }

airbyte_cdk/sources/file_based/file_types/csv_parser.py

@@ -12,7 +12,7 @@ from io import IOBase
 from typing import Any, Callable, Dict, Generator, Iterable, List, Mapping, Optional, Set, Tuple
 from uuid import uuid4
 
-from orjson import orjson
+import orjson
 
 from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.file_based.config.csv_format import (
@@ -117,7 +117,7 @@ class _CsvReader:
         """
         # Note that this method assumes the dialect has already been registered if we're parsing the headers
         if isinstance(config_format.header_definition, CsvHeaderUserProvided):
-            return config_format.header_definition.column_names  # type: ignore  # should be CsvHeaderUserProvided given the type
+            return config_format.header_definition.column_names
 
         if isinstance(config_format.header_definition, CsvHeaderAutogenerated):
             self._skip_rows(
@@ -229,7 +229,7 @@ class CsvParser(FileTypeParser):
             if discovered_schema:
                 property_types = {
                     col: prop["type"] for col, prop in discovered_schema["properties"].items()
-                }  # type: ignore # discovered_schema["properties"] is known to be a mapping
+                }
                 deduped_property_types = CsvParser._pre_propcess_property_types(property_types)
             else:
                 deduped_property_types = {}

airbyte_cdk/sources/file_based/file_types/excel_parser.py

@@ -7,10 +7,10 @@ from io import IOBase
 from pathlib import Path
 from typing import Any, Dict, Iterable, Mapping, Optional, Tuple, Union
 
+import orjson
 import pandas as pd
 from numpy import datetime64, issubdtype
 from numpy import dtype as dtype_
-from orjson import orjson
 from pydantic.v1 import BaseModel
 
 from airbyte_cdk.sources.file_based.config.file_based_stream_config import (
@@ -69,8 +69,11 @@ class ExcelParser(FileTypeParser):
             df = self.open_and_parse_file(fp)
             for column, df_type in df.dtypes.items():
                 # Choose the broadest data type if the column's data type differs in dataframes
-                prev_frame_column_type = fields.get(column)
-                fields[column] = self.dtype_to_json_type(prev_frame_column_type, df_type)
+                prev_frame_column_type = fields.get(column)  # type: ignore [call-overload]
+                fields[column] = self.dtype_to_json_type(  # type: ignore [index]
+                    prev_frame_column_type,
+                    df_type,
+                )
 
         schema = {
             field: (
@@ -136,7 +139,10 @@ class ExcelParser(FileTypeParser):
         return FileReadMode.READ_BINARY
 
     @staticmethod
-    def dtype_to_json_type(current_type: Optional[str], dtype: dtype_) -> str:
+    def dtype_to_json_type(
+        current_type: Optional[str],
+        dtype: dtype_,  # type: ignore [type-arg]
+    ) -> str:
         """
         Convert Pandas DataFrame types to Airbyte Types.
 
@@ -187,4 +193,4 @@ class ExcelParser(FileTypeParser):
         Returns:
             pd.DataFrame: Parsed data from the Excel file.
         """
-        return pd.ExcelFile(fp, engine="calamine").parse()
+        return pd.ExcelFile(fp, engine="calamine").parse()  # type: ignore [arg-type, call-overload, no-any-return]

airbyte_cdk/sources/file_based/file_types/jsonl_parser.py

@@ -6,7 +6,7 @@ import json
 import logging
 from typing import Any, Dict, Iterable, Mapping, Optional, Tuple, Union
 
-from orjson import orjson
+import orjson
 
 from airbyte_cdk.sources.file_based.config.file_based_stream_config import FileBasedStreamConfig
 from airbyte_cdk.sources.file_based.exceptions import FileBasedSourceError, RecordParseError

airbyte_cdk/sources/file_based/stream/abstract_file_based_stream.py

@@ -6,7 +6,7 @@ from abc import abstractmethod
 from functools import cache, cached_property, lru_cache
 from typing import Any, Dict, Iterable, List, Mapping, Optional, Type
 
-from deprecated import deprecated
+from typing_extensions import deprecated
 
 from airbyte_cdk import AirbyteMessage
 from airbyte_cdk.models import SyncMode
@@ -179,7 +179,7 @@ class AbstractFileBasedStream(Stream):
             )
 
     @cached_property
-    @deprecated(version="3.7.0")
+    @deprecated("Deprecated as of CDK version 3.7.0.")
     def availability_strategy(self) -> AbstractFileBasedAvailabilityStrategy:
         return self._availability_strategy
 

airbyte_cdk/sources/file_based/stream/concurrent/adapters.py

@@ -7,7 +7,7 @@ import logging
 from functools import cache, lru_cache
 from typing import TYPE_CHECKING, Any, Iterable, List, Mapping, MutableMapping, Optional, Union
 
-from deprecated.classic import deprecated
+from typing_extensions import deprecated
 
 from airbyte_cdk.models import (
     AirbyteLogMessage,
@@ -56,7 +56,10 @@ This module contains adapters to help enabling concurrency on File-based Stream
 """
 
 
-@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@deprecated(
+    "This class is experimental. Use at your own risk.",
+    category=ExperimentalClassWarning,
+)
 class FileBasedStreamFacade(AbstractStreamFacade[DefaultStream], AbstractFileBasedStream):
     @classmethod
     def create_from_stream(
@@ -143,7 +146,7 @@ class FileBasedStreamFacade(AbstractStreamFacade[DefaultStream], AbstractFileBas
         return self._legacy_stream.supports_incremental
 
     @property
-    @deprecated(version="3.7.0")
+    @deprecated("Deprecated as of CDK version 3.7.0.")
     def availability_strategy(self) -> AbstractFileBasedAvailabilityStrategy:
         return self._legacy_stream.availability_strategy
 

airbyte_cdk/sources/file_based/stream/cursor/default_file_based_cursor.py

@@ -21,7 +21,7 @@ class DefaultFileBasedCursor(AbstractFileBasedCursor):
     CURSOR_FIELD = "_ab_source_file_last_modified"
 
     def __init__(self, stream_config: FileBasedStreamConfig, **_: Any):
-        super().__init__(stream_config)
+        super().__init__(stream_config)  # type: ignore [safe-super]
         self._file_to_datetime_history: MutableMapping[str, str] = {}
         self._time_window_if_history_is_full = timedelta(
             days=stream_config.days_to_sync_if_history_is_full

airbyte_cdk/sources/http_logger.py

@@ -14,7 +14,7 @@ def format_http_message(
     title: str,
     description: str,
     stream_name: Optional[str],
-    is_auxiliary: bool = None,
+    is_auxiliary: bool | None = None,
 ) -> LogMessage:
     request = response.request
     log_message = {
@@ -42,10 +42,10 @@ def format_http_message(
         "url": {"full": request.url},
     }
     if is_auxiliary is not None:
-        log_message["http"]["is_auxiliary"] = is_auxiliary
+        log_message["http"]["is_auxiliary"] = is_auxiliary  # type: ignore [index]
     if stream_name:
         log_message["airbyte_cdk"] = {"stream": {"name": stream_name}}
-    return log_message
+    return log_message  # type: ignore [return-value]  # got "dict[str, object]", expected "dict[str, JsonType]"
 
 
 def _normalize_body_string(body_str: Optional[Union[str, bytes]]) -> Optional[str]:

airbyte_cdk/sources/streams/concurrent/abstract_stream.py

@@ -5,7 +5,7 @@
 from abc import ABC, abstractmethod
 from typing import Any, Iterable, Mapping, Optional
 
-from deprecated.classic import deprecated
+from typing_extensions import deprecated
 
 from airbyte_cdk.models import AirbyteStream
 from airbyte_cdk.sources.source import ExperimentalClassWarning
@@ -14,7 +14,10 @@ from airbyte_cdk.sources.streams.concurrent.cursor import Cursor
 from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
 
 
-@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@deprecated(
+    "This class is experimental. Use at your own risk.",
+    category=ExperimentalClassWarning,
+)
 class AbstractStream(ABC):
     """
     AbstractStream is an experimental interface for streams developed as part of the Concurrent CDK.

airbyte_cdk/sources/streams/concurrent/adapters.py

@@ -8,7 +8,7 @@ import logging
 from functools import lru_cache
 from typing import Any, Iterable, List, Mapping, MutableMapping, Optional, Tuple, Union
 
-from deprecated.classic import deprecated
+from typing_extensions import deprecated
 
 from airbyte_cdk.models import (
     AirbyteLogMessage,
@@ -50,7 +50,10 @@ This module contains adapters to help enabling concurrency on Stream objects wit
 """
 
 
-@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@deprecated(
+    "This class is experimental. Use at your own risk.",
+    category=ExperimentalClassWarning,
+)
 class StreamFacade(AbstractStreamFacade[DefaultStream], Stream):
     """
     The StreamFacade is a Stream that wraps an AbstractStream and exposes it as a Stream.
@@ -297,7 +300,7 @@ class StreamPartition(Partition):
                     yield Record(
                         data=data_to_return,
                         stream_name=self.stream_name(),
-                        associated_slice=self._slice,
+                        associated_slice=self._slice,  # type: ignore [arg-type]
                     )
                 else:
                     self._message_repository.emit_message(record_data)

airbyte_cdk/sources/streams/concurrent/availability_strategy.py

@@ -6,7 +6,7 @@ import logging
 from abc import ABC, abstractmethod
 from typing import Optional
 
-from deprecated.classic import deprecated
+from typing_extensions import deprecated
 
 from airbyte_cdk.sources.source import ExperimentalClassWarning
 
@@ -48,7 +48,10 @@ class StreamUnavailable(StreamAvailability):
 STREAM_AVAILABLE = StreamAvailable()
 
 
-@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@deprecated(
+    "This class is experimental. Use at your own risk.",
+    category=ExperimentalClassWarning,
+)
 class AbstractAvailabilityStrategy(ABC):
     """
     AbstractAvailabilityStrategy is an experimental interface developed as part of the Concurrent CDK.
@@ -68,7 +71,10 @@ class AbstractAvailabilityStrategy(ABC):
         """
 
 
-@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@deprecated(
+    "This class is experimental. Use at your own risk.",
+    category=ExperimentalClassWarning,
+)
 class AlwaysAvailableAvailabilityStrategy(AbstractAvailabilityStrategy):
     """
     An availability strategy that always indicates a stream is available.

airbyte_cdk/sources/streams/concurrent/cursor.py

@@ -473,7 +473,7 @@ class ConcurrentCursor(Cursor):
         :return: True if the record's cursor value falls within the sync boundaries
         """
         try:
-            record_cursor_value: CursorValueType = self._extract_cursor_value(record)  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__
+            record_cursor_value: CursorValueType = self._extract_cursor_value(record)
         except ValueError:
             self._log_for_record_without_cursor_value()
             return True

airbyte_cdk/sources/streams/concurrent/state_converters/datetime_stream_state_converter.py

@@ -141,7 +141,7 @@ class EpochValueConcurrentStreamStateConverter(DateTimeStreamStateConverter):
             raise ValueError(
                 f"DateTime object was expected but got {type(dt_object)} from pendulum.parse({timestamp})"
             )
-        return dt_object  # type: ignore  # we are manually type checking because pendulum.parse may return different types
+        return dt_object
 
 
 class IsoMillisConcurrentStreamStateConverter(DateTimeStreamStateConverter):
@@ -178,7 +178,7 @@ class IsoMillisConcurrentStreamStateConverter(DateTimeStreamStateConverter):
             raise ValueError(
                 f"DateTime object was expected but got {type(dt_object)} from pendulum.parse({timestamp})"
             )
-        return dt_object  # type: ignore  # we are manually type checking because pendulum.parse may return different types
+        return dt_object
 
 
 class CustomFormatConcurrentStreamStateConverter(IsoMillisConcurrentStreamStateConverter):

airbyte_cdk/sources/streams/core.py

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from functools import cached_property, lru_cache
 from typing import Any, Dict, Iterable, Iterator, List, Mapping, MutableMapping, Optional, Union
 
-from deprecated import deprecated
+from typing_extensions import deprecated
 
 import airbyte_cdk.sources.utils.casing as casing
 from airbyte_cdk.models import (
@@ -92,8 +92,8 @@ class CheckpointMixin(ABC):
 
 
 @deprecated(
-    version="0.87.0",
-    reason="Deprecated in favor of the CheckpointMixin which offers similar functionality",
+    "Deprecated as of CDK version 0.87.0. "
+    "Deprecated in favor of the `CheckpointMixin` which offers similar functionality."
 )
 class IncrementalMixin(CheckpointMixin, ABC):
     """Mixin to make stream incremental.
@@ -115,12 +115,6 @@ class StreamClassification:
     has_multiple_slices: bool
 
 
-# Moved to class declaration since get_updated_state is called on every record for incremental syncs, and thus the @deprecated decorator as well.
-@deprecated(
-    version="0.1.49",
-    reason="Deprecated method get_updated_state, You should use explicit state property instead, see IncrementalMixin docs.",
-    action="ignore",
-)
 class Stream(ABC):
     """
     Base abstract class for an Airbyte Stream. Makes no assumption of the Stream's underlying transport protocol.
@@ -222,7 +216,8 @@ class Stream(ABC):
                         # Some connectors have streams that implement get_updated_state(), but do not define a cursor_field. This
                         # should be fixed on the stream implementation, but we should also protect against this in the CDK as well
                         stream_state_tracker = self.get_updated_state(
-                            stream_state_tracker, record_data
+                            stream_state_tracker,
+                            record_data,  # type: ignore [arg-type]
                         )
                         self._observe_state(checkpoint_reader, stream_state_tracker)
                     record_counter += 1
@@ -282,7 +277,7 @@ class Stream(ABC):
             if state
             else {},  # read() expects MutableMapping instead of Mapping which is used more often
             state_manager=None,
-            internal_config=InternalConfig(),
+            internal_config=InternalConfig(),  # type: ignore [call-arg]
         )
 
     @abstractmethod
@@ -322,7 +317,7 @@ class Stream(ABC):
         # If we can offer incremental we always should. RFR is always less reliable than incremental which uses a real cursor value
         if self.supports_incremental:
             stream.source_defined_cursor = self.source_defined_cursor
-            stream.supported_sync_modes.append(SyncMode.incremental)  # type: ignore
+            stream.supported_sync_modes.append(SyncMode.incremental)
             stream.default_cursor_field = self._wrapped_cursor_field()
 
         keys = Stream._wrapped_primary_key(self.primary_key)
@@ -436,10 +431,18 @@ class Stream(ABC):
         """
         return None
 
+    # Commented-out to avoid any runtime penalty, since this is used in a hot per-record codepath.
+    # To be evaluated for re-introduction here: https://github.com/airbytehq/airbyte-python-cdk/issues/116
+    # @deprecated(
+    #     "Deprecated method `get_updated_state` as of CDK version 0.1.49. "
+    #     "Please use explicit state property instead, see `IncrementalMixin` docs."
+    # )
     def get_updated_state(
         self, current_stream_state: MutableMapping[str, Any], latest_record: Mapping[str, Any]
     ) -> MutableMapping[str, Any]:
-        """Override to extract state from the latest record. Needed to implement incremental sync.
+        """DEPRECATED. Please use explicit state property instead, see `IncrementalMixin` docs.
+
+        Override to extract state from the latest record. Needed to implement incremental sync.
 
         Inspects the latest record extracted from the data source and the current state object and return an updated state object.
 
@@ -654,7 +657,7 @@ class Stream(ABC):
         # todo: This can be consolidated into one ConnectorStateManager.update_and_create_state_message() method, but I want
         #  to reduce changes right now and this would span concurrent as well
         state_manager.update_state_for_stream(self.name, self.namespace, stream_state)
-        return state_manager.create_state_message(self.name, self.namespace)
+        return state_manager.create_state_message(self.name, self.namespace)  # type: ignore [no-any-return]
 
     @property
     def configured_json_schema(self) -> Optional[Dict[str, Any]]:

airbyte_cdk/sources/streams/http/http.py

@@ -9,8 +9,8 @@ from typing import Any, Callable, Iterable, List, Mapping, MutableMapping, Optio
 from urllib.parse import urljoin
 
 import requests
-from deprecated import deprecated
 from requests.auth import AuthBase
+from typing_extensions import deprecated
 
 from airbyte_cdk.models import AirbyteMessage, FailureType, SyncMode
 from airbyte_cdk.models import Type as MessageType
@@ -121,8 +121,8 @@ class HttpStream(Stream, CheckpointMixin, ABC):
 
     @property
     @deprecated(
-        version="3.0.0",
-        reason="You should set error_handler explicitly in HttpStream.get_error_handler() instead.",
+        "Deprecated as of CDK version 3.0.0. "
+        "You should set error_handler explicitly in HttpStream.get_error_handler() instead."
     )
     def raise_on_http_errors(self) -> bool:
         """
@@ -132,8 +132,8 @@ class HttpStream(Stream, CheckpointMixin, ABC):
 
     @property
     @deprecated(
-        version="3.0.0",
-        reason="You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead.",
+        "Deprecated as of CDK version 3.0.0. "
+        "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
     )
     def max_retries(self) -> Union[int, None]:
         """
@@ -143,8 +143,8 @@ class HttpStream(Stream, CheckpointMixin, ABC):
 
     @property
     @deprecated(
-        version="3.0.0",
-        reason="You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead.",
+        "Deprecated as of CDK version 3.0.0. "
+        "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
     )
     def max_time(self) -> Union[int, None]:
         """
@@ -154,8 +154,8 @@ class HttpStream(Stream, CheckpointMixin, ABC):
 
     @property
     @deprecated(
-        version="3.0.0",
-        reason="You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead.",
+        "Deprecated as of CDK version 3.0.0. "
+        "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
     )
     def retry_factor(self) -> float:
         """
@@ -594,7 +594,7 @@ class HttpSubStream(HttpStream, ABC):
             # Skip non-records (eg AirbyteLogMessage)
             if isinstance(parent_record, AirbyteMessage):
                 if parent_record.type == MessageType.RECORD:
-                    parent_record = parent_record.record.data
+                    parent_record = parent_record.record.data  # type: ignore [assignment, union-attr]  # Incorrect type for assignment
                 else:
                     continue
             elif isinstance(parent_record, Record):
@@ -603,8 +603,8 @@ class HttpSubStream(HttpStream, ABC):
 
 
 @deprecated(
-    version="3.0.0",
-    reason="You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead.",
+    "Deprecated as of CDK version 3.0.0."
+    "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
 )
 class HttpStreamAdapterBackoffStrategy(BackoffStrategy):
     def __init__(self, stream: HttpStream):
@@ -619,8 +619,8 @@ class HttpStreamAdapterBackoffStrategy(BackoffStrategy):
 
 
 @deprecated(
-    version="3.0.0",
-    reason="You should set error_handler explicitly in HttpStream.get_error_handler() instead.",
+    "Deprecated as of CDK version 3.0.0. "
+    "You should set error_handler explicitly in HttpStream.get_error_handler() instead."
 )
 class HttpStreamAdapterHttpStatusErrorHandler(HttpStatusErrorHandler):
     def __init__(self, stream: HttpStream, **kwargs):  # type: ignore # noqa
@@ -639,15 +639,15 @@ class HttpStreamAdapterHttpStatusErrorHandler(HttpStatusErrorHandler):
                     return ErrorResolution(
                         response_action=ResponseAction.RATE_LIMITED,
                         failure_type=FailureType.transient_error,
-                        error_message=f"Response status code: {response_or_exception.status_code}. Retrying...",  # type: ignore[union-attr]
+                        error_message=f"Response status code: {response_or_exception.status_code}. Retrying...",
                     )
                 return ErrorResolution(
                     response_action=ResponseAction.RETRY,
                     failure_type=FailureType.transient_error,
-                    error_message=f"Response status code: {response_or_exception.status_code}. Retrying...",  # type: ignore[union-attr]
+                    error_message=f"Response status code: {response_or_exception.status_code}. Retrying...",
                 )
             else:
-                if response_or_exception.ok:  # type: ignore # noqa
+                if response_or_exception.ok:
                     return ErrorResolution(
                         response_action=ResponseAction.SUCCESS,
                         failure_type=None,
@@ -657,13 +657,13 @@ class HttpStreamAdapterHttpStatusErrorHandler(HttpStatusErrorHandler):
                     return ErrorResolution(
                         response_action=ResponseAction.FAIL,
                         failure_type=FailureType.transient_error,
-                        error_message=f"Response status code: {response_or_exception.status_code}. Unexpected error. Failed.",  # type: ignore[union-attr]
+                        error_message=f"Response status code: {response_or_exception.status_code}. Unexpected error. Failed.",
                     )
                 else:
                     return ErrorResolution(
                         response_action=ResponseAction.IGNORE,
                         failure_type=FailureType.transient_error,
-                        error_message=f"Response status code: {response_or_exception.status_code}. Ignoring...",  # type: ignore[union-attr]
+                        error_message=f"Response status code: {response_or_exception.status_code}. Ignoring...",
                     )
         else:
             self._logger.error(f"Received unexpected response type: {type(response_or_exception)}")