airbyte-cdk 6.8.1.dev1__py3-none-any.whl → 6.8.1rc1__py3-none-any.whl

airbyte_cdk/sources/declarative/partition_routers/substream_partition_router.py

@@ -130,11 +130,11 @@ class SubstreamPartitionRouter(PartitionRouter):
                     if value:
                         params.update(
                             {
-                                parent_config.request_option.field_name.eval(  # type: ignore [union-attr]
+                                parent_config.request_option.field_name.eval(
                                     config=self.config
                                 ): value
                             }
-                        )
+                        )  # type: ignore # field_name is always casted to an interpolated string
         return params
 
     def stream_slices(self) -> Iterable[StreamSlice]:
@@ -162,9 +162,9 @@ class SubstreamPartitionRouter(PartitionRouter):
                 extra_fields = None
                 if parent_stream_config.extra_fields:
                     extra_fields = [
-                        [field_path_part.eval(self.config) for field_path_part in field_path]  # type: ignore [union-attr]
+                        [field_path_part.eval(self.config) for field_path_part in field_path]
                         for field_path in parent_stream_config.extra_fields
-                    ]
+                    ]  # type: ignore # extra_fields is always casted to an interpolated string
 
                 # read_stateless() assumes the parent is not concurrent. This is currently okay since the concurrent CDK does
                 # not support either substreams or RFR, but something that needs to be considered once we do
@@ -192,10 +192,7 @@ class SubstreamPartitionRouter(PartitionRouter):
                             message=f"Parent stream returned records as invalid type {type(parent_record)}"
                         )
                     try:
-                        partition_value = dpath.get(
-                            parent_record,  # type: ignore [arg-type]
-                            parent_field,
-                        )
+                        partition_value = dpath.get(parent_record, parent_field)
                     except KeyError:
                         continue
 
@@ -231,10 +228,7 @@ class SubstreamPartitionRouter(PartitionRouter):
         if extra_fields:
             for extra_field_path in extra_fields:
                 try:
-                    extra_field_value = dpath.get(
-                        parent_record,  # type: ignore [arg-type]
-                        extra_field_path,
-                    )
+                    extra_field_value = dpath.get(parent_record, extra_field_path)
                     self.logger.debug(
                         f"Extracted extra_field_path: {extra_field_path} with value: {extra_field_value}"
                     )
@@ -297,7 +291,7 @@ class SubstreamPartitionRouter(PartitionRouter):
         if not parent_state and incremental_dependency:
             # Attempt to retrieve child state
             substream_state = list(stream_state.values())
-            substream_state = substream_state[0] if substream_state else {}  # type: ignore [assignment]  # Incorrect type for assignment
+            substream_state = substream_state[0] if substream_state else {}
             parent_state = {}
 
             # Copy child state to parent streams with incremental dependencies

airbyte_cdk/sources/declarative/requesters/error_handlers/default_error_handler.py

@@ -141,7 +141,7 @@ class DefaultErrorHandler(ErrorHandler):
             for backoff_strategy in self.backoff_strategies:
                 backoff = backoff_strategy.backoff_time(
                     response_or_exception=response_or_exception, attempt_count=attempt_count
-                )
+                )  # type: ignore # attempt_count maintained for compatibility with low code CDK
                 if backoff:
                     return backoff
         return backoff

airbyte_cdk/sources/declarative/requesters/error_handlers/http_response_filter.py

