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

dara/core/interactivity/filtering.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import re
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, List, Optional, Tuple, Union, cast, overload
+from typing import Any, cast, overload
 
 import numpy
 from pandas import DataFrame, Series
@@ -47,10 +47,10 @@ class Pagination(BaseModel):
     If index is defined, retrieves only the row of the specified index
     """
 
-    offset: Optional[int] = None
-    limit: Optional[int] = None
-    orderBy: Optional[str] = None
-    index: Optional[str] = None
+    offset: int | None = None
+    limit: int | None = None
+    orderBy: str | None = None
+    index: str | None = None
 
     @field_validator('orderBy', mode='before')
     @classmethod
@@ -83,7 +83,7 @@ class ClauseQuery(BaseModel):
     """
 
     combinator: QueryCombinator
-    clauses: List[FilterQuery]
+    clauses: list[FilterQuery]
 
 
 class ValueQuery(BaseModel):
@@ -96,7 +96,7 @@ class ValueQuery(BaseModel):
     value: Any
 
 
-FilterQuery = Union[ClauseQuery, ValueQuery]
+FilterQuery = ClauseQuery | ValueQuery
 """
 Filter query to be applied
 """
@@ -104,7 +104,7 @@ Filter query to be applied
 ClauseQuery.model_rebuild()
 
 
-def coerce_to_filter_query(filters: Union[ClauseQuery, ValueQuery, dict, None]) -> Optional[FilterQuery]:
+def coerce_to_filter_query(filters: ClauseQuery | ValueQuery | dict | None) -> FilterQuery | None:
     """
     Coerce a filter query to a FilterQuery object. Converts dict representation to the correct query type.
     """
@@ -172,7 +172,7 @@ def infer_column_type(series: Series) -> ColumnType:
         return ColumnType.CATEGORICAL
 
 
-def _filter_to_series(data: DataFrame, column: str, operator: QueryOperator, value: Any) -> Optional[Series]:
+def _filter_to_series(data: DataFrame, column: str, operator: QueryOperator, value: Any) -> Series | None:
     """
     Convert a single filter to a Series[bool] for filtering
     """
@@ -186,14 +186,14 @@ def _filter_to_series(data: DataFrame, column: str, operator: QueryOperator, val
 
     try:
         # In the case of categorical filter we get a List for value
-        if isinstance(value, List):
+        if isinstance(value, list):
             return series.isin(value)
         # Converts date passed from frontend to the right format to compare with pandas
         if col_type == ColumnType.DATETIME:
-            value = [parseISO(value[0]), parseISO(value[1])] if isinstance(value, List) else parseISO(value)
+            value = [parseISO(value[0]), parseISO(value[1])] if isinstance(value, list) else parseISO(value)
         elif col_type == ColumnType.CATEGORICAL:
             value = str(value)
-        elif isinstance(value, List):
+        elif isinstance(value, list):
             lower_bound = float(value[0]) if '.' in str(value[0]) else int(value[0])
             upper_bound = float(value[1]) if '.' in str(value[1]) else int(value[1])
             value = [lower_bound, upper_bound]
@@ -219,7 +219,7 @@ def _filter_to_series(data: DataFrame, column: str, operator: QueryOperator, val
         return None
 
 
-def _resolve_filter_query(data: DataFrame, query: FilterQuery) -> Optional[Series]:
+def _resolve_filter_query(data: DataFrame, query: FilterQuery) -> Series | None:
     """
     Resolve a FilterQuery to a Series[bool] for filtering. Strips the internal column index from the query.
     """
@@ -248,19 +248,19 @@ def _resolve_filter_query(data: DataFrame, query: FilterQuery) -> Optional[Serie
 
 @overload
 def apply_filters(
-    data: DataFrame, filters: Optional[FilterQuery] = None, pagination: Optional[Pagination] = None
-) -> Tuple[DataFrame, int]: ...
+    data: DataFrame, filters: FilterQuery | None = None, pagination: Pagination | None = None
+) -> tuple[DataFrame, int]: ...
 
 
 @overload
 def apply_filters(
-    data: None, filters: Optional[FilterQuery] = None, pagination: Optional[Pagination] = None
-) -> Tuple[None, int]: ...
+    data: None, filters: FilterQuery | None = None, pagination: Pagination | None = None
+) -> tuple[None, int]: ...
 
 
 def apply_filters(
-    data: Optional[DataFrame], filters: Optional[FilterQuery] = None, pagination: Optional[Pagination] = None
-) -> Tuple[Optional[DataFrame], int]:
+    data: DataFrame | None, filters: FilterQuery | None = None, pagination: Pagination | None = None
+) -> tuple[DataFrame | None, int]:
     """
     Apply filtering and pagination to a DataFrame.
     """

