dara-core 1.21.16__py3-none-any.whl → 1.21.18__py3-none-any.whl

dara/core/internal/registry.py

@@ -18,7 +18,7 @@ limitations under the License.
 import copy
 from collections.abc import MutableMapping
 from enum import Enum
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from dara.core.metrics import CACHE_METRICS_TRACKER, total_size
 
@@ -57,8 +57,8 @@ class Registry(Generic[T]):
     def __init__(
         self,
         name: RegistryType,
-        initial_registry: Optional[MutableMapping[str, T]] = None,
-        allow_duplicates: Optional[bool] = True,
+        initial_registry: MutableMapping[str, T] | None = None,
+        allow_duplicates: bool | None = True,
     ):
         """
         :param name: human readable name of the registry; used for metrics

dara/core/internal/registry_lookup.py

@@ -15,8 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from collections.abc import Coroutine
-from typing import Callable, Dict, Literal, TypeVar, Union
+from collections.abc import Callable, Coroutine
+from typing import Literal, TypeVar
 
 from dara.core.internal.registry import Registry, RegistryType
 from dara.core.internal.utils import async_dedupe
@@ -31,7 +31,7 @@ RegistryLookupKey = Literal[
     RegistryType.BACKEND_STORE,
     RegistryType.DOWNLOAD_CODE,
 ]
-CustomRegistryLookup = Dict[RegistryLookupKey, Callable[[str], Coroutine]]
+CustomRegistryLookup = dict[RegistryLookupKey, Callable[[str], Coroutine]]
 
 RegistryType = TypeVar('RegistryType')
 
@@ -41,7 +41,7 @@ class RegistryLookup:
     Manages registry Lookup.
     """
 
-    def __init__(self, handlers: Union[CustomRegistryLookup, None] = None):
+    def __init__(self, handlers: CustomRegistryLookup | None = None):
         if handlers is None:
             handlers = {}
         self.handlers = handlers

dara/core/internal/routing.py

@@ -20,13 +20,14 @@ import json
 import math
 import os
 import traceback
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from functools import wraps
 from importlib.metadata import version
-from typing import Annotated, Any, Callable, Dict, List, Literal, Optional, Union
+from typing import Annotated, Any, Literal
 from urllib.parse import unquote
 
 import anyio