@@ -151,23 +151,21 @@ class HttpResponseFilter:
         :param response: The HTTP response which can be used during interpolation
         :return: The evaluated error message string to be emitted
         """
-        return self.error_message.eval(  # type: ignore [no-any-return, union-attr]
+        return self.error_message.eval(
             self.config, response=self._safe_response_json(response), headers=response.headers
-        )
+        )  # type: ignore # error_message is always cast to an interpolated string
 
     def _response_matches_predicate(self, response: requests.Response) -> bool:
         return (
             bool(
-                self.predicate.condition  # type: ignore [union-attr]
-                and self.predicate.eval(  # type: ignore [union-attr]
-                    None,  # type: ignore [arg-type]
-                    response=self._safe_response_json(response),
-                    headers=response.headers,
+                self.predicate.condition
+                and self.predicate.eval(
+                    None, response=self._safe_response_json(response), headers=response.headers
                 )
             )
             if self.predicate
             else False
-        )
+        )  # type: ignore # predicate is always cast to an interpolated string
 
     def _response_contains_error_message(self, response: requests.Response) -> bool:
         if not self.error_message_contains:

airbyte_cdk/sources/declarative/requesters/paginators/default_paginator.py

@@ -194,7 +194,7 @@ class DefaultPaginator(Paginator):
             and self.pagination_strategy.get_page_size()
             and self.page_size_option.inject_into == option_type
         ):
-            options[self.page_size_option.field_name.eval(config=self.config)] = (  # type: ignore [union-attr]
+            options[self.page_size_option.field_name.eval(config=self.config)] = (
                 self.pagination_strategy.get_page_size()
             )  # type: ignore # field_name is always cast to an interpolated string
         return options

airbyte_cdk/sources/declarative/requesters/request_options/datetime_based_request_options_provider.py

@@ -85,7 +85,7 @@ class DatetimeBasedRequestOptionsProvider(RequestOptionsProvider):
                 self._partition_field_start.eval(self.config)
             )
         if self.end_time_option and self.end_time_option.inject_into == option_type:
-            options[self.end_time_option.field_name.eval(config=self.config)] = stream_slice.get(  # type: ignore [union-attr]
+            options[self.end_time_option.field_name.eval(config=self.config)] = stream_slice.get(
                 self._partition_field_end.eval(self.config)
-            )
+            )  # type: ignore # field_name is always casted to an interpolated string
         return options

airbyte_cdk/sources/declarative/requesters/request_options/interpolated_request_options_provider.py

@@ -5,7 +5,7 @@
 from dataclasses import InitVar, dataclass, field
 from typing import Any, Mapping, MutableMapping, Optional, Union
 
-from typing_extensions import deprecated
+from deprecated import deprecated
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping import NestedMapping
 from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_nested_request_input_provider import (

airbyte_cdk/sources/declarative/retrievers/async_retriever.py

@@ -4,7 +4,7 @@
 from dataclasses import InitVar, dataclass, field
 from typing import Any, Callable, Iterable, Mapping, Optional
 
-from typing_extensions import deprecated
+from deprecated.classic import deprecated
 
 from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.declarative.async_job.job_orchestrator import (
@@ -21,10 +21,7 @@ from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 
 
-@deprecated(
-    "This class is experimental. Use at your own risk.",
-    category=ExperimentalClassWarning,
-)
+@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
 @dataclass
 class AsyncRetriever(Retriever):
     config: Config

airbyte_cdk/sources/declarative/spec/spec.py

@@ -9,7 +9,7 @@ from airbyte_cdk.models import (
     AdvancedAuth,
     ConnectorSpecification,
     ConnectorSpecificationSerializer,
-)
+)  # type: ignore [attr-defined]
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import AuthFlow
 
 

airbyte_cdk/sources/embedded/base_integration.py

@@ -52,9 +52,8 @@ class BaseEmbeddedIntegration(ABC, Generic[TConfig, TOutput]):
         for message in self.source.read(self.config, configured_catalog, state):
             if message.type == Type.RECORD:
                 output = self._handle_record(
-                    message.record,
-                    get_defined_id(stream, message.record.data),  # type: ignore[union-attr, arg-type]
-                )
+                    message.record, get_defined_id(stream, message.record.data)
+                )  # type: ignore[union-attr] # record has `data`
                 if output:
                     yield output
             elif message.type is Type.STATE and message.state:

airbyte_cdk/sources/file_based/availability_strategy/abstract_file_based_availability_strategy.py

@@ -2,8 +2,6 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
-from __future__ import annotations
-
 import logging
 from abc import abstractmethod
 from typing import TYPE_CHECKING, Optional, Tuple
@@ -24,11 +22,8 @@ if TYPE_CHECKING:
 
 class AbstractFileBasedAvailabilityStrategy(AvailabilityStrategy):
     @abstractmethod
-    def check_availability(  # type: ignore[override]  # Signature doesn't match base class
-        self,
-        stream: Stream,
-        logger: logging.Logger,
-        _: Optional[Source],
+    def check_availability(
+        self, stream: Stream, logger: logging.Logger, _: Optional[Source]
     ) -> Tuple[bool, Optional[str]]:
         """
         Perform a connection check for the stream.
