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

dara/core/auth/base.py

@@ -16,7 +16,7 @@ limitations under the License.
 """
 
 import abc
-from typing import Any, ClassVar, Dict, Union
+from typing import Any, ClassVar
 
 from fastapi import HTTPException, Response
 from pydantic import model_serializer
@@ -57,7 +57,7 @@ class AuthComponentConfig(BaseModel):
     logout: AuthComponent
     """Logout component"""
 
-    extra: Dict[str, AuthComponent] = {}
+    extra: dict[str, AuthComponent] = {}
     """Extra components, map of route -> component"""
 
     @model_serializer()
@@ -72,7 +72,7 @@ class BaseAuthConfig(BaseModel, abc.ABC):
     """
 
     @abc.abstractmethod
-    def get_token(self, body: SessionRequestBody) -> Union[TokenResponse, RedirectResponse]:
+    def get_token(self, body: SessionRequestBody) -> TokenResponse | RedirectResponse:
         """
         Get a session token.
 
@@ -82,7 +82,7 @@ class BaseAuthConfig(BaseModel, abc.ABC):
         """
 
     @abc.abstractmethod
-    def verify_token(self, token: str) -> Union[Any, TokenData]:
+    def verify_token(self, token: str) -> Any | TokenData:
         """
         Verify a session token.
 
@@ -105,7 +105,7 @@ class BaseAuthConfig(BaseModel, abc.ABC):
         """
         raise HTTPException(400, f'Auth config {self.__class__.__name__} does not support token refresh')
 
-    def revoke_token(self, token: str, response: Response) -> Union[SuccessResponse, RedirectResponse]:
+    def revoke_token(self, token: str, response: Response) -> SuccessResponse | RedirectResponse:
         """
         Revoke a session token.
 

dara/core/auth/basic.py

@@ -15,7 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Any, ClassVar, Dict
+from typing import Any, ClassVar
 
 import jwt
 from fastapi import HTTPException
@@ -52,7 +52,7 @@ class BaseBasicAuthConfig(BaseAuthConfig):
         login=BasicAuthLogin,
         logout=BasicAuthLogout,
     )
-    users: Dict[str, str]
+    users: dict[str, str]
 
     def get_token(self, body: SessionRequestBody) -> TokenResponse:
         """
@@ -106,7 +106,7 @@ class BasicAuthConfig(BaseBasicAuthConfig):
 class MultiBasicAuthConfig(BaseBasicAuthConfig):
     """Authenticate the dashboard with multiple users"""
 
-    def __init__(self, users: Dict[str, str]):
+    def __init__(self, users: dict[str, str]):
         super().__init__(users=users)
 
 

dara/core/auth/definitions.py

@@ -17,7 +17,6 @@ limitations under the License.
 
 from contextvars import ContextVar
 from datetime import datetime
-from typing import List, Optional, Union
 
 from typing_extensions import TypedDict
 
@@ -38,12 +37,12 @@ class TokenData(BaseModel):
     """
 
     session_id: str
-    exp: Union[float, int, datetime]
+    exp: float | int | datetime
     identity_id: str
     identity_name: str
-    identity_email: Optional[str] = None
-    id_token: Optional[str] = None
-    groups: Optional[List[str]] = []
+    identity_email: str | None = None
+    id_token: str | None = None
+    groups: list[str] | None = []
 
 
 class UserData(BaseModel):
@@ -58,8 +57,8 @@ class UserData(BaseModel):
 
     identity_id: str
     identity_name: str
-    identity_email: Optional[str] = None
-    groups: Optional[List[str]] = []
+    identity_email: str | None = None
+    groups: list[str] | None = []
 
 
 class TokenResponse(TypedDict):
@@ -75,15 +74,15 @@ class SuccessResponse(TypedDict):
 
 
 class SessionRequestBody(BaseModel):
-    username: Optional[str] = None
-    password: Optional[str] = None
+    username: str | None = None
+    password: str | None = None
 
 
 class AuthError(Exception):
-    detail: Union[str, dict]
+    detail: str | dict
     code: int
 
-    def __init__(self, detail: Union[str, dict], code: int):
+    def __init__(self, detail: str | dict, code: int):
         self.detail = detail
         self.code = code
 
@@ -115,6 +114,6 @@ def BAD_REQUEST_ERROR(msg):
 JWT_ALGO = 'HS256'
 
 # Context
-SESSION_ID: ContextVar[Optional[str]] = ContextVar('session_id', default=None)
-USER: ContextVar[Optional[UserData]] = ContextVar('user', default=None)
-ID_TOKEN: ContextVar[Optional[str]] = ContextVar('id_token', default=None)
+SESSION_ID: ContextVar[str | None] = ContextVar('session_id', default=None)
+USER: ContextVar[UserData | None] = ContextVar('user', default=None)
+ID_TOKEN: ContextVar[str | None] = ContextVar('id_token', default=None)

dara/core/auth/routes.py

@@ -16,7 +16,7 @@ limitations under the License.
 """
 
 from inspect import iscoroutinefunction
