airbyte-cdk 6.8.1rc9__py3-none-any.whl → 6.8.2.dev1__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 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)}")

airbyte_cdk/sources/streams/http/http_client.py

@@ -54,7 +54,6 @@ 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):
@@ -95,7 +94,6 @@ class HttpClient:
     ):
         self._name = name
         self._api_budget: APIBudget = api_budget or APIBudget(policies=[])
-        self._logger = logger
         if session:
             self._session = session
         else:
@@ -109,6 +107,7 @@ class HttpClient:
             )
         if isinstance(authenticator, AuthBase):
             self._session.auth = authenticator
+        self._logger = logger
         self._error_handler = error_handler or HttpStatusErrorHandler(self._logger)
         if backoff_strategy is not None:
             if isinstance(backoff_strategy, list):
@@ -142,12 +141,10 @@ class HttpClient:
             if cache_dir:
                 sqlite_path = str(Path(cache_dir) / self.cache_filename)
             else:
-                self._logger.info("Using memory for cache")  # TODO: remove
                 sqlite_path = "file::memory:?cache=shared"
-            backend = SkipFailureSQLiteCache(self._name, sqlite_path)  # TODO maybe add a busy timeout
             return CachedLimiterSession(
-                sqlite_path, backend=backend, api_budget=self._api_budget, match_headers=True
-            )  # type: ignore # there are no typeshed stubs for requests_cache
+                sqlite_path, backend="sqlite", api_budget=self._api_budget, match_headers=True
+            )
         else:
             return LimiterSession(api_budget=self._api_budget)
 
@@ -327,7 +324,7 @@ class HttpClient:
             formatter = log_formatter
             self._message_repository.log_message(
                 Level.DEBUG,
-                lambda: formatter(response),  # type: ignore # log_formatter is always cast to a callable
+                lambda: formatter(response),
             )
 
         self._handle_error_resolution(
@@ -520,44 +517,3 @@ class HttpClient:
         )
 
         return request, response
-
-
-class SkipFailureSQLiteDict(requests_cache.backends.sqlite.SQLiteDict):
-    def __getitem__(self, key):  # type: ignore  # lib is not typed
-        try:
-            return super().__getitem__(key)  # type: ignore  # lib is not typed
-        except Exception as exception:
-            if not isinstance(exception, KeyError):
-                logger.warning(f"Error while retrieving item from cache: {exception}")
-            else:
-                raise exception
-
-    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(f"Error while saving item to cache: {exception}")
-
-
-class SkipFailureSQLiteCache(requests_cache.backends.sqlite.SQLiteCache):
-    def __init__(  # type: ignore  # ignoring as lib is not typed
-        self,
-        table_name="response",
-        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=table_name, fast_save=True, wal=True, **skwargs
-        )
-        self.redirects: requests_cache.backends.sqlite.SQLiteDict = SkipFailureSQLiteDict(
-            db_path,
-            table_name=f"redirects_{table_name}",
-            fast_save=True,
-            wal=True,
-            lock=self.responses._lock,
-            serializer=None,
-            **kwargs,
-        )

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

@@ -5,13 +5,14 @@
 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):
