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

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))
 

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
 
-from orjson import 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))  # type: ignore[no-any-return] # Serializer.load() always returns AirbyteMessage
+            return AirbyteMessageSerializer.load(orjson.loads(message))
         except (orjson.JSONDecodeError, SchemaValidationError):
             # The platform assumes that logs that are not of AirbyteMessage format are log messages
             return AirbyteMessage(
@@ -129,14 +129,19 @@ 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, flags=re.IGNORECASE) for entry in self.logs
-        )  # type: ignore[union-attr] # log has `message`
+            re.search(
+                pattern,
+                entry.log.message,  # type: ignore[union-attr] # log has `message`
+                flags=re.IGNORECASE,
+            )
+            for entry in self.logs
+        )
 
     def is_not_in_logs(self, pattern: str) -> bool:
         """Check if no log message matches the case-insensitive pattern."""

airbyte_cdk/test/mock_http/response_builder.py

@@ -183,7 +183,7 @@ class HttpResponseBuilder:
 
 def _get_unit_test_folder(execution_folder: str) -> FilePath:
     # FIXME: This function should be removed after the next CDK release to avoid breaking amazon-seller-partner test code.
-    return get_unit_test_folder(execution_folder)  # type: ignore # get_unit_test_folder is known to return a FilePath
+    return get_unit_test_folder(execution_folder)
 
 
 def find_template(resource: str, execution_folder: str) -> Dict[str, Any]:

airbyte_cdk/utils/airbyte_secrets_utils.py

@@ -47,7 +47,7 @@ def get_secrets(
     result = []
     for path in secret_paths:
         try:
-            result.append(dpath.get(config, path))
+            result.append(dpath.get(config, path))  # type: ignore  # dpath expect MutableMapping but doesn't need it
         except KeyError:
             # Since we try to get paths to all known secrets in the spec, in the case of oneOfs, some secret fields may not be present
             # In that case, a KeyError is thrown. This is expected behavior.

airbyte_cdk/utils/event_timing.py

@@ -7,7 +7,7 @@ import logging
 import time
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Optional
+from typing import Any, Generator, Literal, Optional
 
 logger = logging.getLogger("airbyte")
 
@@ -18,13 +18,13 @@ class EventTimer:
        Event nesting follows a LIFO pattern, so finish will apply to the last started event.
     """
 
-    def __init__(self, name):
+    def __init__(self, name: str) -> None:
         self.name = name
-        self.events = {}
+        self.events: dict[str, Any] = {}
         self.count = 0
-        self.stack = []
+        self.stack: list[Any] = []
 
-    def start_event(self, name):
+    def start_event(self, name: str) -> None:
         """
         Start a new event and push it to the stack.
         """
@@ -32,7 +32,7 @@ class EventTimer:
         self.count += 1
         self.stack.insert(0, self.events[name])
 
-    def finish_event(self):
+    def finish_event(self) -> None:
         """
         Finish the current event and pop it from the stack.
         """
@@ -43,7 +43,7 @@ class EventTimer:
         else:
             logger.warning(f"{self.name} finish_event called without start_event")
 
-    def report(self, order_by="name"):
+    def report(self, order_by: Literal["name", "duration"] = "name") -> str:
         """
         :param order_by: 'name' or 'duration'
         """
@@ -69,15 +69,15 @@ class Event:
             return (self.end - self.start) / 1e9
         return float("+inf")
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.name} {datetime.timedelta(seconds=self.duration)}"
 
-    def finish(self):
+    def finish(self) -> None:
         self.end = time.perf_counter_ns()
 
 
 @contextmanager
-def create_timer(name):
+def create_timer(name: str) -> Generator[EventTimer, Any, None]:
     """
     Creates a new EventTimer as a context manager to improve code readability.
     """

airbyte_cdk/utils/message_utils.py

@@ -8,15 +8,16 @@ def get_stream_descriptor(message: AirbyteMessage) -> HashableStreamDescriptor:
     match message.type:
         case Type.RECORD:
             return HashableStreamDescriptor(
-                name=message.record.stream, namespace=message.record.namespace
-            )  # type: ignore[union-attr] # record has `stream` and `namespace`
+                name=message.record.stream,  # type: ignore[union-attr] # record has `stream`
+                namespace=message.record.namespace,  # type: ignore[union-attr] # record has `namespace`
+            )
         case Type.STATE:
             if not message.state.stream or not message.state.stream.stream_descriptor:  # type: ignore[union-attr] # state has `stream`
                 raise ValueError(
                     "State message was not in per-stream state format, which is required for record counts."
                 )
             return HashableStreamDescriptor(
-                name=message.state.stream.stream_descriptor.name,
+                name=message.state.stream.stream_descriptor.name,  # type: ignore[union-attr] # state has `stream`
                 namespace=message.state.stream.stream_descriptor.namespace,  # type: ignore[union-attr] # state has `stream`
             )
         case _:

airbyte_cdk/utils/spec_schema_transformations.py

@@ -4,11 +4,12 @@
 
 import json
 import re
+from typing import Any
 
 from jsonschema import RefResolver
 
 
-def resolve_refs(schema: dict) -> dict:
+def resolve_refs(schema: dict[str, Any]) -> dict[str, Any]:
     """
     For spec schemas generated using Pydantic models, the resulting JSON schema can contain refs between object
     relationships.
@@ -20,6 +21,6 @@ def resolve_refs(schema: dict) -> dict:
         str_schema = str_schema.replace(
             ref_block, json.dumps(json_schema_ref_resolver.resolve(ref)[1])
         )
-    pyschema: dict = json.loads(str_schema)
+    pyschema: dict[str, Any] = json.loads(str_schema)
     del pyschema["definitions"]
     return pyschema

airbyte_cdk/utils/traced_exception.py

@@ -3,9 +3,9 @@
 #
 import time
 import traceback
-from typing import Optional
+from typing import Any, Optional
 
-from orjson import orjson
+import orjson
 
 from airbyte_cdk.models import (
     AirbyteConnectionStatus,
@@ -104,9 +104,9 @@ class AirbyteTracedException(Exception):
         cls,
         exc: BaseException,
         stream_descriptor: Optional[StreamDescriptor] = None,
-        *args,
-        **kwargs,
-    ) -> "AirbyteTracedException":  # type: ignore  # ignoring because of args and kwargs
+        *args: Any,
+        **kwargs: Any,
+    ) -> "AirbyteTracedException":
         """
         Helper to create an AirbyteTracedException from an existing exception
         :param exc: the exception that caused the error
@@ -131,13 +131,15 @@ class AirbyteTracedException(Exception):
         """
         error_message = self.as_airbyte_message(stream_descriptor=stream_descriptor)
         if error_message.trace.error.message:  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
-            error_message.trace.error.message = filter_secrets(error_message.trace.error.message)  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
+            error_message.trace.error.message = filter_secrets(  # type: ignore[union-attr]
+                error_message.trace.error.message,  # type: ignore[union-attr]
+            )
         if error_message.trace.error.internal_message:  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
-            error_message.trace.error.internal_message = filter_secrets(
-                error_message.trace.error.internal_message
-            )  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
+            error_message.trace.error.internal_message = filter_secrets(  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
+                error_message.trace.error.internal_message  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
+            )
         if error_message.trace.error.stack_trace:  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
-            error_message.trace.error.stack_trace = filter_secrets(
-                error_message.trace.error.stack_trace
-            )  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
+            error_message.trace.error.stack_trace = filter_secrets(  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
+                error_message.trace.error.stack_trace  # type: ignore[union-attr] # AirbyteMessage with MessageType.TRACE has AirbyteTraceMessage
+            )
         return error_message