cognite-extractor-utils 7.5.4__py3-none-any.whl → 7.5.6__py3-none-any.whl

cognite/extractorutils/__init__.py

@@ -16,5 +16,7 @@
 Cognite extractor utils is a Python package that simplifies the development of new extractors.
 """
 
-__version__ = "7.5.4"
+__version__ = "7.5.6"
 from .base import Extractor
+
+__all__ = ["Extractor"]

cognite/extractorutils/_inner_util.py

@@ -18,15 +18,26 @@ A module containing utilities meant for use inside the extractor-utils package
 
 import json
 from decimal import Decimal
-from typing import Any, Dict, Union
+from typing import Any
 
 
 def _resolve_log_level(level: str) -> int:
     return {"NOTSET": 0, "DEBUG": 10, "INFO": 20, "WARNING": 30, "ERROR": 40, "CRITICAL": 50}[level.upper()]
 
 
+def resolve_log_level_for_httpx(level: str) -> str:
+    return {
+        None: "WARNING",
+        "INFO": "WARNING",
+        "WARNING": "WARNING",
+        "ERROR": "ERROR",
+        "CRITICAL": "CRITICAL",
+        "DEBUG": "DEBUG",
+    }.get(level, "WARNING")
+
+
 class _DecimalEncoder(json.JSONEncoder):
-    def default(self, obj: Any) -> Dict[str, str]:
+    def default(self, obj: Any) -> dict[str, str]:
         if isinstance(obj, Decimal):
             return {"type": "decimal_encoded", "value": str(obj)}
         return super(_DecimalEncoder, self).default(obj)
@@ -36,7 +47,7 @@ class _DecimalDecoder(json.JSONDecoder):
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         json.JSONDecoder.__init__(self, *args, object_hook=self.object_hook, **kwargs)
 
-    def object_hook(self, obj_dict: Dict[str, str]) -> Union[Dict[str, str], Decimal]:
+    def object_hook(self, obj_dict: dict[str, str]) -> dict[str, str] | Decimal:
         if obj_dict.get("type") == "decimal_encoded":
             return Decimal(obj_dict["value"])
         return obj_dict

cognite/extractorutils/base.py

@@ -19,7 +19,7 @@ from dataclasses import is_dataclass
 from enum import Enum
 from threading import Thread
 from types import TracebackType
-from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar
+from typing import Any, Callable, Generic, Type, TypeVar
 
 from dotenv import find_dotenv, load_dotenv
 
@@ -40,6 +40,7 @@ class ReloadConfigAction(Enum):
 
 
 CustomConfigClass = TypeVar("CustomConfigClass", bound=BaseConfig)
+RunHandle = Callable[[CogniteClient, AbstractStateStore, CustomConfigClass, CancellationToken], None]
 
 
 class Extractor(Generic[CustomConfigClass]):
@@ -68,27 +69,25 @@ class Extractor(Generic[CustomConfigClass]):
         heartbeat_waiting_time: Time interval between each heartbeat to the extraction pipeline in seconds.
     """
 
-    _config_singleton: Optional[CustomConfigClass] = None
-    _statestore_singleton: Optional[AbstractStateStore] = None
+    _config_singleton: CustomConfigClass | None = None
+    _statestore_singleton: AbstractStateStore | None = None
 
     def __init__(
         self,
         *,
         name: str,
         description: str,
-        version: Optional[str] = None,
-        run_handle: Optional[
-            Callable[[CogniteClient, AbstractStateStore, CustomConfigClass, CancellationToken], None]
-        ] = None,
+        version: str | None = None,
+        run_handle: RunHandle | None = None,
         config_class: Type[CustomConfigClass],
-        metrics: Optional[BaseMetrics] = None,
+        metrics: BaseMetrics | None = None,
         use_default_state_store: bool = True,
-        cancellation_token: Optional[CancellationToken] = None,
-        config_file_path: Optional[str] = None,
+        cancellation_token: CancellationToken | None = None,
+        config_file_path: str | None = None,
         continuous_extractor: bool = False,
         heartbeat_waiting_time: int = 600,
         handle_interrupts: bool = True,
-        reload_config_interval: Optional[int] = 300,
+        reload_config_interval: int | None = 300,
         reload_config_action: ReloadConfigAction = ReloadConfigAction.DO_NOTHING,
     ):
         self.name = name