dara/core/interactivity/loop_variable.py

@@ -1,5 +1,3 @@
-from typing import List, Optional
-
 from pydantic import Field, SerializerFunctionWrapHandler, model_serializer
 
 from .client_variable import ClientVariable
@@ -47,9 +45,9 @@ class LoopVariable(ClientVariable):
     Both `get` and `[]` are equivalent.
     """
 
-    nested: List[str] = Field(default_factory=list)
+    nested: list[str] = Field(default_factory=list)
 
-    def __init__(self, uid: Optional[str] = None, nested: Optional[List[str]] = None):
+    def __init__(self, uid: str | None = None, nested: list[str] | None = None):
         if nested is None:
             nested = []
         super().__init__(uid=uid, nested=nested)

dara/core/interactivity/non_data_variable.py

@@ -1,4 +1,4 @@
-from typing_extensions import TypeAlias
+from typing import TypeAlias
 
 from .client_variable import *  # noqa: F403
 

dara/core/interactivity/plain_variable.py

@@ -18,9 +18,10 @@ limitations under the License.
 from __future__ import annotations
 
 import warnings
+from collections.abc import Callable
 from contextlib import contextmanager
 from contextvars import ContextVar
-from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Union
+from typing import Any, Generic
 
 from fastapi.encoders import jsonable_encoder
 from pydantic import (
@@ -30,6 +31,7 @@ from pydantic import (
     field_serializer,
     model_serializer,
 )
+from typing_extensions import TypeVar
 
 from dara.core.interactivity.client_variable import ClientVariable
 from dara.core.interactivity.derived_variable import DerivedVariable
@@ -37,31 +39,32 @@ from dara.core.internal.utils import call_async
 from dara.core.logging import dev_logger
 from dara.core.persistence import BackendStore, BrowserStore, PersistenceStore
 
-VARIABLE_INIT_OVERRIDE = ContextVar[Optional[Callable[[dict], dict]]]('VARIABLE_INIT_OVERRIDE', default=None)
+VARIABLE_INIT_OVERRIDE = ContextVar[Callable[[dict], dict] | None]('VARIABLE_INIT_OVERRIDE', default=None)
 
 VariableType = TypeVar('VariableType')
-PersistenceStoreType_co = TypeVar('PersistenceStoreType_co', bound=PersistenceStore, covariant=True)
+PersistenceStoreType_co = TypeVar(
+    'PersistenceStoreType_co', bound=PersistenceStore, covariant=True, default=PersistenceStore
+)
 
 
-# TODO: once Python supports a default value for a generic type properly we can make PersistenceStoreType a second generic param
-class Variable(ClientVariable, Generic[VariableType]):
+class Variable(ClientVariable, Generic[VariableType, PersistenceStoreType_co]):
     """
     A Variable represents a dynamic value in the system that can be read and written to by components and actions
     """
 
-    default: Optional[VariableType] = None
-    store: Optional[PersistenceStore] = None
+    default: VariableType | None = None
+    store: PersistenceStoreType_co | None = None
     uid: str
-    nested: List[str] = Field(default_factory=list)
+    nested: list[str] = Field(default_factory=list)
     model_config = ConfigDict(extra='forbid')
 
     def __init__(
         self,
-        default: Optional[VariableType] = None,
-        persist_value: Optional[bool] = False,
-        uid: Optional[str] = None,
-        store: Optional[PersistenceStoreType_co] = None,
-        nested: Optional[List[str]] = None,
+        default: VariableType | None = None,
+        persist_value: bool | None = False,
+        uid: str | None = None,
+        store: PersistenceStoreType_co | None = None,
+        nested: list[str] | None = None,
         **kwargs,
     ):
         """