-from typing import Union, cast
+from typing import Annotated, cast
 
 import jwt
 from fastapi import APIRouter, Cookie, Depends, HTTPException, Request, Response
@@ -41,7 +41,7 @@ auth_router = APIRouter()
 @auth_router.post('/verify-session')
 async def verify_session(
     req: Request,
-    credentials: HTTPAuthorizationCredentials = Depends(HTTPBearer(auto_error=False)),
+    credentials: Annotated[HTTPAuthorizationCredentials, Depends(HTTPBearer(auto_error=False))],
 ):
     """
     Helper to verify whether the user has a valid session JWT in the request they made. The function should be applied
@@ -86,7 +86,9 @@ async def verify_session(
 
 
 @auth_router.post('/revoke-session')
-async def _revoke_session(response: Response, credentials: HTTPAuthorizationCredentials = Depends(HTTPBearer())):
+async def _revoke_session(
+    response: Response, credentials: Annotated[HTTPAuthorizationCredentials, Depends(HTTPBearer())]
+):
     """
     Helper to revoke a session and its' associated token
     """
@@ -108,8 +110,8 @@ async def _revoke_session(response: Response, credentials: HTTPAuthorizationCred
 @auth_router.post('/refresh-token')
 async def handle_refresh_token(
     response: Response,
-    dara_refresh_token: Union[str, None] = Cookie(default=None),
-    credentials: HTTPAuthorizationCredentials = Depends(HTTPBearer()),
+    credentials: Annotated[HTTPAuthorizationCredentials, Depends(HTTPBearer())],
+    dara_refresh_token: Annotated[str | None, Cookie()] = None,
 ):
     """
     Given a refresh token, issues a new session token and refresh token cookie.

dara/core/auth/utils.py

@@ -17,8 +17,9 @@ limitations under the License.
 
 import asyncio
 import uuid
+from collections.abc import Callable
 from datetime import datetime, timedelta, timezone
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import jwt
 from anyio import to_thread
@@ -53,11 +54,11 @@ def decode_token(token: str, **kwargs) -> TokenData:
 def sign_jwt(
     identity_id: str,
     identity_name: str,
-    identity_email: Optional[str],
-    groups: List[str],
-    id_token: Optional[str] = None,
-    exp: Optional[Union[datetime, int]] = None,
-    session_id: Optional[str] = None,
+    identity_email: str | None,
+    groups: list[str],
+    id_token: str | None = None,
+    exp: datetime | int | None = None,
+    session_id: str | None = None,
 ):
     """
     Create a new Dara JWT token
@@ -115,8 +116,8 @@ class AsyncTokenRefreshCache:
     """
 
     def __init__(self, ttl_seconds: int = 5):
-        self.cache: Dict[str, Tuple[Any, datetime]] = {}
-        self.locks: Dict[str, asyncio.Lock] = {}
+        self.cache: dict[str, tuple[Any, datetime]] = {}
+        self.locks: dict[str, asyncio.Lock] = {}
         self.locks_lock = asyncio.Lock()
         self.ttl = timedelta(seconds=ttl_seconds)
 
@@ -148,7 +149,7 @@ class AsyncTokenRefreshCache:
             # We can modify self.locks here because we're always under an async lock when calling this
             self.locks.pop(key, None)
 