+import backoff
 from anyio.streams.memory import MemoryObjectSendStream
 from fastapi import (
     APIRouter,
@@ -37,6 +38,7 @@ from fastapi import (
     Form,
     HTTPException,
     Path,
+    Query,
     Response,
     UploadFile,
 )
@@ -213,20 +215,6 @@ async def get_download(code: str):
         raise ValueError('Invalid or expired download code') from e
 
 
-@core_api_router.get('/components/{name}/definition', dependencies=[Depends(verify_session)])
-async def get_component_definition(name: str):
-    """
-    Attempt to refetch a component definition from the backend.
-    This is used when a component isn't immediately available in the initial registry,
-    e.g. when it was added by a py_component.
-
-    :param name: the name of component
-    """
-    registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-    component = await registry_mgr.get(component_registry, name)
-    return component.model_dump(exclude={'func'})
-
-
 class ComponentRequestBody(BaseModel):
     # Dynamic kwarg values
     values: NormalizedPayload[Mapping[str, Any]]
@@ -243,7 +231,16 @@ async def get_component(component: str, body: ComponentRequestBody):
     store: CacheStore = utils_registry.get('Store')
     task_mgr: TaskManager = utils_registry.get('TaskManager')
     registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-    comp_def = await registry_mgr.get(component_registry, component)
+
+    # Retry 5 times with a constant backoff of 1 s with 0-1 jitter
+    @backoff.on_exception(backoff.constant, ValueError, max_tries=5, jitter=backoff.full_jitter)
+    async def _get_component():
+        try:
+            return await registry_mgr.get(component_registry, component)
+        except Exception as e:
+            raise ValueError(f'Could now resolve component {component}. Was it registered in the app?') from e
+
+    comp_def = await _get_component()
 
     if isinstance(comp_def, PyComponentDef):
         static_kwargs = await registry_mgr.get(static_kwargs_registry, body.uid)
@@ -295,11 +292,11 @@ async def get_latest_derived_variable(uid: str):
 
 
 class TabularRequestBody(BaseModel):
-    filters: Optional[FilterQuery] = None
+    filters: FilterQuery | None = None
     ws_channel: str
-    dv_values: Optional[NormalizedPayload[List[Any]]] = None
+    dv_values: NormalizedPayload[list[Any]] | None = None
     """DerivedVariable values if variable is a DerivedVariable"""
-    force_key: Optional[str] = None
+    force_key: str | None = None
     """Optional force key if variable is a DerivedVariable and a recalculation is forced"""
 
 
@@ -307,10 +304,10 @@ class TabularRequestBody(BaseModel):
 async def get_tabular_variable(
     uid: str,
     body: TabularRequestBody,
-    offset: Optional[int] = None,
-    limit: Optional[int] = None,
-    order_by: Optional[str] = None,
-    index: Optional[str] = None,
+    offset: int | None = None,
+    limit: int | None = None,
+    order_by: str | None = None,
+    index: str | None = None,
 ):
     """
     Generic endpoint for getting tabular data from a variable.
@@ -359,9 +356,9 @@ async def get_server_variable_sequence(
 
 @core_api_router.post('/data/upload', dependencies=[Depends(verify_session)])
 async def upload_data(
-    data_uid: Optional[str] = None,
-    data: UploadFile = File(),
-    resolver_id: Optional[str] = Form(default=None),
+    data: Annotated[UploadFile, File()],
+    resolver_id: Annotated[str | None, Form()] = None,
+    data_uid: Annotated[str | None, Query()] = None,
 ):
     """
     Upload endpoint.
@@ -391,8 +388,8 @@ async def upload_data(
 
 
 class DerivedStateRequestBody(BaseModel):
-    values: NormalizedPayload[List[Any]]
-    force_key: Optional[str] = None
+    values: NormalizedPayload[list[Any]]
+    force_key: str | None = None
     ws_channel: str
 
 
@@ -448,7 +445,7 @@ async def read_backend_store(store_uid: str):
 
 
 @core_api_router.post('/store', dependencies=[Depends(verify_session)])
-async def sync_backend_store(ws_channel: str = Body(), values: Dict[str, Any] = Body()):
+async def sync_backend_store(ws_channel: Annotated[str, Body()], values: Annotated[dict[str, Any], Body()]):
     registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
 
     async def _write(store_uid: str, value: Any):
@@ -519,7 +516,7 @@ class ActionPayload(BaseModel):
 
 class DerivedVariablePayload(BaseModel):
     uid: str
-    values: NormalizedPayload[List[Any]]
+    values: NormalizedPayload[list[Any]]
 
 
 class PyComponentPayload(BaseModel):
@@ -529,11 +526,11 @@ class PyComponentPayload(BaseModel):
 
 
 class RouteDataRequestBody(BaseModel):
-    action_payloads: List[ActionPayload] = Field(default_factory=list)
-    derived_variable_payloads: List[DerivedVariablePayload] = Field(default_factory=list)
-    py_component_payloads: List[PyComponentPayload] = Field(default_factory=list)
+    action_payloads: list[ActionPayload] = Field(default_factory=list)
+    derived_variable_payloads: list[DerivedVariablePayload] = Field(default_factory=list)
+    py_component_payloads: list[PyComponentPayload] = Field(default_factory=list)
     ws_channel: str
-    params: Dict[str, str] = Field(default_factory=dict)
+    params: dict[str, str] = Field(default_factory=dict)
 
 
 class Result(BaseModel):
@@ -561,7 +558,7 @@ class PyComponentChunk(BaseModel):
     result: Result
 
 
-Chunk = Union[DerivedVariableChunk, PyComponentChunk]
+Chunk = DerivedVariableChunk | PyComponentChunk
 
 
 def create_loader_route(config: Configuration, app: FastAPI):
@@ -577,7 +574,7 @@ def create_loader_route(config: Configuration, app: FastAPI):
         if route_data is None:
             raise HTTPException(status_code=404, detail=f'Route {route_id} not found')
 
-        action_results: Dict[str, Any] = {}
+        action_results: dict[str, Any] = {}
 
         if len(body.action_payloads) > 0:
             store: CacheStore = utils_registry.get('Store')

dara/core/internal/scheduler.py

@@ -20,19 +20,19 @@ from datetime import datetime
 from multiprocessing import get_context
 from multiprocessing.process import BaseProcess
 from pickle import PicklingError
-from typing import Any, List, Optional, Union, cast
+from typing import Any, cast
 
 from croniter import croniter
 from pydantic import BaseModel, field_validator
 
 
 class ScheduledJob(BaseModel):
-    interval: Union[int, List[int]]
+    interval: int | list[int]
     continue_running: bool = True
     first_execution: bool = True
     run_once: bool
 
-    def __init__(self, interval: Union[int, list], run_once=False, **kwargs):
+    def __init__(self, interval: int | list, run_once=False, **kwargs):
         """
         Creates a ScheduledJob object
 
@@ -126,7 +126,7 @@ class CronScheduledJob(ScheduledJob):
 class TimeScheduledJob(ScheduledJob):
     job_time: datetime
 
-    def __init__(self, interval: Union[int, list], job_time: str, run_once=False):
+    def __init__(self, interval: int | list, job_time: str, run_once=False):
         """
         Creates a TimeScheduledJob object
 
@@ -172,9 +172,9 @@ class ScheduledJobFactory(BaseModel):
     :param run_once: Whether the job should be run only once
     """
 
-    interval: Union[int, list]
+    interval: int | list
     continue_running: bool = True
-    weekday: Optional[datetime] = None
+    weekday: datetime | None = None
     run_once: bool
 
     @field_validator('weekday', mode='before')
@@ -197,7 +197,7 @@ class ScheduledJobFactory(BaseModel):
         # If the job is scheduled to execute on a weekly basis
         if self.weekday is not None:
             # Set 2 intervals, where the first interval is the time from now until the first execution
-            interval = [(self.weekday - datetime.utcnow()).seconds, self.interval]  # type: Union[list, int]
+            interval: list | int = [(self.weekday - datetime.utcnow()).seconds, self.interval]
         else:
             interval = self.interval
         job = TimeScheduledJob(interval, job_time, run_once=self.run_once)
@@ -214,7 +214,7 @@ class ScheduledJobFactory(BaseModel):
         """
         if self.weekday is not None:
             # Set 2 intervals, where the first interval is the time from now until the first execution
-            interval = [(self.weekday - datetime.utcnow()).seconds, self.interval]  # type: Union[list, int]
+            interval: list | int = [(self.weekday - datetime.utcnow()).seconds, self.interval]
         else:
             interval = self.interval
         job = ScheduledJob(interval, run_once=self.run_once)

dara/core/internal/settings.py

@@ -18,7 +18,6 @@ limitations under the License.
 import os
 from functools import lru_cache
 from secrets import token_hex
-from typing import List, Optional
 
 from dotenv import dotenv_values
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -44,7 +43,7 @@ class Settings(BaseSettings):
     sso_groups: str = ''
     sso_jwt_algo: str = 'ES256'
     sso_verify_audience: bool = False
-    sso_extra_audience: Optional[List[str]] = None
+    sso_extra_audience: list[str] | None = None
     model_config = SettingsConfigDict(env_file='.env', extra='allow')
 
 

dara/core/internal/store.py

@@ -15,7 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from dara.core.base_definitions import CacheType, PendingTask
 from dara.core.internal.utils import get_cache_scope
@@ -34,9 +34,9 @@ class Store:
     def __init__(self):
         # This dict is the main store of values, the first level of keys is the cache type and the second level are the
         # value keys. The root key is used for any non-session/user dependant keys that are added.
-        self._store: Dict[str, Dict[str, Any]] = {'global': {}}
+        self._store: dict[str, dict[str, Any]] = {'global': {}}
 
-    def get(self, key: str, cache_type: Optional[CacheType] = CacheType.GLOBAL) -> Any:
+    def get(self, key: str, cache_type: CacheType | None = CacheType.GLOBAL) -> Any:
         """
         Get a given key from the store and optionally pull it from the specified cache store or the global one
 
@@ -47,7 +47,7 @@ class Store:
         cache_key = get_cache_scope(cache_type)
         return self._store.get(cache_key, {}).get(key)
 
-    async def get_or_wait(self, key: str, cache_type: Optional[CacheType] = CacheType.GLOBAL) -> Any:
+    async def get_or_wait(self, key: str, cache_type: CacheType | None = CacheType.GLOBAL) -> Any:
         """
         Wait for the given key to not be pending and then return the value. Optionally pull it from the specified cache specific
         store or the global one
@@ -67,8 +67,8 @@ class Store:
         self,
         key: str,
         value: Any,
-        cache_type: Optional[CacheType] = CacheType.GLOBAL,
-        error: Optional[Exception] = None,
+        cache_type: CacheType | None = CacheType.GLOBAL,
+        error: Exception | None = None,
     ):
         """
         Set the value of a given key in the store. the cache_type flag can be used to optionally pull the value from
@@ -86,7 +86,7 @@ class Store:
 
         self._store[cache_key][key] = value
 
-    def set_pending_task(self, key: str, pending_task: PendingTask, cache_type: Optional[CacheType] = CacheType.GLOBAL):
+    def set_pending_task(self, key: str, pending_task: PendingTask, cache_type: CacheType | None = CacheType.GLOBAL):
         """
         Store a pending task state for a given key in the store. This will trigger the async behavior of the get call if subsequent
         requests ask for the same key. The PendingTask will be resolved once the underlying task is completed.
@@ -102,7 +102,7 @@ class Store:
 
         self._store[cache_key][key] = pending_task
 
-    def remove_starting_with(self, start: str, cache_type: Optional[CacheType] = CacheType.GLOBAL):
+    def remove_starting_with(self, start: str, cache_type: CacheType | None = CacheType.GLOBAL):
         """
         Remove any entries stored under keys starting with given string
 
@@ -134,7 +134,7 @@ class Store:
                     if not isinstance(cache_type_store[key], PendingTask):
                         cache_type_store.pop(key)
 
-    def list(self, cache_type: Optional[CacheType] = CacheType.GLOBAL) -> List[str]:
+    def list(self, cache_type: CacheType | None = CacheType.GLOBAL) -> list[str]:
         """
         List all keys in a specified cache store. Listed the global store unless cache_type is not None
 

dara/core/internal/tasks.py

@@ -18,8 +18,8 @@ limitations under the License.
 import contextlib
 import inspect
 import math
-from collections.abc import Awaitable
-from typing import Any, Callable, Dict, List, Optional, Set, Union, cast, overload
+from collections.abc import Awaitable, Callable
+from typing import Any, cast, overload
 
 from anyio import (
     BrokenResourceError,
@@ -68,13 +68,13 @@ class Task(BaseTask):
     def __init__(
         self,
         func: Callable,
-        args: Union[List[Any], None] = None,
-        kwargs: Union[Dict[str, Any], None] = None,
-        reg_entry: Optional[CachedRegistryEntry] = None,
-        notify_channels: Optional[List[str]] = None,
-        cache_key: Optional[str] = None,
-        task_id: Optional[str] = None,
-        on_progress: Optional[Callable[[TaskProgressUpdate], Union[None, Awaitable[None]]]] = None,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+        reg_entry: CachedRegistryEntry | None = None,
+        notify_channels: list[str] | None = None,
+        cache_key: str | None = None,
+        task_id: str | None = None,
+        on_progress: Callable[[TaskProgressUpdate], None | Awaitable[None]] | None = None,
     ):
         """
         :param func: The function to execute within the process
@@ -122,7 +122,7 @@ class Task(BaseTask):
 
         return func.__name__
 
-    async def run(self, send_stream: Optional[MemoryObjectSendStream[TaskMessage]] = None) -> Any:
+    async def run(self, send_stream: MemoryObjectSendStream[TaskMessage] | None = None) -> Any:
         """
         Run the task asynchronously, and await its' end.
 
@@ -200,13 +200,13 @@ class MetaTask(BaseTask):
     def __init__(
         self,
         process_result: Callable[..., Any],
-        args: Optional[List[Any]] = None,
-        kwargs: Optional[Dict[str, Any]] = None,
-        reg_entry: Optional[CachedRegistryEntry] = None,
-        notify_channels: Optional[List[str]] = None,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+        reg_entry: CachedRegistryEntry | None = None,
+        notify_channels: list[str] | None = None,
         process_as_task: bool = False,
-        cache_key: Optional[str] = None,
-        task_id: Optional[str] = None,
+        cache_key: str | None = None,
+        task_id: str | None = None,
     ):
         """
         :param process result: A function to process the result of the other tasks
@@ -224,13 +224,13 @@ class MetaTask(BaseTask):
         self.kwargs = kwargs if kwargs is not None else {}
         self.notify_channels = notify_channels if notify_channels is not None else []
         self.process_as_task = process_as_task
-        self.cancel_scope: Optional[CancelScope] = None
+        self.cancel_scope: CancelScope | None = None
         self.cache_key = cache_key
         self.reg_entry = reg_entry
 
         super().__init__(task_id)
 
-    async def run(self, send_stream: Optional[MemoryObjectSendStream[TaskMessage]] = None):
+    async def run(self, send_stream: MemoryObjectSendStream[TaskMessage] | None = None):
         """
         Run any tasks found in the arguments to completion, collect the results and then call the process result
         function as a further task with a resultant arguments
@@ -241,7 +241,7 @@ class MetaTask(BaseTask):
 
         try:
             with self.cancel_scope:
-                tasks: List[BaseTask] = []
+                tasks: list[BaseTask] = []
 
                 # Collect up the tasks that need to be run and kick them off without awaiting them.
                 tasks.extend(x for x in self.args if isinstance(x, BaseTask))
@@ -250,7 +250,7 @@ class MetaTask(BaseTask):
                 eng_logger.info(f'MetaTask {self.task_id} running sub-tasks', {'task_ids': [x.task_id for x in tasks]})
 
                 # Wait for all tasks to complete
-                results: Dict[str, Any] = {}
+                results: dict[str, Any] = {}
 
                 async def _run_and_capture_result(task: BaseTask):
                     """
@@ -382,7 +382,7 @@ class TaskManager:
     """
 
     def __init__(self, task_group: TaskGroup, ws_manager: WebsocketManager, store: CacheStore):
-        self.tasks: Dict[str, PendingTask] = {}
+        self.tasks: dict[str, PendingTask] = {}
         self.task_group = task_group
         self.ws_manager = ws_manager
         self.store = store
@@ -396,12 +396,12 @@ class TaskManager:
         return pending_task
 
     @overload
-    async def run_task(self, task: PendingTask, ws_channel: Optional[str] = None) -> Any: ...
+    async def run_task(self, task: PendingTask, ws_channel: str | None = None) -> Any: ...
 
     @overload
-    async def run_task(self, task: BaseTask, ws_channel: Optional[str] = None) -> PendingTask: ...
+    async def run_task(self, task: BaseTask, ws_channel: str | None = None) -> PendingTask: ...
 
-    async def run_task(self, task: BaseTask, ws_channel: Optional[str] = None):
+    async def run_task(self, task: BaseTask, ws_channel: str | None = None):
         """
         Run a task and store it in the tasks dict
 
@@ -438,7 +438,7 @@ class TaskManager:
 
         return pending_task
 
-    async def _cancel_tasks(self, task_ids: List[str], notify: bool = True):
+    async def _cancel_tasks(self, task_ids: list[str], notify: bool = True):
         """
         Cancel a list of tasks
 
@@ -534,7 +534,7 @@ class TaskManager:
         """
         return await self.store.set(TaskResultEntry, key=task_id, value=value)
 
-    def _collect_all_task_ids_in_hierarchy(self, task: BaseTask) -> Set[str]:
+    def _collect_all_task_ids_in_hierarchy(self, task: BaseTask) -> set[str]:
         """
         Recursively collect all task IDs in the task hierarchy
 
@@ -556,7 +556,7 @@ class TaskManager:
 
         return task_ids
 
-    async def _multicast_notification(self, task_id: str, messages: List[dict], variable_task_id: bool = True):
+    async def _multicast_notification(self, task_id: str, messages: list[dict], variable_task_id: bool = True):
         """
         Send notifications to all task IDs that are related to a given task
 
@@ -585,7 +585,7 @@ class TaskManager:
                         pending_task = self.tasks[pending_task_id]
                         task_tg.start_soon(self._send_notification_for_task, pending_task, messages, variable_task_id)
 
-    async def _send_notification_for_task(self, task: BaseTask, messages: List[dict], variable_task_id: bool = True):
+    async def _send_notification_for_task(self, task: BaseTask, messages: list[dict], variable_task_id: bool = True):
         """
         Send notifications for a specific PendingTask
 
@@ -713,7 +713,7 @@ class TaskManager:
                             # Remove the task from the registered tasks - it finished running
                             self.tasks.pop(message.task_id, None)
 
-            task_error: Optional[ExceptionGroup] = None
+            task_error: ExceptionGroup | None = None
 
             # ExceptionGroup handler can't be async so we just mark the task as errored
             # and run the async handler in the finally block
@@ -746,7 +746,7 @@ class TaskManager:
             finally:
                 with CancelScope(shield=True):
                     # cast explicitly as otherwise pyright thinks it's always None here
-                    task_error = cast(Optional[ExceptionGroup], task_error)
+                    task_error = cast(ExceptionGroup | None, task_error)
                     if task_error is not None:
                         err = task_error
                         # Mark pending task as failed

dara/core/internal/utils.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import asyncio
 import inspect
 import os
-from collections.abc import Awaitable, Coroutine, Sequence
+from collections.abc import Awaitable, Callable, Coroutine, Sequence
 from functools import wraps
 from importlib import import_module
 from importlib.util import find_spec
@@ -28,14 +28,8 @@ from types import ModuleType
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
     Literal,
-    Optional,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
 )
 
 import anyio
@@ -55,10 +49,10 @@ if TYPE_CHECKING:
 
 # CacheScope stores as a key an user if cache is set to users, a session_id if cache is sessions or is set to 'global' otherwise
 # The value is a cache_key, for example the cache key used to store derived variable results to the store
-CacheScope = Union[Literal['global'], str]
+CacheScope = Literal['global'] | str
 
 
-def get_cache_scope(cache_type: Optional[CacheType]) -> CacheScope:
+def get_cache_scope(cache_type: CacheType | None) -> CacheScope:
     """
     Helper to resolve the cache scope
 
@@ -80,7 +74,7 @@ def get_cache_scope(cache_type: Optional[CacheType]) -> CacheScope:
     return 'global'
 
 
-async def run_user_handler(handler: Callable, args: Union[Sequence, None] = None, kwargs: Union[dict, None] = None):
+async def run_user_handler(handler: Callable, args: Sequence | None = None, kwargs: dict | None = None):
     """
     Run a user-defined handler function. Runs sync functions in a threadpool.
     Handles SystemExits cleanly.
@@ -123,7 +117,7 @@ def call_async(handler: Callable[..., Coroutine], *args):
                 portal.call(handler, *args)
 
 
-def import_config(config_path: str) -> Tuple[ModuleType, ConfigurationBuilder]:
+def import_config(config_path: str) -> tuple[ModuleType, ConfigurationBuilder]:
     """
     Import Dara from specified config in format "my_package.my_module:variable_name"
     """
@@ -194,9 +188,9 @@ def async_dedupe(fn: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
     This decorator is useful for operations that might be triggered multiple times in parallel
     but should be executed only once to prevent redundant work or data fetches.
     """
-    locks: Dict[Tuple, anyio.Lock] = {}
-    results: Dict[Tuple, Any] = {}
-    wait_counts: Dict[Tuple, int] = {}
+    locks: dict[tuple, anyio.Lock] = {}
+    results: dict[tuple, Any] = {}
+    wait_counts: dict[tuple, int] = {}
 
     is_method = 'self' in inspect.signature(fn).parameters
 
@@ -243,7 +237,7 @@ def resolve_exception_group(error: Any):
     return error
 
 
-def exception_group_contains(err_type: Type[BaseException], group: BaseExceptionGroup) -> bool:
+def exception_group_contains(err_type: type[BaseException], group: BaseExceptionGroup) -> bool:
     """
     Check if an ExceptionGroup contains an error of a given type, recursively