@@ -233,7 +236,7 @@ class Variable(ClientVariable, Generic[VariableType]):
         assert_no_context('ctx.update')
         return UpdateVariableImpl(variable=self, value=UpdateVariableImpl.TOGGLE)
 
-    def update(self, value: Any):
+    def update(self, value: VariableType):
         """
         Create an action to update the value of this Variable to a provided value.
 
@@ -269,7 +272,7 @@ class Variable(ClientVariable, Generic[VariableType]):
         """
         return cls(default=other)  # type: ignore
 
-    async def write(self, value: Any, notify=True, ignore_channel: Optional[str] = None):
+    async def write(self, value: VariableType, notify=True, ignore_channel: str | None = None):
         """
         Persist a value to the variable's BackendStore.
         Raises an error if the variable does not have a BackendStore attached.
@@ -284,7 +287,7 @@ class Variable(ClientVariable, Generic[VariableType]):
         assert isinstance(self.store, BackendStore), 'This method can only be used with a BackendStore'
         return await self.store.write(value, notify=notify, ignore_channel=ignore_channel)
 
-    async def write_partial(self, data: Union[List[Dict[str, Any]], Any], notify: bool = True, in_place: bool = False):
+    async def write_partial(self, data: list[dict[str, Any]] | Any, notify: bool = True, in_place: bool = False):
         """
         Apply partial updates to the variable's BackendStore using JSON Patch operations or automatic diffing.
         Raises an error if the variable does not have a BackendStore attached.
@@ -302,7 +305,7 @@ class Variable(ClientVariable, Generic[VariableType]):
         assert isinstance(self.store, BackendStore), 'This method can only be used with a BackendStore'
         return await self.store.write_partial(data, notify=notify, in_place=in_place)
 
-    async def read(self):
+    async def read(self) -> VariableType:
         """
         Read a value from the variable's BackendStore.
         Raises an error if the variable does not have a BackendStore attached.
@@ -326,7 +329,7 @@ class Variable(ClientVariable, Generic[VariableType]):
         assert isinstance(self.store, BackendStore), 'This method can only be used with a BackendStore'
         return await self.store.delete(notify=notify)
 
-    async def get_all(self) -> Dict[str, Any]:
+    async def get_all(self) -> dict[str, VariableType]:
         """
         Get all the values from the variable's BackendStore as a dictionary of key-value pairs.
         Raises an error if the variable does not have a BackendStore attached.

dara/core/interactivity/server_variable.py

@@ -1,6 +1,6 @@
 import abc
 from collections import defaultdict
-from typing import Any, DefaultDict, Dict, Literal, Optional, Tuple, Union
+from typing import Any, Literal
 
 from pandas import DataFrame
 from pydantic import BaseModel, ConfigDict, Field, SerializerFunctionWrapHandler, model_serializer
@@ -38,8 +38,8 @@ class ServerBackend(BaseModel, abc.ABC):
 
     @abc.abstractmethod
     async def read_filtered(
-        self, key: str, filters: Optional[Union[FilterQuery, dict]] = None, pagination: Optional[Pagination] = None
-    ) -> Tuple[Optional[DataFrame], int]:
+        self, key: str, filters: FilterQuery | dict | None = None, pagination: Pagination | None = None
+    ) -> tuple[DataFrame | None, int]:
         """
         Read a value
         :param filters: filters to apply
@@ -54,8 +54,8 @@ class ServerBackend(BaseModel, abc.ABC):
 
 
 class MemoryBackend(ServerBackend):
-    data: Dict[str, Any] = Field(default_factory=dict)
-    sequence_number: DefaultDict[str, int] = Field(default_factory=lambda: defaultdict(int))
+    data: dict[str, Any] = Field(default_factory=dict)
+    sequence_number: defaultdict[str, int] = Field(default_factory=lambda: defaultdict(int))
 
     def __init__(self, scope: Literal['user', 'global'] = 'user'):
         super().__init__(scope=scope)
@@ -69,8 +69,8 @@ class MemoryBackend(ServerBackend):
         return self.data.get(key)
 
     async def read_filtered(
-        self, key: str, filters: Optional[Union[FilterQuery, dict]] = None, pagination: Optional[Pagination] = None
-    ) -> Tuple[Optional[DataFrame], int]:
+        self, key: str, filters: FilterQuery | dict | None = None, pagination: Pagination | None = None
+    ) -> tuple[DataFrame | None, int]:
         dataset = self.data.get(key)
 
         # print user-friendly error message if the data is not a DataFrame
@@ -141,10 +141,10 @@ class ServerVariable(AnyVariable):
 
     def __init__(
         self,
-        default: Optional[Any] = None,
-        backend: Optional[ServerBackend] = None,
+        default: Any | None = None,
+        backend: ServerBackend | None = None,
         scope: Literal['user', 'global'] = 'global',
-        uid: Optional[str] = None,
+        uid: str | None = None,
         **kwargs,
     ) -> None:
         from dara.core.internal.registries import server_variable_registry
@@ -192,8 +192,8 @@ class ServerVariable(AnyVariable):
     async def get_tabular_data(
         cls,
         entry: 'ServerVariableRegistryEntry',
-        filters: Optional[FilterQuery] = None,
-        pagination: Optional[Pagination] = None,
+        filters: FilterQuery | None = None,
+        pagination: Pagination | None = None,
     ) -> DataResponse:
         """
         Internal method to get tabular data from the backend
