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

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 typing_extensions import deprecated
+from deprecated import deprecated
 
 import airbyte_cdk.sources.utils.casing as casing
 from airbyte_cdk.models import (
@@ -92,8 +92,8 @@ class CheckpointMixin(ABC):
 
 
 @deprecated(
-    "Deprecated as of CDK version 0.87.0. "
-    "Deprecated in favor of the `CheckpointMixin` which offers similar functionality."
+    version="0.87.0",
+    reason="Deprecated in favor of the CheckpointMixin which offers similar functionality",
 )
 class IncrementalMixin(CheckpointMixin, ABC):
     """Mixin to make stream incremental.
@@ -115,6 +115,12 @@ 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.
@@ -216,8 +222,7 @@ 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,  # type: ignore [arg-type]
+                            stream_state_tracker, record_data
                         )
                         self._observe_state(checkpoint_reader, stream_state_tracker)
                     record_counter += 1
@@ -277,7 +282,7 @@ class Stream(ABC):
             if state
             else {},  # read() expects MutableMapping instead of Mapping which is used more often
             state_manager=None,
-            internal_config=InternalConfig(),  # type: ignore [call-arg]
+            internal_config=InternalConfig(),
         )
 
     @abstractmethod
@@ -317,7 +322,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)
+            stream.supported_sync_modes.append(SyncMode.incremental)  # type: ignore
             stream.default_cursor_field = self._wrapped_cursor_field()
 
         keys = Stream._wrapped_primary_key(self.primary_key)
@@ -431,18 +436,10 @@ 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]:
-        """DEPRECATED. Please use explicit state property instead, see `IncrementalMixin` docs.
-
-        Override to extract state from the latest record. Needed to implement incremental sync.
+        """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.
 
@@ -657,7 +654,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)  # type: ignore [no-any-return]
+        return state_manager.create_state_message(self.name, self.namespace)
 
     @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(
-        "Deprecated as of CDK version 3.0.0. "
-        "You should set error_handler explicitly in HttpStream.get_error_handler() instead."
+        version="3.0.0",
+        reason="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(
-        "Deprecated as of CDK version 3.0.0. "
-        "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
+        version="3.0.0",
+        reason="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(
-        "Deprecated as of CDK version 3.0.0. "
-        "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
+        version="3.0.0",
+        reason="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(
-        "Deprecated as of CDK version 3.0.0. "
-        "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
+        version="3.0.0",
+        reason="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  # type: ignore [assignment, union-attr]  # Incorrect type for assignment
+                    parent_record = parent_record.record.data
                 else:
                     continue
             elif isinstance(parent_record, Record):
@@ -603,8 +603,8 @@ class HttpSubStream(HttpStream, ABC):
 
 
 @deprecated(
-    "Deprecated as of CDK version 3.0.0."
-    "You should set backoff_strategies explicitly in HttpStream.get_backoff_strategy() instead."
+    version="3.0.0",
+    reason="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(
-    "Deprecated as of CDK version 3.0.0. "
-    "You should set error_handler explicitly in HttpStream.get_error_handler() instead."
+    version="3.0.0",
+    reason="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...",
+                        error_message=f"Response status code: {response_or_exception.status_code}. Retrying...",  # type: ignore[union-attr]
                     )
                 return ErrorResolution(
                     response_action=ResponseAction.RETRY,
                     failure_type=FailureType.transient_error,
-                    error_message=f"Response status code: {response_or_exception.status_code}. Retrying...",
+                    error_message=f"Response status code: {response_or_exception.status_code}. Retrying...",  # type: ignore[union-attr]
                 )
             else:
-                if response_or_exception.ok:
+                if response_or_exception.ok:  # type: ignore # noqa
                     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.",
+                        error_message=f"Response status code: {response_or_exception.status_code}. Unexpected error. Failed.",  # type: ignore[union-attr]
                     )
                 else:
                     return ErrorResolution(
                         response_action=ResponseAction.IGNORE,
                         failure_type=FailureType.transient_error,
-                        error_message=f"Response status code: {response_or_exception.status_code}. Ignoring...",
+                        error_message=f"Response status code: {response_or_exception.status_code}. Ignoring...",  # type: ignore[union-attr]
                     )
         else:
             self._logger.error(f"Received unexpected response type: {type(response_or_exception)}")

airbyte_cdk/sources/streams/http/http_client.py

@@ -54,6 +54,7 @@ from airbyte_cdk.utils.stream_status_utils import (
 from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 
 BODY_REQUEST_METHODS = ("GET", "POST", "PUT", "PATCH")
+logger = logging.getLogger("airbyte")
 
 
 class MessageRepresentationAirbyteTracedErrors(AirbyteTracedException):
@@ -142,9 +143,10 @@ class HttpClient:
                 sqlite_path = str(Path(cache_dir) / self.cache_filename)
             else:
                 sqlite_path = "file::memory:?cache=shared"
+            backend = SkipFailureSQLiteCache(sqlite_path)
             return CachedLimiterSession(
-                sqlite_path, backend="sqlite", api_budget=self._api_budget, match_headers=True
-            )
+                sqlite_path, backend=backend, api_budget=self._api_budget, match_headers=True
+            )  # type: ignore # there are no typeshed stubs for requests_cache
         else:
             return LimiterSession(api_budget=self._api_budget)
 
@@ -324,7 +326,7 @@ class HttpClient:
             formatter = log_formatter
             self._message_repository.log_message(
                 Level.DEBUG,
-                lambda: formatter(response),
+                lambda: formatter(response),  # type: ignore # log_formatter is always cast to a callable
             )
 
         self._handle_error_resolution(
@@ -517,3 +519,32 @@ class HttpClient:
         )
 
         return request, response
+
+
+class SkipFailureSQLiteDict(requests_cache.backends.sqlite.SQLiteDict):
+    def _write(self, key: str, value: str) -> None:
+        try:
+            super()._write(key, value)  # type: ignore  # lib is not typed
+        except Exception as exception:
+            logger.warning(exception)
+
+
+class SkipFailureSQLiteCache(requests_cache.backends.sqlite.SQLiteCache):
+    def __init__(  # type: ignore  # ignoring as lib is not typed
+        self,
+        db_path="http_cache",
+        serializer=None,
+        **kwargs,
+    ) -> None:
+        super().__init__(db_path, serializer, **kwargs)
+        skwargs = {"serializer": serializer, **kwargs} if serializer else kwargs
+        self.responses: requests_cache.backends.sqlite.SQLiteDict = SkipFailureSQLiteDict(
+            db_path, table_name="responses", **skwargs
+        )
+        self.redirects: requests_cache.backends.sqlite.SQLiteDict = SkipFailureSQLiteDict(
+            db_path,
+            table_name="redirects",
+            lock=self.responses._lock,
+            serializer=None,
+            **kwargs,
+        )

airbyte_cdk/sources/streams/http/requests_native_auth/abstract_token.py

@@ -5,14 +5,13 @@
 from abc import abstractmethod
 from typing import Any, Mapping
 
-import requests
 from requests.auth import AuthBase
 
 
 class AbstractHeaderAuthenticator(AuthBase):
     """Abstract class for an header-based authenticators that add a header to outgoing HTTP requests."""
 
-    def __call__(self, request: requests.PreparedRequest) -> Any:
+    def __call__(self, request):
         """Attach the HTTP headers required to authenticate on the HTTP request"""
         request.headers.update(self.get_auth_header())
         return request

airbyte_cdk/sources/streams/http/requests_native_auth/oauth.py

@@ -30,12 +30,12 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
         client_id: str,
         client_secret: str,
         refresh_token: str,
-        scopes: List[str] | None = None,
-        token_expiry_date: pendulum.DateTime | None = None,
-        token_expiry_date_format: str | None = None,
+        scopes: List[str] = None,
+        token_expiry_date: pendulum.DateTime = None,
+        token_expiry_date_format: str = None,
         access_token_name: str = "access_token",
         expires_in_name: str = "expires_in",
-        refresh_request_body: Mapping[str, Any] | None = None,
+        refresh_request_body: Mapping[str, Any] = None,
         grant_type: str = "refresh_token",
         token_expiry_is_time_of_expiration: bool = False,
         refresh_token_error_status_codes: Tuple[int, ...] = (),
@@ -52,7 +52,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
         self._refresh_request_body = refresh_request_body
         self._grant_type = grant_type
 
-        self._token_expiry_date = token_expiry_date or pendulum.now().subtract(days=1)  # type: ignore [no-untyped-call]
+        self._token_expiry_date = token_expiry_date or pendulum.now().subtract(days=1)
         self._token_expiry_date_format = token_expiry_date_format
         self._token_expiry_is_time_of_expiration = token_expiry_is_time_of_expiration
         self._access_token = None
@@ -75,14 +75,14 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
     def get_access_token_name(self) -> str:
         return self._access_token_name
 
-    def get_scopes(self) -> list[str]:
-        return self._scopes  # type: ignore [return-value]
+    def get_scopes(self) -> [str]:
+        return self._scopes
 
     def get_expires_in_name(self) -> str:
         return self._expires_in_name
 
     def get_refresh_request_body(self) -> Mapping[str, Any]:
-        return self._refresh_request_body  # type: ignore [return-value]
+        return self._refresh_request_body
 
     def get_grant_type(self) -> str:
         return self._grant_type
@@ -90,7 +90,7 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
     def get_token_expiry_date(self) -> pendulum.DateTime:
         return self._token_expiry_date
 
-    def set_token_expiry_date(self, value: Union[str, int]) -> None:
+    def set_token_expiry_date(self, value: Union[str, int]):
         self._token_expiry_date = self._parse_token_expiration_date(value)
 
     @property
@@ -103,11 +103,11 @@ class Oauth2Authenticator(AbstractOauth2Authenticator):
 
     @property
     def access_token(self) -> str:
-        return self._access_token  # type: ignore [return-value]
+        return self._access_token
 
     @access_token.setter
-    def access_token(self, value: str) -> None:
-        self._access_token = value  # type: ignore [assignment]  # Incorrect type for assignment
+    def access_token(self, value: str):
+        self._access_token = value
 
 
 class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
@@ -124,11 +124,11 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
         self,
         connector_config: Mapping[str, Any],
         token_refresh_endpoint: str,
-        scopes: List[str] | None = None,
+        scopes: List[str] = None,
         access_token_name: str = "access_token",
         expires_in_name: str = "expires_in",
         refresh_token_name: str = "refresh_token",
-        refresh_request_body: Mapping[str, Any] | None = None,
+        refresh_request_body: Mapping[str, Any] = None,
         grant_type: str = "refresh_token",
         client_id: Optional[str] = None,
         client_secret: Optional[str] = None,
@@ -162,17 +162,14 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             message_repository (MessageRepository): the message repository used to emit logs on HTTP requests and control message on config update
         """
         self._client_id = (
-            client_id  # type: ignore [assignment]  # Incorrect type for assignment
+            client_id
             if client_id is not None
-            else dpath.get(connector_config, ("credentials", "client_id"))  # type: ignore [arg-type]
+            else dpath.get(connector_config, ("credentials", "client_id"))
         )
         self._client_secret = (
-            client_secret  # type: ignore [assignment]  # Incorrect type for assignment
+            client_secret
             if client_secret is not None
-            else dpath.get(
-                connector_config,  # type: ignore [arg-type]
-                ("credentials", "client_secret"),
-            )
+            else dpath.get(connector_config, ("credentials", "client_secret"))
         )
         self._access_token_config_path = access_token_config_path
         self._refresh_token_config_path = refresh_token_config_path
@@ -210,50 +207,27 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
 
     @property
     def access_token(self) -> str:
-        return dpath.get(  # type: ignore [return-value]
-            self._connector_config,  # type: ignore [arg-type]
-            self._access_token_config_path,
-            default="",
-        )
+        return dpath.get(self._connector_config, self._access_token_config_path, default="")
 
     @access_token.setter
-    def access_token(self, new_access_token: str) -> None:
-        dpath.new(
-            self._connector_config,  # type: ignore [arg-type]
-            self._access_token_config_path,
-            new_access_token,
-        )
+    def access_token(self, new_access_token: str):
+        dpath.new(self._connector_config, self._access_token_config_path, new_access_token)
 
     def get_refresh_token(self) -> str:
-        return dpath.get(  # type: ignore [return-value]
-            self._connector_config,  # type: ignore [arg-type]
-            self._refresh_token_config_path,
-            default="",
-        )
+        return dpath.get(self._connector_config, self._refresh_token_config_path, default="")
 
-    def set_refresh_token(self, new_refresh_token: str) -> None:
-        dpath.new(
-            self._connector_config,  # type: ignore [arg-type]
-            self._refresh_token_config_path,
-            new_refresh_token,
-        )
+    def set_refresh_token(self, new_refresh_token: str):
+        dpath.new(self._connector_config, self._refresh_token_config_path, new_refresh_token)
 
     def get_token_expiry_date(self) -> pendulum.DateTime:
         expiry_date = dpath.get(
-            self._connector_config,  # type: ignore [arg-type]
-            self._token_expiry_date_config_path,
-            default="",
+            self._connector_config, self._token_expiry_date_config_path, default=""
         )
-        return pendulum.now().subtract(days=1) if expiry_date == "" else pendulum.parse(expiry_date)  # type: ignore [arg-type, return-value, no-untyped-call]
+        return pendulum.now().subtract(days=1) if expiry_date == "" else pendulum.parse(expiry_date)
 
-    def set_token_expiry_date(  # type: ignore[override]
-        self,
-        new_token_expiry_date: pendulum.DateTime,
-    ) -> None:
+    def set_token_expiry_date(self, new_token_expiry_date):
         dpath.new(
-            self._connector_config,  # type: ignore [arg-type]
-            self._token_expiry_date_config_path,
-            str(new_token_expiry_date),
+            self._connector_config, self._token_expiry_date_config_path, str(new_token_expiry_date)
         )
 
     def token_has_expired(self) -> bool:
@@ -262,8 +236,7 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
 
     @staticmethod
     def get_new_token_expiry_date(
-        access_token_expires_in: str,
-        token_expiry_date_format: str | None = None,
+        access_token_expires_in: str, token_expiry_date_format: str = None
     ) -> pendulum.DateTime:
         if token_expiry_date_format:
             return pendulum.from_format(access_token_expires_in, token_expiry_date_format)
@@ -280,7 +253,7 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             new_access_token, access_token_expires_in, new_refresh_token = (
                 self.refresh_access_token()
             )
-            new_token_expiry_date: pendulum.DateTime = self.get_new_token_expiry_date(
+            new_token_expiry_date = self.get_new_token_expiry_date(
                 access_token_expires_in, self._token_expiry_date_format
             )
             self.access_token = new_access_token
@@ -291,15 +264,13 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             #  message directly in the console, this is needed
             if not isinstance(self._message_repository, NoopMessageRepository):
                 self._message_repository.emit_message(
-                    create_connector_config_control_message(self._connector_config)  # type: ignore [arg-type]
+                    create_connector_config_control_message(self._connector_config)
                 )
             else:
-                emit_configuration_as_airbyte_control_message(self._connector_config)  # type: ignore [arg-type]
+                emit_configuration_as_airbyte_control_message(self._connector_config)
         return self.access_token
 
-    def refresh_access_token(  # type: ignore[override]  # Signature doesn't match base class
-        self,
-    ) -> Tuple[str, str, str]:
+    def refresh_access_token(self) -> Tuple[str, str, str]:
         response_json = self._get_refresh_access_token_response()
         return (
             response_json[self.get_access_token_name()],

airbyte_cdk/sources/utils/record_helper.py

@@ -35,7 +35,7 @@ def stream_data_to_airbyte_message(
             # need it to normalize values against json schema. By default no action
             # taken unless configured. See
             # docs/connector-development/cdk-python/schemas.md for details.
-            transformer.transform(data, schema)
+            transformer.transform(data, schema)  # type: ignore
             if is_file_transfer_message:
                 message = AirbyteFileTransferRecordMessage(
                     stream=stream_name, file=data, emitted_at=now_millis, data={}

airbyte_cdk/sources/utils/schema_helpers.py

@@ -194,7 +194,7 @@ class InternalConfig(BaseModel):
     def dict(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
         kwargs["by_alias"] = True
         kwargs["exclude_unset"] = True
-        return super().dict(*args, **kwargs)
+        return super().dict(*args, **kwargs)  # type: ignore[no-any-return]
 
     def is_limit_reached(self, records_counter: int) -> bool:
         """

airbyte_cdk/sources/utils/transform.py

@@ -5,9 +5,9 @@
 import logging
 from distutils.util import strtobool
 from enum import Flag, auto
-from typing import Any, Callable, Dict, Generator, Mapping, Optional, cast
+from typing import Any, Callable, Dict, Mapping, Optional
 
-from jsonschema import Draft7Validator, RefResolver, ValidationError, Validator, validators
+from jsonschema import Draft7Validator, ValidationError, validators
 
 json_to_python_simple = {
     "string": str,
@@ -30,7 +30,7 @@ class TransformConfig(Flag):
         ```
     """
 
-    # No action taken, default behavior. Cannot be combined with any other options.
+    # No action taken, default behaviour. Cannot be combined with any other options.
     NoTransform = auto()
     # Applies default type casting with default_convert method which converts
     # values by applying simple type casting to specified jsonschema type.
@@ -67,15 +67,15 @@ class TypeTransformer:
         )
 
     def registerCustomTransform(
-        self, normalization_callback: Callable[[Any, dict[str, Any]], Any]
-    ) -> Callable[[Any, dict[str, Any]], Any]:
+        self, normalization_callback: Callable[[Any, Dict[str, Any]], Any]
+    ) -> Callable:
         """
         Register custom normalization callback.
         :param normalization_callback function to be used for value
         normalization. Takes original value and part type schema. Should return
         normalized value. See docs/connector-development/cdk-python/schemas.md
         for details.
-        :return Same callback, this is useful for using registerCustomTransform function as decorator.
+        :return Same callbeck, this is usefull for using registerCustomTransform function as decorator.
         """
         if TransformConfig.CustomSchemaNormalization not in self._config:
             raise Exception(
@@ -141,11 +141,7 @@ class TypeTransformer:
             return original_item
         return original_item
 
-    def __get_normalizer(
-        self,
-        schema_key: str,
-        original_validator: Callable,  # type: ignore[type-arg]
-    ) -> Callable[[Any, Any, Any, dict[str, Any]], Generator[Any, Any, None]]:
+    def __get_normalizer(self, schema_key: str, original_validator: Callable):
         """
         Traverse through object fields using native jsonschema validator and apply normalization function.
         :param schema_key related json schema key that currently being validated/normalized.
@@ -153,11 +149,8 @@ class TypeTransformer:
         """
 
         def normalizator(
-            validator_instance: Validator,
-            property_value: Any,
-            instance: Any,
-            schema: Dict[str, Any],
-        ) -> Generator[Any, Any, None]:
+            validator_instance: Callable, property_value: Any, instance: Any, schema: Dict[str, Any]
+        ):
             """
             Jsonschema validator callable it uses for validating instance. We
             override default Draft7Validator to perform value transformation
@@ -170,13 +163,10 @@ class TypeTransformer:
             :
             """
 
-            def resolve(subschema: dict[str, Any]) -> dict[str, Any]:
+            def resolve(subschema):
                 if "$ref" in subschema:
-                    _, resolved = cast(
-                        RefResolver,
-                        validator_instance.resolver,
-                    ).resolve(subschema["$ref"])
-                    return cast(dict[str, Any], resolved)
+                    _, resolved = validator_instance.resolver.resolve(subschema["$ref"])
+                    return resolved
                 return subschema
 
             # Transform object and array values before running json schema type checking for each element.
@@ -195,20 +185,11 @@ class TypeTransformer:
                     instance[index] = self.__normalize(item, subschema)
 
             # Running native jsonschema traverse algorithm after field normalization is done.
-            yield from original_validator(
-                validator_instance,
-                property_value,
-                instance,
-                schema,
-            )
+            yield from original_validator(validator_instance, property_value, instance, schema)
 
         return normalizator
 
-    def transform(
-        self,
-        record: Dict[str, Any],
-        schema: Mapping[str, Any],
-    ) -> None:
+    def transform(self, record: Dict[str, Any], schema: Mapping[str, Any]):
         """
         Normalize and validate according to config.
         :param record: record instance for normalization/transformation. All modification are done by modifying existent object.
@@ -220,7 +201,7 @@ class TypeTransformer:
         for e in normalizer.iter_errors(record):
             """
             just calling normalizer.validate() would throw an exception on
-            first validation occurrences and stop processing rest of schema.
+            first validation occurences and stop processing rest of schema.
             """
             logger.warning(self.get_error_message(e))
 

airbyte_cdk/test/entrypoint_wrapper.py

@@ -23,7 +23,7 @@ from io import StringIO
 from pathlib import Path
 from typing import Any, List, Mapping, Optional, Union
 
-import orjson
+from orjson import orjson
 from pydantic import ValidationError as V2ValidationError
 from serpyco_rs import SchemaValidationError
 
@@ -63,7 +63,7 @@ class EntrypointOutput:
     @staticmethod
     def _parse_message(message: str) -> AirbyteMessage:
         try:
-            return AirbyteMessageSerializer.load(orjson.loads(message))
+            return AirbyteMessageSerializer.load(orjson.loads(message))  # type: ignore[no-any-return] # Serializer.load() always returns AirbyteMessage
         except (orjson.JSONDecodeError, SchemaValidationError):
             # The platform assumes that logs that are not of AirbyteMessage format are log messages
             return AirbyteMessage(
@@ -129,19 +129,14 @@ class EntrypointOutput:
         return [
             message
             for message in self._get_message_by_types([Type.TRACE])
-            if message.trace.type == trace_type  # type: ignore[union-attr] # trace has `type`
-        ]
+            if message.trace.type == trace_type
+        ]  # type: ignore[union-attr] # trace has `type`
 
     def is_in_logs(self, pattern: str) -> bool:
         """Check if any log message case-insensitive matches the pattern."""
         return any(
-            re.search(
-                pattern,
-                entry.log.message,  # type: ignore[union-attr] # log has `message`
-                flags=re.IGNORECASE,
-            )
-            for entry in self.logs
-        )
+            re.search(pattern, entry.log.message, flags=re.IGNORECASE) for entry in self.logs
+        )  # type: ignore[union-attr] # log has `message`
 
     def is_not_in_logs(self, pattern: str) -> bool:
         """Check if no log message matches the case-insensitive pattern."""