-    def get_cached_value(self, key: str) -> Tuple[Any, bool]:
+    def get_cached_value(self, key: str) -> tuple[Any, bool]:
         """
         Retrieve a value from the cache if it exists and hasn't expired.
 
@@ -186,7 +187,7 @@ Shared token refresh cache instance
 
 
 async def cached_refresh_token(
-    do_refresh_token: Callable[[TokenData, str], Tuple[str, str]], old_token_data: TokenData, refresh_token: str
+    do_refresh_token: Callable[[TokenData, str], tuple[str, str]], old_token_data: TokenData, refresh_token: str
 ):
     """
     A utility to run a token refresh method with caching to prevent multiple concurrent refreshes

dara/core/base_definitions.py

@@ -21,21 +21,15 @@ from __future__ import annotations
 # between other parts of the framework
 import abc
 import uuid
-from collections.abc import Awaitable, Mapping
+from collections.abc import Awaitable, Callable, Mapping
 from enum import Enum
 from inspect import isclass
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Callable,
     ClassVar,
-    Dict,
-    List,
     Literal,
-    Optional,
-    Tuple,
-    Union,
     get_args,
     get_origin,
 )
@@ -84,7 +78,7 @@ def annotation_has_base_model(typ: Any) -> bool:
 # It works by adding SerializeAsAny to all fields of the model.
 # See https://github.com/pydantic/pydantic/issues/6381
 class SerializeAsAnyMeta(ModelMetaclass):
-    def __new__(cls, name: str, bases: Tuple[type], namespaces: Dict[str, Any], **kwargs):
+    def __new__(cls, name: str, bases: tuple[type], namespaces: dict[str, Any], **kwargs):
         annotations: dict = namespaces.get('__annotations__', {}).copy()
 
         for base in bases:
@@ -267,7 +261,7 @@ class Cache:
             )
 
         @classmethod
-        def from_dict(cls, arg: dict) -> Optional[BaseCachePolicy]:
+        def from_dict(cls, arg: dict) -> BaseCachePolicy | None:
             """
             Construct a cache policy from its serialized dict represetnation
             """
@@ -288,7 +282,7 @@ class Cache:
                 raise ValueError(f'Invalid cache policy: {arg}')
 
 
-CacheArgType = Union[CacheType, BaseCachePolicy, str]
+CacheArgType = CacheType | BaseCachePolicy | str
 
 
 class CachedRegistryEntry(BaseModel):
@@ -297,7 +291,7 @@ class CachedRegistryEntry(BaseModel):
     via the cache policy.
     """
 
-    cache: Optional[BaseCachePolicy] = None
+    cache: BaseCachePolicy | None = None
     uid: str
 
     def to_store_key(self):
@@ -327,18 +321,18 @@ class TaskProgressUpdate(BaseTaskMessage):
 
 class TaskResult(BaseTaskMessage):
     result: Any
-    cache_key: Optional[str] = None
-    reg_entry: Optional[CachedRegistryEntry] = None
+    cache_key: str | None = None
+    reg_entry: CachedRegistryEntry | None = None
 
 
 class TaskError(BaseTaskMessage):
     error: BaseException
-    cache_key: Optional[str] = None
-    reg_entry: Optional[CachedRegistryEntry] = None
+    cache_key: str | None = None
+    reg_entry: CachedRegistryEntry | None = None
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
-TaskMessage = Union[TaskProgressUpdate, TaskResult, TaskError]
+TaskMessage = TaskProgressUpdate | TaskResult | TaskError
 
 
 class BaseTask(abc.ABC):
@@ -346,18 +340,18 @@ class BaseTask(abc.ABC):
     Generic BaseTask that can be used for type checking tasks
     """
 
-    cache_key: Optional[str]
-    reg_entry: Optional[CachedRegistryEntry]
-    notify_channels: List[str]
+    cache_key: str | None
+    reg_entry: CachedRegistryEntry | None
+    notify_channels: list[str]
     task_id: str
 
     @abc.abstractmethod
-    def __init__(self, task_id: Optional[str] = None) -> None:
+    def __init__(self, task_id: str | None = None) -> None:
         self.task_id = str(uuid.uuid4()) if task_id is None else task_id
         super().__init__()
 
     @abc.abstractmethod
-    async def run(self, send_stream: Optional[MemoryObjectSendStream[TaskMessage]] = None) -> Any: ...
+    async def run(self, send_stream: MemoryObjectSendStream[TaskMessage] | None = None) -> Any: ...
 
     @abc.abstractmethod
     async def cancel(self): ...