@@ -294,9 +294,7 @@ class ServerVariable(AnyVariable):
         await self._notify(self.uid, self.key, self.backend)
         return value
 
-    async def read_filtered(
-        self, filters: Optional[Union[FilterQuery, dict]] = None, pagination: Optional[Pagination] = None
-    ):
+    async def read_filtered(self, filters: FilterQuery | dict | None = None, pagination: Pagination | None = None):
         """
         Read a filtered value from the backend.
         Depending on the scope, the value will be global or user-specific.

dara/core/interactivity/state_variable.py

@@ -17,10 +17,9 @@ limitations under the License.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Literal
 
 from pydantic import SerializerFunctionWrapHandler, model_serializer
-from typing_extensions import Literal
 
 from dara.core.interactivity.client_variable import ClientVariable
 
@@ -38,14 +37,14 @@ class StateVariable(ClientVariable):
     like loading state, error state, etc.
     """
 
-    parent_variable: 'DerivedVariable'
+    parent_variable: DerivedVariable
     property_name: Literal['loading', 'error', 'hasValue']
 
     def __init__(
         self,
-        parent_variable: 'DerivedVariable',
+        parent_variable: DerivedVariable,
         property_name: Literal['loading', 'error', 'hasValue'],
-        uid: Optional[str] = None,
+        uid: str | None = None,
         **kwargs,
     ):
         """

dara/core/interactivity/switch_variable.py

@@ -17,7 +17,7 @@ limitations under the License.
 
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 from pydantic import SerializerFunctionWrapHandler, field_validator, model_serializer
 
@@ -222,17 +222,17 @@ class SwitchVariable(ClientVariable):
         - Other values use standard string conversion to match JavaScript's String() behavior
     """
 
-    value: Optional[Union[Condition, ClientVariable, Any]] = None
+    value: Condition | ClientVariable | Any | None = None
     # must be typed as any, otherwise pydantic is trying to instantiate the variables incorrectly
-    value_map: Optional[Any] = None
-    default: Optional[Any] = None
+    value_map: Any | None = None
+    default: Any | None = None
 
     def __init__(
         self,
-        value: Union[Condition, ClientVariable, Any],
-        value_map: Dict[Any, Any] | ClientVariable,
-        default: Optional[Any] = None,
-        uid: Optional[str] = None,
+        value: Condition | ClientVariable | Any,
+        value_map: dict[Any, Any] | ClientVariable,
+        default: Any | None = None,
+        uid: str | None = None,
     ):
         """
         Create a SwitchVariable with a mapping of values.
@@ -270,10 +270,10 @@ class SwitchVariable(ClientVariable):
     @classmethod
     def when(
         cls,
-        condition: Union[Condition, ClientVariable, Any],
-        true_value: Union[Any, ClientVariable],
-        false_value: Union[Any, ClientVariable],
-        uid: Optional[str] = None,
+        condition: Condition | ClientVariable | Any,
+        true_value: Any | ClientVariable,
+        false_value: Any | ClientVariable,
+        uid: str | None = None,
     ) -> SwitchVariable:
         """
         Create a SwitchVariable for boolean conditions.