+    def __call__(self, request: requests.PreparedRequest) -> Any:
         """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,
-        token_expiry_date: pendulum.DateTime = None,
-        token_expiry_date_format: str = None,
+        scopes: List[str] | None = None,
+        token_expiry_date: pendulum.DateTime | None = None,
+        token_expiry_date_format: str | None = None,
         access_token_name: str = "access_token",
         expires_in_name: str = "expires_in",
-        refresh_request_body: Mapping[str, Any] = None,
+        refresh_request_body: Mapping[str, Any] | None = 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)
+        self._token_expiry_date = token_expiry_date or pendulum.now().subtract(days=1)  # type: ignore [no-untyped-call]
         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) -> [str]:
-        return self._scopes
+    def get_scopes(self) -> list[str]:
+        return self._scopes  # type: ignore [return-value]
 
     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
+        return self._refresh_request_body  # type: ignore [return-value]
 
     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]):
+    def set_token_expiry_date(self, value: Union[str, int]) -> None:
         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
+        return self._access_token  # type: ignore [return-value]
 
     @access_token.setter
-    def access_token(self, value: str):
-        self._access_token = value
+    def access_token(self, value: str) -> None:
+        self._access_token = value  # type: ignore [assignment]  # Incorrect type for assignment
 
 
 class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
@@ -124,11 +124,11 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
         self,
         connector_config: Mapping[str, Any],
         token_refresh_endpoint: str,
-        scopes: List[str] = None,
+        scopes: List[str] | None = 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,
+        refresh_request_body: Mapping[str, Any] | None = None,
         grant_type: str = "refresh_token",
         client_id: Optional[str] = None,
         client_secret: Optional[str] = None,
@@ -162,14 +162,17 @@ 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
+            client_id  # type: ignore [assignment]  # Incorrect type for assignment
             if client_id is not None
-            else dpath.get(connector_config, ("credentials", "client_id"))
+            else dpath.get(connector_config, ("credentials", "client_id"))  # type: ignore [arg-type]
         )
         self._client_secret = (
-            client_secret
+            client_secret  # type: ignore [assignment]  # Incorrect type for assignment
             if client_secret is not None
-            else dpath.get(connector_config, ("credentials", "client_secret"))
+            else dpath.get(
+                connector_config,  # type: ignore [arg-type]
+                ("credentials", "client_secret"),
+            )
         )
         self._access_token_config_path = access_token_config_path
         self._refresh_token_config_path = refresh_token_config_path
@@ -207,27 +210,50 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
 
     @property
     def access_token(self) -> str:
-        return dpath.get(self._connector_config, self._access_token_config_path, default="")
+        return dpath.get(  # type: ignore [return-value]
+            self._connector_config,  # type: ignore [arg-type]
+            self._access_token_config_path,
+            default="",
+        )
 
     @access_token.setter
-    def access_token(self, new_access_token: str):
-        dpath.new(self._connector_config, self._access_token_config_path, new_access_token)
+    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 get_refresh_token(self) -> str:
-        return dpath.get(self._connector_config, self._refresh_token_config_path, default="")
+        return dpath.get(  # type: ignore [return-value]
+            self._connector_config,  # type: ignore [arg-type]
+            self._refresh_token_config_path,
+            default="",
+        )
 
-    def set_refresh_token(self, new_refresh_token: str):
-        dpath.new(self._connector_config, self._refresh_token_config_path, new_refresh_token)
+    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 get_token_expiry_date(self) -> pendulum.DateTime:
         expiry_date = dpath.get(
-            self._connector_config, self._token_expiry_date_config_path, default=""
+            self._connector_config,  # type: ignore [arg-type]
+            self._token_expiry_date_config_path,
+            default="",
         )
-        return pendulum.now().subtract(days=1) if expiry_date == "" else pendulum.parse(expiry_date)
+        return pendulum.now().subtract(days=1) if expiry_date == "" else pendulum.parse(expiry_date)  # type: ignore [arg-type, return-value, no-untyped-call]
 
-    def set_token_expiry_date(self, new_token_expiry_date):
+    def set_token_expiry_date(  # type: ignore[override]
+        self,
+        new_token_expiry_date: pendulum.DateTime,
+    ) -> None:
         dpath.new(
-            self._connector_config, self._token_expiry_date_config_path, str(new_token_expiry_date)
+            self._connector_config,  # type: ignore [arg-type]
+            self._token_expiry_date_config_path,
+            str(new_token_expiry_date),
         )
 
     def token_has_expired(self) -> bool:
@@ -236,7 +262,8 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
 
     @staticmethod
     def get_new_token_expiry_date(
-        access_token_expires_in: str, token_expiry_date_format: str = None
+        access_token_expires_in: str,
+        token_expiry_date_format: str | None = None,
     ) -> pendulum.DateTime:
         if token_expiry_date_format:
             return pendulum.from_format(access_token_expires_in, token_expiry_date_format)
@@ -253,7 +280,7 @@ class SingleUseRefreshTokenOauth2Authenticator(Oauth2Authenticator):
             new_access_token, access_token_expires_in, new_refresh_token = (
                 self.refresh_access_token()
             )
-            new_token_expiry_date = self.get_new_token_expiry_date(
+            new_token_expiry_date: pendulum.DateTime = self.get_new_token_expiry_date(
                 access_token_expires_in, self._token_expiry_date_format
             )
             self.access_token = new_access_token
@@ -264,13 +291,15 @@ 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)
+                    create_connector_config_control_message(self._connector_config)  # type: ignore [arg-type]
                 )
             else:
-                emit_configuration_as_airbyte_control_message(self._connector_config)
+                emit_configuration_as_airbyte_control_message(self._connector_config)  # type: ignore [arg-type]
         return self.access_token
 
-    def refresh_access_token(self) -> Tuple[str, str, str]:
+    def refresh_access_token(  # type: ignore[override]  # Signature doesn't match base class
+        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)  # type: ignore
+            transformer.transform(data, schema)
             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)  # type: ignore[no-any-return]
+        return super().dict(*args, **kwargs)
 
     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, Mapping, Optional
+from typing import Any, Callable, Dict, Generator, Mapping, Optional, cast
 
-from jsonschema import Draft7Validator, ValidationError, validators
+from jsonschema import Draft7Validator, RefResolver, ValidationError, Validator, validators
 
 json_to_python_simple = {
     "string": str,
@@ -30,7 +30,7 @@ class TransformConfig(Flag):
         ```
     """
 