@@ -111,7 +110,7 @@ class Extractor(Generic[CustomConfigClass]):
         self.cognite_client: CogniteClient
         self.state_store: AbstractStateStore
         self.config: CustomConfigClass
-        self.extraction_pipeline: Optional[ExtractionPipeline]
+        self.extraction_pipeline: ExtractionPipeline | None
         self.logger: logging.Logger
 
         self.should_be_restarted = False
@@ -121,7 +120,7 @@ class Extractor(Generic[CustomConfigClass]):
         else:
             self.metrics = BaseMetrics(extractor_name=name, extractor_version=self.version)
 
-    def _initial_load_config(self, override_path: Optional[str] = None) -> None:
+    def _initial_load_config(self, override_path: str | None = None) -> None:
         """
         Load a configuration file, either from the specified path, or by a path specified by the user in a command line
         arg. Will quit further execution of no path is given.
@@ -177,7 +176,7 @@ class Extractor(Generic[CustomConfigClass]):
         Either way, the state_store attribute is guaranteed to be set after calling this method.
         """
 
-        def recursive_find_state_store(d: Dict[str, Any]) -> Optional[StateStoreConfig]:
+        def recursive_find_state_store(d: dict[str, Any]) -> StateStoreConfig | None:
             for k in d:
                 if is_dataclass(d[k]):
                     res = recursive_find_state_store(d[k].__dict__)