@@ -346,10 +346,10 @@ class SwitchVariable(ClientVariable):
     @classmethod
     def match(
         cls,
-        value: Union[ClientVariable, Any],
-        mapping: Union[Dict[Any, Any], ClientVariable],
-        default: Optional[Union[Any, ClientVariable]] = None,
-        uid: Optional[str] = None,
+        value: ClientVariable | Any,
+        mapping: dict[Any, Any] | ClientVariable,
+        default: Any | ClientVariable | None = None,
+        uid: str | None = None,
     ) -> SwitchVariable:
         """
         Create a SwitchVariable with a custom mapping.

dara/core/interactivity/tabular_variable.py

@@ -17,7 +17,7 @@ limitations under the License.
 
 import io
 import os
-from typing import Literal, Optional, TypedDict, Union, cast
+from typing import Literal, TypedDict, cast
 
 import pandas
 from fastapi import UploadFile
@@ -28,7 +28,7 @@ from dara.core.internal.utils import run_user_handler
 
 
 class FieldType(TypedDict):
-    name: Union[str, tuple[str, ...]]
+    name: str | tuple[str, ...]
     type: Literal['integer', 'number', 'boolean', 'datetime', 'duration', 'any', 'str']
 
 
@@ -37,7 +37,7 @@ class DataFrameSchema(TypedDict):
     primaryKey: list[str]
 
 
-async def upload(data: UploadFile, data_uid: Optional[str] = None, resolver_id: Optional[str] = None):
+async def upload(data: UploadFile, data_uid: str | None = None, resolver_id: str | None = None):
     """
     Handler for uploading data.
 

dara/core/interactivity/url_variable.py

@@ -17,7 +17,7 @@ limitations under the License.
 
 from __future__ import annotations
 
-from typing import Optional, TypeVar
+from typing import TypeVar
 
 from pydantic import ConfigDict
 from typing_extensions import deprecated
@@ -38,12 +38,12 @@ class UrlVariable(Variable[VariableType]):
     pages as you switch from one to the other.
     """
 
-    default: Optional[VariableType] = None
+    default: VariableType | None = None
     query: str
     uid: str
     model_config = ConfigDict(extra='forbid')
 
-    def __init__(self, query: str, default: Optional[VariableType] = None, uid: Optional[str] = None):
+    def __init__(self, query: str, default: VariableType | None = None, uid: str | None = None):
         """
         A UrlVariable is very similar to a normal Variable however rather than it's state being stored in the memory of
         the client it's value is stored in the url of page as a query parameter. This is very useful for parameterizing