-    # No action taken, default behaviour. Cannot be combined with any other options.
+    # No action taken, default behavior. 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:
+        self, normalization_callback: Callable[[Any, dict[str, Any]], Any]
+    ) -> Callable[[Any, dict[str, Any]], Any]:
         """
         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 callbeck, this is usefull for using registerCustomTransform function as decorator.
+        :return Same callback, this is useful for using registerCustomTransform function as decorator.
         """
         if TransformConfig.CustomSchemaNormalization not in self._config:
             raise Exception(
@@ -141,7 +141,11 @@ class TypeTransformer:
             return original_item
         return original_item
 
-    def __get_normalizer(self, schema_key: str, original_validator: Callable):
+    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]]:
         """
         Traverse through object fields using native jsonschema validator and apply normalization function.
         :param schema_key related json schema key that currently being validated/normalized.
@@ -149,8 +153,11 @@ class TypeTransformer:
         """
 
         def normalizator(
-            validator_instance: Callable, property_value: Any, instance: Any, schema: Dict[str, Any]
-        ):
+            validator_instance: Validator,
+            property_value: Any,
+            instance: Any,
+            schema: Dict[str, Any],
+        ) -> Generator[Any, Any, None]:
             """
             Jsonschema validator callable it uses for validating instance. We
             override default Draft7Validator to perform value transformation
@@ -163,10 +170,13 @@ class TypeTransformer:
             :
             """
 
-            def resolve(subschema):
+            def resolve(subschema: dict[str, Any]) -> dict[str, Any]:
                 if "$ref" in subschema:
-                    _, resolved = validator_instance.resolver.resolve(subschema["$ref"])
-                    return resolved
+                    _, resolved = cast(
+                        RefResolver,
+                        validator_instance.resolver,
+                    ).resolve(subschema["$ref"])
+                    return cast(dict[str, Any], resolved)
                 return subschema
 
             # Transform object and array values before running json schema type checking for each element.
@@ -185,11 +195,20 @@ 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]):
+    def transform(
+        self,
+        record: Dict[str, Any],
+        schema: Mapping[str, Any],
+    ) -> None:
         """
         Normalize and validate according to config.
         :param record: record instance for normalization/transformation. All modification are done by modifying existent object.
@@ -201,7 +220,7 @@ class TypeTransformer:
         for e in normalizer.iter_errors(record):
             """
             just calling normalizer.validate() would throw an exception on
-            first validation occurences and stop processing rest of schema.
+            first validation occurrences and stop processing rest of schema.
             """
             logger.warning(self.get_error_message(e))