@@ -369,18 +363,18 @@ class PendingTask(BaseTask):
     Is associated to an underlying task definition.
     """
 
-    def __init__(self, task_id: str, task_def: BaseTask, ws_channel: Optional[str] = None):
+    def __init__(self, task_id: str, task_def: BaseTask, ws_channel: str | None = None):
         self.task_id = task_id
         self.task_def = task_def
         self.notify_channels = [ws_channel] if ws_channel else []
 
-        self.cancel_scope: Optional[anyio.CancelScope] = None
+        self.cancel_scope: anyio.CancelScope | None = None
         self.event = anyio.Event()
-        self.result: Optional[Any] = None
-        self.error: Optional[BaseException] = None
+        self.result: Any | None = None
+        self.error: BaseException | None = None
         self.subscribers = 1
 
-    async def run(self, send_stream: Optional[MemoryObjectSendStream[TaskMessage]] = None):
+    async def run(self, send_stream: MemoryObjectSendStream[TaskMessage] | None = None):
         """
         Wait for the task to complete
         """
@@ -445,17 +439,17 @@ class PendingTask(BaseTask):
 
 
 class RouterPath(BaseModel):
-    pathname: Optional[str] = None
+    pathname: str | None = None
     """
     A URL pathname, beginning with '/'.
     """
 
-    search: Optional[str] = None
+    search: str | None = None
     """
     A URL search string, beginning with '?'.
     """
 
-    hash: Optional[str] = None
+    hash: str | None = None
     """
     A URL hash string, beginning with '#'.
     """
@@ -542,8 +536,8 @@ class ActionImpl(DaraBaseModel):
     Required for non-local actions which have a JS implementation.
     """
 
-    js_module: ClassVar[Optional[str]] = None
-    py_name: ClassVar[Optional[str]] = None
+    js_module: ClassVar[str | None] = None
+    py_name: ClassVar[str | None] = None
 
     async def execute(self, ctx: ActionCtx) -> Any:
         """
@@ -570,13 +564,13 @@ class ActionImpl(DaraBaseModel):
         return jsonable_encoder(value)
 
 
-ActionInstance = Union[ActionImpl, AnnotatedAction]
+ActionInstance = ActionImpl | AnnotatedAction
 """
 @deprecated alias for backwards compatibility
 """
 
 # TODO: remove List[AnnotatedAction] support in 2.0
-Action = Union[ActionImpl, AnnotatedAction, List[Union[AnnotatedAction, ActionImpl]]]
+Action = ActionImpl | AnnotatedAction | list[AnnotatedAction | ActionImpl]
 """
 Definition of an action that can be executed by the frontend.
 Supports:
@@ -601,14 +595,14 @@ class ActionDef(BaseModel):
 
     name: str
     py_module: str
-    js_module: Optional[str] = None
+    js_module: str | None = None
 
 
 class ActionResolverDef(BaseModel):
     uid: str
     """Unique id of the action definition"""
 
-    resolver: Optional[Callable] = None
+    resolver: Callable | None = None
     """Resolver function for the action"""
 
     execute_action: Callable[..., Awaitable[Any]]
@@ -616,7 +610,7 @@ class ActionResolverDef(BaseModel):
 
 
 class UploadResolverDef(BaseModel):
-    resolver: Optional[Callable] = None
+    resolver: Callable | None = None
     """Optional custom resolver function for the upload"""
     upload: Callable
     """Upload handling function, default dara.core.interactivity.any_data_variable.upload"""

dara/core/cli.py

@@ -19,7 +19,6 @@ import logging
 import os
 import pathlib
 import subprocess
-from typing import List, Optional
 
 import uvicorn
 
@@ -69,19 +68,19 @@ def start(
     reload: bool,
     enable_hmr: bool,
     production: bool,
-    config: Optional[str],
-    port: Optional[int],
-    metrics_port: Optional[int],
+    config: str | None,
+    port: int | None,
+    metrics_port: int | None,
     disable_metrics: bool,
     host: str,
     rebuild: bool,
     require_sso: bool,
     docker: bool,
-    debug: Optional[str],
-    log: Optional[str],
-    reload_dir: Optional[List[str]],
+    debug: str | None,
+    log: str | None,
+    reload_dir: list[str] | None,
     skip_jsbuild: bool,
-    base_url: Optional[str],
+    base_url: str | None,
 ):
     if config is None:
         folder_name = os.path.basename(os.getcwd()).replace('-', '_')