dara/core/internal/cache_store/cache_store.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Generic, Optional, cast
+from typing import Any, Generic, cast
 
 from dara.core.base_definitions import (
     CachedRegistryEntry,
@@ -20,7 +20,7 @@ def cache_impl_for_policy(policy: PolicyT) -> CacheStoreImpl[PolicyT]:
     """
     Get a cache implementation depending on the policy
     """
-    impl: Optional[CacheStoreImpl] = None
+    impl: CacheStoreImpl | None = None
 
     if isinstance(policy, (LruCachePolicy, MostRecentCachePolicy)):
         impl = LRUCache(policy)
@@ -43,7 +43,7 @@ class CacheScopeStore(Generic[PolicyT]):
     """
 
     def __init__(self, policy: PolicyT):
-        self.caches: Dict[CacheScope, CacheStoreImpl[PolicyT]] = {}
+        self.caches: dict[CacheScope, CacheStoreImpl[PolicyT]] = {}
         self.policy = policy
 
     async def delete(self, key: str) -> Any:
@@ -61,7 +61,7 @@ class CacheScopeStore(Generic[PolicyT]):
 
         return await cache.delete(key)
 
-    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Any | None:
         """
         Retrieve an entry from the cache.
 
@@ -115,7 +115,7 @@ class CacheStore:
     """
 
     def __init__(self):
-        self.registry_stores: Dict[str, CacheScopeStore] = {}
+        self.registry_stores: dict[str, CacheScopeStore] = {}
         # The size is not totally accurate as we only add/subtract values stored, without accounting for keys
         # or extra memory due to hash collisions, internal cache implementation; its a 'good enough' approximation
         # of just the values stored
@@ -158,7 +158,7 @@ class CacheStore:
         key: str,
         unpin: bool = False,
         raise_for_missing: bool = False,
-    ) -> Optional[Any]:
+    ) -> Any | None:
         """
         Retrieve an entry from the cache for the given registry entry and cache key.
 

dara/core/internal/cache_store/keep_all.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any
 
 import anyio
 
@@ -23,7 +23,7 @@ class KeepAllCache(CacheStoreImpl[KeepAllCachePolicy]):
 
     def __init__(self, policy: KeepAllCachePolicy):
         super().__init__(policy)
-        self.cache: Dict[str, Any] = {}
+        self.cache: dict[str, Any] = {}
         self.lock = anyio.Lock()
 
     async def delete(self, key: str) -> Any:
@@ -42,7 +42,7 @@ class KeepAllCache(CacheStoreImpl[KeepAllCachePolicy]):
             del self.cache[key]
             return entry
 
-    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Any | None:
         """
         Retrieve a value from the cache.
 

dara/core/internal/cache_store/lru.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any
 
 import anyio
 
@@ -20,8 +20,8 @@ class Node:
         self.key = key
         self.value = value
         self.pin = pin
-        self.prev: Optional[Node] = None
-        self.next: Optional[Node] = None
+        self.prev: Node | None = None
+        self.next: Node | None = None
 
     def __repr__(self) -> str:
         return f'Node({self.key}, {self.value}, {self.pin})'
@@ -35,9 +35,9 @@ class LRUCache(CacheStoreImpl[LruCachePolicy]):
 
     def __init__(self, policy: LruCachePolicy):
         super().__init__(policy)
-        self.cache: Dict[str, Node] = {}
-        self.head: Optional[Node] = None  # No sentinel, can be None
-        self.tail: Optional[Node] = None  # No sentinel, can be None
+        self.cache: dict[str, Node] = {}
+        self.head: Node | None = None  # No sentinel, can be None
+        self.tail: Node | None = None  # No sentinel, can be None
         self.lock = anyio.Lock()
 
     def _move_to_front(self, node: Node):
@@ -88,7 +88,7 @@ class LRUCache(CacheStoreImpl[LruCachePolicy]):
             self.cache.pop(key, None)
             return node.value
 
-    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Any | None:
         """
         Retrieve a value from the cache.
 
@@ -136,7 +136,7 @@ class LRUCache(CacheStoreImpl[LruCachePolicy]):
 
                 # Check and perform eviction
                 while len(self.cache) > self.policy.max_size:
-                    evict_node: Optional[Node] = self.tail
+                    evict_node: Node | None = self.tail
 
                     # Skip over pinned nodes
                     while evict_node and evict_node.pin:

dara/core/internal/cache_store/ttl.py

@@ -1,6 +1,6 @@
 import heapq
 import time
-from typing import Any, Dict, List, Tuple
+from typing import Any
 
 import anyio
 
@@ -38,9 +38,9 @@ class TTLCache(CacheStoreImpl[TTLCachePolicy]):
 
     def __init__(self, policy: TTLCachePolicy):
         super().__init__(policy)
-        self.pinned_cache: Dict[str, Node] = {}
-        self.unpinned_cache: Dict[str, Node] = {}
-        self.expiration_heap: List[Tuple[float, str]] = []  # Stores (expiration_time, key) for unpinned items
+        self.pinned_cache: dict[str, Node] = {}
+        self.unpinned_cache: dict[str, Node] = {}
+        self.expiration_heap: list[tuple[float, str]] = []  # Stores (expiration_time, key) for unpinned items
         self.lock = anyio.Lock()
 
     async def _cleanup(self):

dara/core/internal/custom_response.py

@@ -16,9 +16,9 @@ class CustomResponse(Response):
         self,
         content: typing.Any,
         status_code: int = 200,
-        headers: typing.Optional[typing.Dict[str, str]] = None,
-        media_type: typing.Optional[str] = None,
-        background: typing.Optional[BackgroundTask] = None,
+        headers: dict[str, str] | None = None,
+        media_type: str | None = None,
+        background: BackgroundTask | None = None,
     ) -> None:
         super().__init__(content, status_code, headers, media_type, background)