@@ -39,10 +34,7 @@ class AbstractFileBasedAvailabilityStrategy(AvailabilityStrategy):
 
     @abstractmethod
     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]]:
         """
         Performs a connection check for the stream, as well as additional checks that
@@ -54,7 +46,7 @@ class AbstractFileBasedAvailabilityStrategy(AvailabilityStrategy):
 
 
 class AbstractFileBasedAvailabilityStrategyWrapper(AbstractAvailabilityStrategy):
-    def __init__(self, stream: AbstractFileBasedStream) -> None:
+    def __init__(self, stream: "AbstractFileBasedStream"):
         self.stream = stream
 
     def check_availability(self, logger: logging.Logger) -> StreamAvailability:

airbyte_cdk/sources/file_based/availability_strategy/default_file_based_availability_strategy.py

@@ -2,8 +2,6 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
-from __future__ import annotations
-
 import logging
 import traceback
 from typing import TYPE_CHECKING, Optional, Tuple
@@ -27,15 +25,12 @@ if TYPE_CHECKING:
 
 
 class DefaultFileBasedAvailabilityStrategy(AbstractFileBasedAvailabilityStrategy):
-    def __init__(self, stream_reader: AbstractFileBasedStreamReader) -> None:
+    def __init__(self, stream_reader: AbstractFileBasedStreamReader):
         self.stream_reader = stream_reader
 
-    def check_availability(  # type: ignore[override]  # Signature doesn't match base class
-        self,
-        stream: AbstractFileBasedStream,
-        logger: logging.Logger,
-        _: Optional[Source],
-    ) -> Tuple[bool, Optional[str]]:
+    def check_availability(
+        self, stream: "AbstractFileBasedStream", logger: logging.Logger, _: Optional[Source]
+    ) -> Tuple[bool, Optional[str]]:  # type: ignore[override]
         """
         Perform a connection check for the stream (verify that we can list files from the stream).
 
@@ -49,10 +44,7 @@ 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.
@@ -90,7 +82,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.
 
@@ -110,10 +102,7 @@ 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, cast
+from typing import Any, Dict, Iterable, Mapping, Optional, Tuple
 
 import fastavro
 
@@ -64,20 +64,18 @@ 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)  # type: ignore [arg-type]
+            avro_reader = fastavro.reader(fp)
             avro_schema = avro_reader.writer_schema
-        if not avro_schema["type"] == "record":  # type: ignore [index, call-overload]
-            unsupported_type = avro_schema["type"]  # type: ignore [index, call-overload]
+        if not avro_schema["type"] == "record":
+            unsupported_type = avro_schema["type"]
             raise ValueError(
                 f"Only record based avro files are supported. Found {unsupported_type}"
             )
         json_schema = {
-            field["name"]: AvroParser._convert_avro_type_to_json(  # type: ignore [index]
-                avro_format,
-                field["name"],  # type: ignore [index]
-                field["type"],  # type: ignore [index]
+            field["name"]: AvroParser._convert_avro_type_to_json(
+                avro_format, field["name"], field["type"]
             )
-            for field in avro_schema["fields"]  # type: ignore [index, call-overload]
+            for field in avro_schema["fields"]
         }
         return json_schema
 
@@ -182,19 +180,18 @@ 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)  # type: ignore [arg-type]
+                avro_reader = fastavro.reader(fp)
                 schema = avro_reader.writer_schema
                 schema_field_name_to_type = {
-                    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
+                    field["name"]: field["type"] for field in schema["fields"]
                 }
                 for record in avro_reader:
                     line_no += 1
                     yield {
                         record_field: self._to_output_value(
                             avro_format,
-                            schema_field_name_to_type[record_field],  # type: ignore [index] # Any not subscriptable
-                            record[record_field],  # type: ignore [index] # Any not subscriptable
+                            schema_field_name_to_type[record_field],
+                            record[record_field],
                         )
                         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
 
-import orjson
+from 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
+            return config_format.header_definition.column_names  # type: ignore  # should be CsvHeaderUserProvided given the type
 
         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,11 +69,8 @@ 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)  # type: ignore [call-overload]
