dara-core 1.15.6a1__py3-none-any.whl → 1.16.0__py3-none-any.whl

dara/core/internal/routing.py

@@ -120,7 +120,7 @@ def create_router(config: Configuration):
         values: NormalizedPayload[Mapping[str, Any]]
         """Dynamic kwarg values"""
 
-        input: Any
+        input: Any = None
         """Input from the component"""
 
         ws_channel: str
@@ -194,7 +194,7 @@ def create_router(config: Configuration):
     @core_api_router.get('/config', dependencies=[Depends(verify_session)])
     async def get_config():  # pylint: disable=unused-variable
         return {
-            **config.dict(
+            **config.model_dump(
                 include={
                     'enable_devtools',
                     'live_reload',
@@ -211,7 +211,7 @@ def create_router(config: Configuration):
     @core_api_router.get('/auth-config')
     async def get_auth_config():  # pylint: disable=unused-variable
         return {
-            'auth_components': config.auth_config.component_config.dict(),
+            'auth_components': config.auth_config.component_config.model_dump(),
         }
 
     @core_api_router.get('/components', dependencies=[Depends(verify_session)])
@@ -225,7 +225,7 @@ def create_router(config: Configuration):
             registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
             await registry_mgr.get(component_registry, name)
 
-        return {k: comp.dict(exclude={'func'}) for k, comp in component_registry.get_all().items()}
+        return {k: comp.model_dump(exclude={'func'}) for k, comp in component_registry.get_all().items()}
 
     class ComponentRequestBody(BaseModel):
         # Dynamic kwarg values
@@ -294,9 +294,9 @@ def create_router(config: Configuration):
             )
 
     class DataVariableRequestBody(BaseModel):
-        filters: Optional[FilterQuery]
-        cache_key: Optional[str]
-        ws_channel: Optional[str]
+        filters: Optional[FilterQuery] = None
+        cache_key: Optional[str] = None
+        ws_channel: Optional[str] = None
 
     @core_api_router.post('/data-variable/{uid}', dependencies=[Depends(verify_session)])
     async def get_data_variable(
@@ -366,8 +366,8 @@ def create_router(config: Configuration):
             raise HTTPException(status_code=400, detail=str(e))
 
     class DataVariableCountRequestBody(BaseModel):
-        cache_key: Optional[str]
-        filters: Optional[FilterQuery]
+        cache_key: Optional[str] = None
+        filters: Optional[FilterQuery] = None
 
     @core_api_router.post('/data-variable/{uid}/count', dependencies=[Depends(verify_session)])
     async def get_data_variable_count(uid: str, body: Optional[DataVariableCountRequestBody] = None):
@@ -538,7 +538,7 @@ def create_router(config: Configuration):
     async def get_template(template: str):  # pylint: disable=unused-variable
         try:
             selected_template = template_registry.get(template)
-            normalized_template, lookup = normalize(selected_template.dict())
+            normalized_template, lookup = normalize(jsonable_encoder(selected_template))
             return {'data': normalized_template, 'lookup': lookup}
         except KeyError:
             raise HTTPException(status_code=404, detail=f'Template: {template}, not found in registry')

dara/core/internal/scheduler.py

@@ -23,7 +23,7 @@ from pickle import PicklingError
 from typing import Any, List, Optional, Union
 
 from croniter import croniter
-from pydantic import BaseModel, validator
+from pydantic import BaseModel, field_validator
 
 
 class ScheduledJob(BaseModel):
@@ -174,7 +174,8 @@ class ScheduledJobFactory(BaseModel):
     weekday: Optional[datetime] = None
     run_once: bool
 
-    @validator('weekday', pre=True)
+    @field_validator('weekday', mode='before')
+    @classmethod
     def validate_weekday(cls, weekday: Any) -> datetime:  # pylint: disable=E0213
         if isinstance(weekday, datetime):
             return weekday

dara/core/internal/settings.py

@@ -21,7 +21,7 @@ from secrets import token_hex
 from typing import List, Optional
 
 from dotenv import dotenv_values
-from pydantic import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from dara.core.logging import dev_logger
 
@@ -45,9 +45,7 @@ class Settings(BaseSettings):
     sso_jwt_algo: str = 'ES256'
     sso_verify_audience: bool = False
     sso_extra_audience: Optional[List[str]] = None
-
-    class Config:
-        env_file = '.env'
+    model_config = SettingsConfigDict(env_file='.env')
 
 
 def generate_env_content():

dara/core/internal/store.py

@@ -31,9 +31,6 @@ class Store:
     and resolve at the same time when the value is correctly updated by the first one to request the specific key
     """
 
-    class Config:
-        use_enum_values = True
-
     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.

dara/core/internal/tasks.py

@@ -29,6 +29,7 @@ from anyio import (
 from anyio.abc import TaskGroup
 from anyio.streams.memory import MemoryObjectSendStream
 from exceptiongroup import ExceptionGroup
+from pydantic import ConfigDict
 
 from dara.core.base_definitions import (
     BaseTask,
@@ -58,8 +59,7 @@ class Task(BaseTask):
     Methods for reading from the subprocess and writing to it are also provided.
     """
 
-    class Config:
-        use_enum_values = True
+    model_config = ConfigDict(use_enum_values=True)
 
     def __init__(
         self,

dara/core/internal/websocket.py

@@ -30,12 +30,19 @@ from exceptiongroup import catch
 from fastapi import Query, WebSocketException
 from fastapi.encoders import jsonable_encoder
 from jwt import DecodeError
-from pydantic import BaseModel, Field, parse_obj_as
+from pydantic import (
+    ConfigDict,
+    Field,
+    SerializerFunctionWrapHandler,
+    TypeAdapter,
+    model_serializer,
+)
 from starlette.websockets import WebSocket, WebSocketDisconnect
 
 from dara.core.auth.base import BaseAuthConfig
 from dara.core.auth.definitions import AuthError, TokenData
 from dara.core.auth.utils import decode_token
+from dara.core.base_definitions import DaraBaseModel as BaseModel
 from dara.core.logging import dev_logger, eng_logger
 
 
@@ -47,22 +54,24 @@ class DaraClientMessage(BaseModel):
     An optional chunk_count field can be used to indicate that a message is chunked and what number of messages to expect
     """
 
-    type: Literal['message'] = Field(default='message', const=True)
+    type: Literal['message'] = 'message'
     channel: str
     chunk_count: Optional[int] = None
     message: Any
 
 
 class CustomClientMessagePayload(BaseModel):
+    model_config = ConfigDict(serialize_by_alias=True)
+
     rchan: Optional[str] = Field(default=None, alias='__rchan')
     """Return channel if the message is expected to have a response for"""
 
     kind: str
     data: Any
 
-    def dict(self, *args, **kwargs):
-        # Force by_alias to True to use __rchan name
-        result = super().dict(*args, **{**kwargs, 'by_alias': True})
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        result = nxt(self)
 
         # remove rchan if None
         if '__rchan' in result and result.get('__rchan') is None:
@@ -76,7 +85,7 @@ class CustomClientMessage(BaseModel):
     Represents a custom message sent by the frontend to the backend.
     """
 
-    type: Literal['custom'] = Field(default='custom', const=True)
+    type: Literal['custom'] = 'custom'
     message: CustomClientMessagePayload
 
 
@@ -85,18 +94,17 @@ ClientMessage = Union[DaraClientMessage, CustomClientMessage]
 
 # Server message types
 class ServerMessagePayload(BaseModel):
+    model_config = ConfigDict(serialize_by_alias=True, extra='allow')
+
     rchan: Optional[str] = Field(default=None, alias='__rchan')
     """Return channel if the message is expected to have a response for"""
 
     response_for: Optional[str] = Field(default=None, alias='__response_for')
     """ID of the __rchan included in the original client message if this message is a response to a client message"""
 
-    class Config:
-        extra = 'allow'
-
-    def dict(self, *args, **kwargs):
-        # Force by_alias to True to use __rchan name
-        result = super().dict(*args, **{**kwargs, 'by_alias': True})
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        result = nxt(self)
 
         # remove rchan if None
         if '__rchan' in result and result.get('__rchan') is None:
@@ -119,7 +127,7 @@ class DaraServerMessage(BaseModel):
     Represents a message sent by Dara internals from the backend to the frontend.
     """
 
-    type: Literal['message'] = Field(default='message', const=True)
+    type: Literal['message'] = 'message'
     message: ServerMessagePayload  # exact messages expected by frontend are defined in js/api/websocket.tsx
 
 
@@ -128,7 +136,7 @@ class CustomServerMessage(BaseModel):
     Represents a custom message sent by the backend to the frontend.
     """
 
-    type: Literal['custom'] = Field(default='custom', const=True)
+    type: Literal['custom'] = 'custom'
     message: CustomServerMessagePayload
 
 
@@ -165,8 +173,7 @@ class WebSocketHandler:
     notify when the response is received and the response data.
     """
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     def __init__(self, channel_id: str):
         send_stream, receive_stream = create_memory_object_stream[ServerMessage](math.inf)
@@ -334,9 +341,9 @@ class WebsocketManager:
         :param custom: Whether the message is a custom message
         """
         if custom:
-            return CustomServerMessage(message=CustomServerMessagePayload.parse_obj(payload))
+            return CustomServerMessage(message=CustomServerMessagePayload.model_validate(payload))
         else:
-            return DaraServerMessage(message=ServerMessagePayload.parse_obj(payload))
+            return DaraServerMessage(message=ServerMessagePayload.model_validate(payload))
 
     def create_handler(self, channel_id: str) -> WebSocketHandler:
         """
@@ -534,7 +541,7 @@ async def ws_handler(websocket: WebSocket, token: Optional[str] = Query(default=
                                 eng_logger.error('Error updating token data', error=e)
                         else:
                             try:
-                                parsed_data = parse_obj_as(ClientMessage, data)
+                                parsed_data = TypeAdapter(ClientMessage).validate_python(data)
                                 result = handler.process_client_message(parsed_data)
                                 # Process the resulting coroutine before moving on to next message
                                 if inspect.iscoroutine(result):
@@ -547,6 +554,8 @@ async def ws_handler(websocket: WebSocket, token: Optional[str] = Query(default=
                     Handle messages sent to the client and pass them via the websocket
                     """
                     async for message in handler.receive_stream:
+                        # TODO: This is hacky, should probably be a model_serializer
+                        # on a proper payload type
                         if (
                             message.type == 'message'
                             and isinstance(message.message, ServerMessagePayload)
@@ -556,7 +565,7 @@ async def ws_handler(websocket: WebSocket, token: Optional[str] = Query(default=
                             data = message.message
                             # Reconstruct the payload without the result field
                             message.message = ServerMessagePayload(
-                                **{k: v for k, v in data.dict().items() if k != 'result'}
+                                **{k: v for k, v in data.model_dump().items() if k != 'result'}
                             )
                         await websocket.send_json(jsonable_encoder(message))
 

dara/core/js_tooling/js_utils.py

@@ -451,7 +451,7 @@ def rebuild_js(build_cache: BuildCache, build_diff: BuildCacheDiff = BuildCacheD
     # Store the new build cache
     build_cache_path = os.path.join(build_cache.static_files_dir, BuildCache.FILENAME)
     with open(build_cache_path, 'w+', encoding='utf-8') as f:
-        f.write(build_cache.json(indent=2))
+        f.write(build_cache.model_dump_json(indent=2))
 
 
 def bundle_js(build_cache: BuildCache, copy_js: bool = False):

dara/core/main.py

@@ -264,8 +264,8 @@ def _start_application(config: Configuration):
             dev_logger.debug(
                 'Building JS...',
                 extra={
-                    'New build cache': build_cache.dict(),
-                    'Difference from last cache': build_diff.dict(),
+                    'New build cache': build_cache.model_dump(),
+                    'Difference from last cache': build_diff.model_dump(),
                 },
             )
             rebuild_js(build_cache, build_diff)

dara/core/persistence.py

@@ -6,7 +6,14 @@ from uuid import uuid4
 
 import aiorwlock
 import anyio
-from pydantic import BaseModel, Field, PrivateAttr, validator
+from pydantic import (
+    BaseModel,
+    Field,
+    PrivateAttr,
+    SerializerFunctionWrapHandler,
+    field_validator,
+    model_serializer,
+)
 
 from dara.core.auth.definitions import USER
 from dara.core.internal.utils import run_user_handler
@@ -88,7 +95,7 @@ class FileBackend(PersistenceBackend):
     path: str
     _lock: aiorwlock.RWLock = PrivateAttr(default_factory=aiorwlock.RWLock)
 
-    @validator('path', check_fields=True)
+    @field_validator('path', check_fields=True)
     @classmethod
     def validate_path(cls, value):
         if not os.path.splitext(value)[1] == '.json':
@@ -151,8 +158,9 @@ class PersistenceStore(BaseModel, abc.ABC):
         Initialize the store when connecting to a variable
         """
 
-    def dict(self, *args, **kwargs):
-        parent_dict = super().dict(*args, **kwargs)
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
         parent_dict['__typename'] = self.__class__.__name__
         return parent_dict