@@ -323,7 +322,7 @@ class Extractor(Generic[CustomConfigClass]):
         return self
 
     def __exit__(
-        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+        self, exc_type: Type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> bool:
         """
         Shuts down the extractor. Makes sure states are preserved, that all uploads of data and metrics are done, etc.

cognite/extractorutils/configtools/__init__.py

@@ -107,3 +107,28 @@ from .elements import (
     TimeIntervalConfig,
 )
 from .loaders import ConfigResolver, KeyVaultAuthenticationMethod, KeyVaultLoader, load_yaml, load_yaml_dict
+
+__all__ = [
+    "AuthenticatorConfig",
+    "BaseConfig",
+    "CastableInt",
+    "CertificateConfig",
+    "CogniteConfig",
+    "ConfigType",
+    "ConnectionConfig",
+    "EitherIdConfig",
+    "FileSizeConfig",
+    "LocalStateStoreConfig",
+    "LoggingConfig",
+    "MetricsConfig",
+    "PortNumber",
+    "RawDestinationConfig",
+    "RawStateStoreConfig",
+    "StateStoreConfig",
+    "TimeIntervalConfig",
+    "ConfigResolver",
+    "KeyVaultAuthenticationMethod",
+    "KeyVaultLoader",
+    "load_yaml",
+    "load_yaml_dict",
+]

cognite/extractorutils/configtools/_util.py

@@ -14,7 +14,7 @@
 import base64
 import re
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable
 
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives import serialization as serialization
@@ -24,7 +24,7 @@ from cryptography.x509 import load_pem_x509_certificate
 from cognite.extractorutils.exceptions import InvalidConfigError
 
 
-def _to_snake_case(dictionary: Dict[str, Any], case_style: str) -> Dict[str, Any]:
+def _to_snake_case(dictionary: dict[str, Any], case_style: str) -> dict[str, Any]:
     """
     Ensure that all keys in the dictionary follows the snake casing convention (recursively, so any sub-dictionaries are
     changed too).
@@ -37,11 +37,11 @@ def _to_snake_case(dictionary: Dict[str, Any], case_style: str) -> Dict[str, Any
         An updated dictionary with keys in the given convention.
     """
 
-    def fix_list(list_: List[Any], key_translator: Callable[[str], str]) -> List[Any]:
+    def fix_list(list_: list[Any], key_translator: Callable[[str], str]) -> list[Any]:
         if list_ is None:
             return []
 
-        new_list: List[Any] = [None] * len(list_)
+        new_list: list[Any] = [None] * len(list_)
         for i, element in enumerate(list_):
             if isinstance(element, dict):
                 new_list[i] = fix_dict(element, key_translator)
@@ -51,11 +51,11 @@ def _to_snake_case(dictionary: Dict[str, Any], case_style: str) -> Dict[str, Any
                 new_list[i] = element
         return new_list
 
-    def fix_dict(dict_: Dict[str, Any], key_translator: Callable[[str], str]) -> Dict[str, Any]:
+    def fix_dict(dict_: dict[str, Any], key_translator: Callable[[str], str]) -> dict[str, Any]:
         if dict_ is None:
             return {}
 
-        new_dict: Dict[str, Any] = {}
+        new_dict: dict[str, Any] = {}
         for key in dict_:
             if isinstance(dict_[key], dict):
                 new_dict[key_translator(key)] = fix_dict(dict_[key], key_translator)
@@ -81,9 +81,7 @@ def _to_snake_case(dictionary: Dict[str, Any], case_style: str) -> Dict[str, Any
         raise ValueError(f"Invalid case style: {case_style}")
 
 
-def _load_certificate_data(
-    cert_path: str | Path, password: Optional[str]
-) -> Union[Tuple[str, str], Tuple[bytes, bytes]]:
+def _load_certificate_data(cert_path: str | Path, password: str | None) -> tuple[str, str] | tuple[bytes, bytes]:
     path = Path(cert_path) if isinstance(cert_path, str) else cert_path
     cert_data = Path(path).read_bytes()
 

cognite/extractorutils/configtools/elements.py

@@ -19,7 +19,7 @@ from datetime import timedelta
 from enum import Enum
 from logging.handlers import TimedRotatingFileHandler
 from time import sleep
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 from urllib.parse import urljoin, urlparse
 
 import yaml
@@ -32,6 +32,7 @@ from cognite.client.credentials import (
     OAuthClientCredentials,
 )
 from cognite.client.data_classes import Asset, DataSet, ExtractionPipeline
+from cognite.extractorutils._inner_util import resolve_log_level_for_httpx
 from cognite.extractorutils.configtools._util import _load_certificate_data
 from cognite.extractorutils.exceptions import InvalidConfigError
 from cognite.extractorutils.metrics import (
@@ -58,8 +59,8 @@ class CertificateConfig:
     """
 
     path: str
-    password: Optional[str]
-    authority_url: Optional[str] = None
+    password: str | None
+    authority_url: str | None = None
 
 
 @dataclass
@@ -69,15 +70,15 @@ class AuthenticatorConfig:
     """
 
     client_id: str
-    scopes: List[str]
-    secret: Optional[str] = None
-    tenant: Optional[str] = None
-    token_url: Optional[str] = None
-    resource: Optional[str] = None
-    audience: Optional[str] = None
+    scopes: list[str]
+    secret: str | None = None
+    tenant: str | None = None
+    token_url: str | None = None
+    resource: str | None = None
+    audience: str | None = None
     authority: str = "https://login.microsoftonline.com/"
     min_ttl: float = 30  # minimum time to live: refresh token ahead of expiration
-    certificate: Optional[CertificateConfig] = None
+    certificate: CertificateConfig | None = None
 
 
 @dataclass
@@ -87,13 +88,13 @@ class ConnectionConfig:
     """
 
     disable_gzip: bool = False
-    status_forcelist: List[int] = field(default_factory=lambda: [429, 502, 503, 504])
+    status_forcelist: list[int] = field(default_factory=lambda: [429, 502, 503, 504])
     max_retries: int = 10
     max_retries_connect: int = 3
     max_retry_backoff: int = 30
     max_connection_pool_size: int = 50
     disable_ssl: bool = False
-    proxies: Dict[str, str] = field(default_factory=dict)
+    proxies: dict[str, str] = field(default_factory=dict)
 
 
 @dataclass
@@ -103,8 +104,8 @@ class EitherIdConfig:
     An EitherId can only hold one ID type, not both.
     """
 
-    id: Optional[int]
-    external_id: Optional[str]
+    id: int | None
+    external_id: str | None
 
     @property
     def either_id(self) -> EitherId:
@@ -128,7 +129,7 @@ class TimeIntervalConfig(yaml.YAMLObject):
         return hash(self._interval)
 
     @classmethod
-    def _parse_expression(cls, expression: str) -> Tuple[int, str]:
+    def _parse_expression(cls, expression: str) -> tuple[int, str]:
         # First, try to parse pure number and assume seconds (for backwards compatibility)
         try:
             return int(expression), f"{expression}s"
@@ -188,7 +189,7 @@ class FileSizeConfig(yaml.YAMLObject):
         self._bytes, self._expression = FileSizeConfig._parse_expression(expression)
 
     @classmethod
-    def _parse_expression(cls, expression: str) -> Tuple[int, str]:
+    def _parse_expression(cls, expression: str) -> tuple[int, str]:
         # First, try to parse pure number and assume bytes
         try:
             return int(expression), f"{expression}s"
@@ -284,20 +285,20 @@ class CogniteConfig:
 
     project: str
     idp_authentication: AuthenticatorConfig
-    data_set: Optional[EitherIdConfig] = None
-    data_set_id: Optional[int] = None
-    data_set_external_id: Optional[str] = None
-    extraction_pipeline: Optional[EitherIdConfig] = None
+    data_set: EitherIdConfig | None = None
+    data_set_id: int | None = None
+    data_set_external_id: str | None = None
+    extraction_pipeline: EitherIdConfig | None = None
     timeout: TimeIntervalConfig = TimeIntervalConfig("30s")
     connection: ConnectionConfig = field(default_factory=ConnectionConfig)
-    security_categories: Optional[List[int]] = None
+    security_categories: list[int] | None = None
     external_id_prefix: str = ""
     host: str = "https://api.cognitedata.com"
 
     def get_cognite_client(
         self,
         client_name: str,
-        token_custom_args: Optional[Dict[str, str]] = None,
+        token_custom_args: dict[str, str] | None = None,
         use_experimental_sdk: bool = False,
     ) -> CogniteClient:
         from cognite.client.config import global_config
@@ -344,7 +345,7 @@ class CogniteConfig:
             )
 
         elif self.idp_authentication.secret:
-            kwargs: Dict[str, Any] = {}
+            kwargs: dict[str, Any] = {}
             if self.idp_authentication.token_url:
                 _validate_https_url(self.idp_authentication.token_url, "Token URL")
                 kwargs["token_url"] = self.idp_authentication.token_url
@@ -387,7 +388,7 @@ class CogniteConfig:
 
         return CogniteClient(client_config)
 
-    def get_data_set(self, cdf_client: CogniteClient) -> Optional[DataSet]:
+    def get_data_set(self, cdf_client: CogniteClient) -> DataSet | None:
         if self.data_set_external_id:
             logging.getLogger(__name__).warning(
                 "Using data-set-external-id is deprecated, please use data-set/external-id instead"
@@ -406,7 +407,7 @@ class CogniteConfig:
             external_id=self.data_set.either_id.external_id,
         )
 
-    def get_extraction_pipeline(self, cdf_client: CogniteClient) -> Optional[ExtractionPipeline]:
+    def get_extraction_pipeline(self, cdf_client: CogniteClient) -> ExtractionPipeline | None:
         if not self.extraction_pipeline:
             return None
 
@@ -438,12 +439,12 @@ class LoggingConfig:
     Logging settings, such as log levels and path to log file
     """
 
-    console: Optional[_ConsoleLoggingConfig]
-    file: Optional[_FileLoggingConfig]
+    console: _ConsoleLoggingConfig | None
+    file: _FileLoggingConfig | None
     # enables metrics on the number of log messages recorded (per logger and level)
     # In order to collect/see result MetricsConfig should be set as well, so metrics are propagated to
     # Prometheus and/or Cognite
-    metrics: Optional[bool] = False
+    metrics: bool | None = False
 
     def setup_logging(self, suppress_console: bool = False) -> None:
         """
@@ -491,15 +492,23 @@ class LoggingConfig:
             if root.getEffectiveLevel() > file_handler.level:
                 root.setLevel(file_handler.level)
 
+            log_level = logging.getLevelName(root.getEffectiveLevel())
+            httpx_log_level = resolve_log_level_for_httpx(log_level)
+            httpx_logger = logging.getLogger("httpx")
+            httpx_logger.setLevel(httpx_log_level)
+
+            http_core_logger = logging.getLogger("httpcore")
+            http_core_logger.setLevel(httpx_log_level)
+
 
 @dataclass
 class _PushGatewayConfig:
     host: str
     job_name: str
-    username: Optional[str]
-    password: Optional[str]
+    username: str | None
+    password: str | None
 
-    clear_after: Optional[TimeIntervalConfig]
+    clear_after: TimeIntervalConfig | None
     push_interval: TimeIntervalConfig = TimeIntervalConfig("30s")
 
 
@@ -511,9 +520,9 @@ class _PromServerConfig:
 @dataclass
 class _CogniteMetricsConfig:
     external_id_prefix: str
-    asset_name: Optional[str]
-    asset_external_id: Optional[str]
-    data_set: Optional[EitherIdConfig] = None
+    asset_name: str | None
+    asset_external_id: str | None
+    data_set: EitherIdConfig | None = None
 
     push_interval: TimeIntervalConfig = TimeIntervalConfig("30s")
 
@@ -525,13 +534,13 @@ class MetricsConfig:
     Series.
     """
 
-    push_gateways: Optional[List[_PushGatewayConfig]]
-    cognite: Optional[_CogniteMetricsConfig]
-    server: Optional[_PromServerConfig]
+    push_gateways: list[_PushGatewayConfig] | None
+    cognite: _CogniteMetricsConfig | None
+    server: _PromServerConfig | None
 
-    def start_pushers(self, cdf_client: CogniteClient, cancellation_token: Optional[CancellationToken] = None) -> None:
-        self._pushers: List[AbstractMetricsPusher] = []
-        self._clear_on_stop: Dict[PrometheusPusher, int] = {}
+    def start_pushers(self, cdf_client: CogniteClient, cancellation_token: CancellationToken | None = None) -> None:
+        self._pushers: list[AbstractMetricsPusher] = []
+        self._clear_on_stop: dict[PrometheusPusher, int] = {}
 
         push_gateways = self.push_gateways or []
 
@@ -599,9 +608,9 @@ class ConfigType(Enum):
 
 @dataclass
 class _BaseConfig:
-    _file_hash: Optional[str] = field(init=False, repr=False, default=None)
+    _file_hash: str | None = field(init=False, repr=False, default=None)
 
-    type: Optional[ConfigType]
+    type: ConfigType | None
     cognite: CogniteConfig
 
 
@@ -611,7 +620,7 @@ class BaseConfig(_BaseConfig):
     Basis for an extractor config, containing config version, ``CogniteConfig`` and ``LoggingConfig``
     """
 
-    version: Optional[Union[str, int]]
+    version: str | int | None
     logger: LoggingConfig
 
 
@@ -650,14 +659,14 @@ class StateStoreConfig:
     Configuration of the State Store, containing ``LocalStateStoreConfig`` or ``RawStateStoreConfig``
     """
 
-    raw: Optional[RawStateStoreConfig] = None
-    local: Optional[LocalStateStoreConfig] = None
+    raw: RawStateStoreConfig | None = None
+    local: LocalStateStoreConfig | None = None
 
     def create_state_store(
         self,
-        cdf_client: Optional[CogniteClient] = None,
+        cdf_client: CogniteClient | None = None,
         default_to_local: bool = True,
-        cancellation_token: Optional[CancellationToken] = None,
+        cancellation_token: CancellationToken | None = None,
     ) -> AbstractStateStore:
         """
         Create a state store object based on the config.
@@ -719,8 +728,8 @@ class IgnorePattern:
     """
 
     pattern: str
-    options: Optional[list[RegExpFlag]] = None
-    flags: Optional[list[RegExpFlag]] = None
+    options: list[RegExpFlag] | None = None
+    flags: list[RegExpFlag] | None = None
 
     def compile(self) -> re.Pattern[str]:
         """

cognite/extractorutils/configtools/loaders.py

@@ -22,7 +22,7 @@ import sys
 from enum import Enum
 from hashlib import sha256
 from pathlib import Path
-from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, TextIO, Type, TypeVar, Union, cast
+from typing import Any, Callable, Generic, Iterable, TextIO, Type, TypeVar, cast
 
 import dacite
 import yaml
@@ -61,11 +61,11 @@ class KeyVaultLoader:
     Class responsible for configuring keyvault for clients using Azure
     """
 
-    def __init__(self, config: Optional[dict]):
+    def __init__(self, config: dict | None):
         self.config = config
 
-        self.credentials: Optional[TokenCredential] = None
-        self.client: Optional[SecretClient] = None
+        self.credentials: TokenCredential | None = None
+        self.client: SecretClient | None = None
 
     def _init_client(self) -> None:
         from dotenv import find_dotenv, load_dotenv
@@ -148,10 +148,10 @@ def _env_constructor(_: yaml.SafeLoader, node: yaml.Node) -> bool:
 
 
 def _load_yaml_dict_raw(
-    source: Union[TextIO, str],
+    source: TextIO | str,
     expand_envvars: bool = True,
-    keyvault_loader: Optional[KeyVaultLoader] = None,
-) -> Dict[str, Any]:
+    keyvault_loader: KeyVaultLoader | None = None,
+) -> dict[str, Any]:
     loader = _EnvLoader if expand_envvars else yaml.SafeLoader
 
     class SafeLoaderIgnoreUnknown(yaml.SafeLoader):
@@ -163,6 +163,9 @@ def _load_yaml_dict_raw(
     SafeLoaderIgnoreUnknown.add_constructor(None, SafeLoaderIgnoreUnknown.ignore_unknown)  # type: ignore
     initial_load = yaml.load(source, Loader=SafeLoaderIgnoreUnknown)  # noqa: S506
 
+    if not isinstance(initial_load, dict):
+        raise InvalidConfigError("The root node of the YAML document must be an object")
+
     if not isinstance(source, str):
         source.seek(0)
 
@@ -187,12 +190,12 @@ def _load_yaml_dict_raw(
 
 
 def _load_yaml_dict(
-    source: Union[TextIO, str],
+    source: TextIO | str,
     case_style: str = "hyphen",
     expand_envvars: bool = True,
-    dict_manipulator: Callable[[Dict[str, Any]], Dict[str, Any]] = lambda x: x,
-    keyvault_loader: Optional[KeyVaultLoader] = None,
-) -> Dict[str, Any]:
+    dict_manipulator: Callable[[dict[str, Any]], dict[str, Any]] = lambda x: x,
+    keyvault_loader: KeyVaultLoader | None = None,
+) -> dict[str, Any]:
     config_dict = _load_yaml_dict_raw(source, expand_envvars, keyvault_loader)
 
     config_dict = dict_manipulator(config_dict)
@@ -207,12 +210,12 @@ def _load_yaml_dict(
 
 
 def _load_yaml(
-    source: Union[TextIO, str],
+    source: TextIO | str,
     config_type: Type[CustomConfigClass],
     case_style: str = "hyphen",
     expand_envvars: bool = True,
-    dict_manipulator: Callable[[Dict[str, Any]], Dict[str, Any]] = lambda x: x,
-    keyvault_loader: Optional[KeyVaultLoader] = None,
+    dict_manipulator: Callable[[dict[str, Any]], dict[str, Any]] = lambda x: x,
+    keyvault_loader: KeyVaultLoader | None = None,
 ) -> CustomConfigClass:
     config_dict = _load_yaml_dict(
         source,
@@ -264,11 +267,11 @@ def _load_yaml(
 
 
 def load_yaml(
-    source: Union[TextIO, str],
+    source: TextIO | str,
     config_type: Type[CustomConfigClass],
     case_style: str = "hyphen",
     expand_envvars: bool = True,
-    keyvault_loader: Optional[KeyVaultLoader] = None,
+    keyvault_loader: KeyVaultLoader | None = None,
 ) -> CustomConfigClass:
     """
     Read a YAML file, and create a config object based on its contents.
@@ -297,11 +300,11 @@ def load_yaml(
 
 
 def load_yaml_dict(
-    source: Union[TextIO, str],
+    source: TextIO | str,
     case_style: str = "hyphen",
     expand_envvars: bool = True,
-    keyvault_loader: Optional[KeyVaultLoader] = None,
-) -> Dict[str, Any]:
+    keyvault_loader: KeyVaultLoader | None = None,
+) -> dict[str, Any]:
     """
     Read a YAML file and return a dictionary from its contents
 
@@ -323,9 +326,9 @@ def load_yaml_dict(
     )
 
 
-def compile_patterns(ignore_patterns: List[Union[str, IgnorePattern]]) -> list[re.Pattern[str]]:
+def compile_patterns(ignore_patterns: list[str | IgnorePattern]) -> list[re.Pattern[str]]:
     """
-    List of patterns to compile
+    list of patterns to compile
 
     Args:
         ignore_patterns: A list of strings or IgnorePattern to be compiled.
@@ -347,17 +350,17 @@ class ConfigResolver(Generic[CustomConfigClass]):
         self.config_path = config_path
         self.config_type = config_type
 
-        self._config: Optional[CustomConfigClass] = None
-        self._next_config: Optional[CustomConfigClass] = None
+        self._config: CustomConfigClass | None = None
+        self._next_config: CustomConfigClass | None = None
 
-        self._cognite_client: Optional[CogniteClient] = None
+        self._cognite_client: CogniteClient | None = None
 
     def _reload_file(self) -> None:
         with open(self.config_path, "r") as stream:
             self._config_text = stream.read()
 
     @property
-    def cognite_client(self) -> Optional[CogniteClient]:
+    def cognite_client(self) -> CogniteClient | None:
         if self._cognite_client is None and self._config is not None:
             self._cognite_client = self._config.cognite.get_cognite_client("config_resolver")
         return self._cognite_client
@@ -409,7 +412,7 @@ class ConfigResolver(Generic[CustomConfigClass]):
 
         return cls(args.config[0], config_type)
 
-    def _inject_cognite(self, local_part: _BaseConfig, remote_part: Dict[str, Any]) -> Dict[str, Any]:
+    def _inject_cognite(self, local_part: _BaseConfig, remote_part: dict[str, Any]) -> dict[str, Any]:
         # We can not dump 'local_part.cognite' directly because e.g. 'data_set' may be set remote only...
         remote_part.setdefault("cognite", {})
         remote_part["cognite"]["idp_authentication"] = dataclasses.asdict(local_part.cognite.idp_authentication)

cognite/extractorutils/configtools/validators.py

@@ -1,11 +1,10 @@
 import logging
 import re
-from typing import Union
 
 _logger = logging.getLogger(__name__)
 
 
-def matches_patterns(patterns: list[Union[str, re.Pattern[str]]], string: str) -> bool:
+def matches_patterns(patterns: list[str | re.Pattern[str]], string: str) -> bool:
     """
     Check string against list of RegExp patterns.
 
@@ -19,7 +18,7 @@ def matches_patterns(patterns: list[Union[str, re.Pattern[str]]], string: str) -
     return any([matches_pattern(pattern, string) for pattern in patterns])
 
 
-def matches_pattern(pattern: Union[str, re.Pattern[str]], string: str) -> bool:
+def matches_pattern(pattern: str | re.Pattern[str], string: str) -> bool:
     """
     Match pattern against a string.