-                fields[column] = self.dtype_to_json_type(  # type: ignore [index]
-                    prev_frame_column_type,
-                    df_type,
-                )
+                prev_frame_column_type = fields.get(column)
+                fields[column] = self.dtype_to_json_type(prev_frame_column_type, df_type)
 
         schema = {
             field: (
@@ -139,10 +136,7 @@ class ExcelParser(FileTypeParser):
         return FileReadMode.READ_BINARY
 
     @staticmethod
-    def dtype_to_json_type(
-        current_type: Optional[str],
-        dtype: dtype_,  # type: ignore [type-arg]
-    ) -> str:
+    def dtype_to_json_type(current_type: Optional[str], dtype: dtype_) -> str:
         """
         Convert Pandas DataFrame types to Airbyte Types.
 
@@ -193,4 +187,4 @@ class ExcelParser(FileTypeParser):
         Returns:
             pd.DataFrame: Parsed data from the Excel file.
         """
-        return pd.ExcelFile(fp, engine="calamine").parse()  # type: ignore [arg-type, call-overload, no-any-return]
+        return pd.ExcelFile(fp, engine="calamine").parse()

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
 
-import orjson
+from 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 typing_extensions import deprecated
+from deprecated import deprecated
 
 from airbyte_cdk import AirbyteMessage
 from airbyte_cdk.models import SyncMode
@@ -179,7 +179,7 @@ class AbstractFileBasedStream(Stream):
             )
 
     @cached_property
-    @deprecated("Deprecated as of CDK version 3.7.0.")
+    @deprecated(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 typing_extensions import deprecated
+from deprecated.classic import deprecated
 
 from airbyte_cdk.models import (
     AirbyteLogMessage,
@@ -56,10 +56,7 @@ 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(
@@ -146,7 +143,7 @@ class FileBasedStreamFacade(AbstractStreamFacade[DefaultStream], AbstractFileBas
         return self._legacy_stream.supports_incremental
 
     @property
-    @deprecated("Deprecated as of CDK version 3.7.0.")
+    @deprecated(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)  # type: ignore [safe-super]
+        super().__init__(stream_config)
         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 = None,
+    is_auxiliary: bool = 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  # type: ignore [index]
+        log_message["http"]["is_auxiliary"] = is_auxiliary
     if stream_name:
         log_message["airbyte_cdk"] = {"stream": {"name": stream_name}}
-    return log_message  # type: ignore [return-value]  # got "dict[str, object]", expected "dict[str, JsonType]"
+    return log_message
 
 
 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 typing_extensions import deprecated
+from deprecated.classic import deprecated
 
 from airbyte_cdk.models import AirbyteStream
 from airbyte_cdk.sources.source import ExperimentalClassWarning
@@ -14,10 +14,7 @@ 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 typing_extensions import deprecated
+from deprecated.classic import deprecated
 
 from airbyte_cdk.models import (
     AirbyteLogMessage,
@@ -50,10 +50,7 @@ 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.
@@ -300,7 +297,7 @@ class StreamPartition(Partition):
                     yield Record(
                         data=data_to_return,
                         stream_name=self.stream_name(),
-                        associated_slice=self._slice,  # type: ignore [arg-type]
+                        associated_slice=self._slice,
                     )
                 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 typing_extensions import deprecated
+from deprecated.classic import deprecated
 
 from airbyte_cdk.sources.source import ExperimentalClassWarning
 
@@ -48,10 +48,7 @@ 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.
@@ -71,10 +68,7 @@ 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)
+            record_cursor_value: CursorValueType = self._extract_cursor_value(record)  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__
         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
+        return dt_object  # type: ignore  # we are manually type checking because pendulum.parse may return different types
 
 
 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
+        return dt_object  # type: ignore  # we are manually type checking because pendulum.parse may return different types
 
 
 class CustomFormatConcurrentStreamStateConverter(IsoMillisConcurrentStreamStateConverter):