dara-core 1.15.7__py3-none-any.whl → 1.16.0__py3-none-any.whl

dara/core/__init__.py

@@ -14,35 +14,16 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 """
-
-from __future__ import annotations
-
 from importlib.metadata import version
 
-from dara.core.base_definitions import Cache, CacheType
+from pydantic import BaseModel
+
+from dara.core.base_definitions import *
 from dara.core.configuration import ConfigurationBuilder
 from dara.core.css import CSSProperties, get_icon
-from dara.core.definitions import ComponentInstance, ErrorHandlingConfig, template
-from dara.core.interactivity import (
-    DataVariable,
-    DerivedDataVariable,
-    DerivedVariable,
-    DownloadContent,
-    DownloadContentImpl,
-    DownloadVariable,
-    NavigateTo,
-    NavigateToImpl,
-    Notify,
-    ResetVariables,
-    SideEffect,
-    TriggerVariable,
-    UpdateVariable,
-    UpdateVariableImpl,
-    UrlVariable,
-    Variable,
-    action,
-)
-from dara.core.visual.components import Fallback, For
+from dara.core.definitions import *
+from dara.core.interactivity import *
+from dara.core.visual.components import Fallback
 from dara.core.visual.dynamic_component import py_component
 from dara.core.visual.progress_updater import ProgressUpdater, track_progress
 
@@ -75,11 +56,19 @@ __all__ = [
     'ProgressUpdater',
     'track_progress',
     'ComponentInstance',
+    'StyledComponentInstance',
     'ErrorHandlingConfig',
-    'template',
-    'For',
     'Fallback',
     'UpdateVariableImpl',
     'DownloadContentImpl',
     'NavigateToImpl',
 ]
+
+for symbol in list(globals().values()):
+    try:
+        if issubclass(symbol, BaseModel) and symbol is not BaseModel:
+            symbol.model_rebuild()
+    except Exception as e:
+        from dara.core.logging import dev_logger
+
+        dev_logger.warning(f'Error rebuilding model "{symbol}": {e}')

dara/core/auth/base.py

@@ -19,7 +19,7 @@ import abc
 from typing import Any, ClassVar, Dict, Union
 
 from fastapi import HTTPException, Response
-from pydantic import BaseModel
+from pydantic import BaseModel, model_serializer
 from typing_extensions import TypedDict
 
 from dara.core.auth.definitions import (
@@ -59,7 +59,8 @@ class AuthComponentConfig(BaseModel):
     extra: Dict[str, AuthComponent] = {}
     """Extra components, map of route -> component"""
 
-    def dict(self, *args, **kwargs):
+    @model_serializer()
+    def ser_model(self) -> dict:
         return {'login': self.login, 'logout': self.logout, **self.extra}
 
 

dara/core/auth/definitions.py

@@ -44,9 +44,6 @@ class TokenData(BaseModel):
     id_token: Optional[str] = None
     groups: Optional[List[str]] = []
 
-    class Config:
-        smart_union = True
-
 
 class UserData(BaseModel):
     """

dara/core/auth/utils.py

@@ -79,7 +79,7 @@ def sign_jwt(
             identity_email=identity_email,
             groups=groups,
             id_token=id_token,
-        ).dict(),
+        ).model_dump(),
         settings.jwt_secret,
         algorithm=JWT_ALGO,
     )

dara/core/base_definitions.py

@@ -24,58 +24,133 @@ import uuid
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
+    Annotated,
     Any,
     Awaitable,
     Callable,
     ClassVar,
+    Dict,
     List,
     Mapping,
     Optional,
+    Tuple,
     Union,
+    get_args,
+    get_origin,
 )
 
 import anyio
 from anyio.streams.memory import MemoryObjectSendStream
-from pydantic import BaseModel, Field
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    SerializeAsAny,
+    SerializerFunctionWrapHandler,
+    model_serializer,
+)
+from pydantic._internal._model_construction import ModelMetaclass
 
 if TYPE_CHECKING:
     from dara.core.interactivity.actions import ActionCtx
 
 
-class DaraBaseModel(BaseModel):
+def annotation_has_base_model(typ: Any) -> bool:
+    """
+    Check whether the given value is of the given type.
+
+    Handles Union and List types.
     """
-    Custom BaseModel which handles TemplateMarkers.
-    If TemplateMarkers are present, validation is skipped.
+    try:
+        type_args = get_args(typ)
+        if len(type_args) > 0:
+            return any(annotation_has_base_model(arg) for arg in type_args)
+    except:   # pylint: disable=bare-except
+        # canot get arguments, should be a simple type
+        pass
+
+    # Handle simple types
+    return typ is BaseModel or issubclass(typ, BaseModel)
+
+
+# This reverts v1->v2 change to make any BaseModel field duck-type serializable.
+# It works by adding SerializeAsAny to all fields of the model.
+# See https://github.com/pydantic/pydantic/issues/6381
+class SerializeAsAnyMeta(ModelMetaclass):
+    def __new__(
+        self, name: str, bases: Tuple[type], namespaces: Dict[str, Any], **kwargs
+    ):   # pylint: disable=bad-mcs-classmethod-argument
+        annotations: dict = namespaces.get('__annotations__', {}).copy()
+
+        for base in bases:
+            for base_ in base.__mro__:
+                if base_ is BaseModel:
+                    annotations.update(base_.__annotations__)
+
+        for field, annotation in annotations.items():
+            if not field.startswith('__'):
+                # Wrapping `ClassVar`s in `SerializeAsAny` breaks pydantic behaviour of making `ClassVar` fields
+                # accessible via the class itself
+                # NOTE: the annotation can be a string due to future annotations
+                if isinstance(annotation, str) or annotation is ClassVar:
+                    continue
+                if annotation_has_base_model(annotation):
+                    annotations[field] = SerializeAsAny[annotation]   # type: ignore
+
+        namespaces['__annotations__'] = annotations
+
+        return super().__new__(self, name, bases, namespaces, **kwargs)
+
+
+class DaraBaseModel(BaseModel, metaclass=SerializeAsAnyMeta):
+    """
+    Custom BaseModel for dara internals.
     """
 
-    class Config:
-        smart_union = True
-        extra = 'forbid'
+    model_config = ConfigDict(extra='forbid')
 
-    def __init__(self, *args, **kwargs):
-        has_template_var_marker = any(isinstance(arg, TemplateMarker) for arg in args) or any(
-            isinstance(value, TemplateMarker) for value in kwargs.values()
+    @classmethod
+    def model_rebuild(
+        cls, *, force: bool = False, raise_errors: bool = True, _parent_namespace_depth: int = 2, _types_namespace=None
+    ) -> bool | None:
+        """
+        Rebuild the model to re-apply the SerializeAsAny wrapper once we've resolved the string annotations
+        """
+        # rebuild once to get all types sorted
+        super().model_rebuild(
+            force=force,
+            raise_errors=raise_errors,
+            _parent_namespace_depth=_parent_namespace_depth + 1,
+            _types_namespace=_types_namespace,
         )
 
-        if has_template_var_marker:
-            # Imitate pydantic's BaseModel.__init__ but avoid validation
-            values = {}
-            fields_set = set()
-            _missing = object()
-
-            for name, field in self.__class__.__fields__.items():
-                value = kwargs.get(field.alias, _missing)
-                if value is _missing:
-                    value = field.get_default()
-                else:
-                    fields_set.add(name)
-                values[name] = value
-
-            object.__setattr__(self, '__dict__', values)
-            object.__setattr__(self, '__fields_set__', fields_set)
-            self._init_private_attributes()
-        else:
-            super().__init__(*args, **kwargs)
+        # Re-apply the SerializeAsAny wrapper to any fields that were originally strings
+        for field_info in cls.__pydantic_fields__.values():
+            # if the original was a str, we've just resolved it so we can re-apply the SerializeAsAny wrapper
+            if (
+                field_info.annotation is not SerializeAsAny
+                and field_info.annotation is not ClassVar
+                and annotation_has_base_model(field_info.annotation)
+            ):
+                # Skip if it has metadata that is already annotated with SerializeAsAny
+                if any(isinstance(x, SerializeAsAny) for x in field_info.metadata):   # type: ignore
+                    continue
+                # Skip if the type is already annotated with SerializeAsAny
+                if get_origin(field_info.annotation) is Annotated and any(
+                    isinstance(arg, SerializeAsAny) for arg in field_info.annotation.__metadata__  # type: ignore
+                ):
+                    continue
+
+                field_info.annotation = SerializeAsAny[field_info.annotation]   # type: ignore
+                field_info.metadata = list(field_info.annotation.__metadata__)   # type: ignore
+
+        # Rebuild again with force to ensure we rebuild the schema with new annotations
+        return super().model_rebuild(
+            force=True,
+            raise_errors=raise_errors,
+            _parent_namespace_depth=_parent_namespace_depth + 1,
+            _types_namespace=_types_namespace,
+        )
 
 
 class CacheType(str, Enum):
@@ -115,7 +190,7 @@ class LruCachePolicy(BaseCachePolicy):
         depending on `cache_type` set in the policy
     """
 
-    policy: str = Field(const=True, default='lru')
+    policy: str = Field(default='lru', frozen=True)
     max_size: int = 10
 
 
@@ -124,8 +199,8 @@ class MostRecentCachePolicy(LruCachePolicy):
     Most recent cache policy. Only keeps the most recent item in the cache.
     """
 
-    policy: str = Field(const=True, default='most-recent')
-    max_size: int = Field(const=True, default=1)
+    policy: str = Field(default='most-recent', frozen=True)
+    max_size: int = Field(default=1, frozen=True)
 
 
 class KeepAllCachePolicy(BaseCachePolicy):
@@ -135,7 +210,7 @@ class KeepAllCachePolicy(BaseCachePolicy):
     Should be used with caution as it can lead to memory leaks.
     """
 
-    policy: str = Field(const=True, default='keep-all')
+    policy: str = Field(default='keep-all', frozen=True)
 
 
 class TTLCachePolicy(BaseCachePolicy):
@@ -146,7 +221,7 @@ class TTLCachePolicy(BaseCachePolicy):
     :param ttl: time-to-live in seconds
     """
 
-    policy: str = Field(const=True, default='ttl')
+    policy: str = Field(default='ttl', frozen=True)
     ttl: int
 
 
@@ -218,7 +293,7 @@ class CachedRegistryEntry(BaseModel):
     via the cache policy.
     """
 
-    cache: Optional[BaseCachePolicy]
+    cache: Optional[BaseCachePolicy] = None
     uid: str
 
     def to_store_key(self):
@@ -242,17 +317,15 @@ class TaskProgressUpdate(BaseTaskMessage):
 
 class TaskResult(BaseTaskMessage):
     result: Any
-    cache_key: Optional[str]
-    reg_entry: Optional[CachedRegistryEntry]
+    cache_key: Optional[str] = None
+    reg_entry: Optional[CachedRegistryEntry] = None
 
 
 class TaskError(BaseTaskMessage):
     error: BaseException
-    cache_key: Optional[str]
-    reg_entry: Optional[CachedRegistryEntry]
-
-    class Config:
-        arbitrary_types_allowed = True
+    cache_key: Optional[str] = None
+    reg_entry: Optional[CachedRegistryEntry] = None
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 TaskMessage = Union[TaskProgressUpdate, TaskResult, TaskError]
@@ -288,9 +361,6 @@ class PendingTask(BaseTask):
     Is associated to an underlying task definition.
     """
 
-    cache_key: None = None
-    reg_entry: None = None
-
     def __init__(self, task_id: str, task_def: BaseTask, ws_channel: Optional[str] = None):
         self.task_id = task_id
         self.task_def = task_def
@@ -431,7 +501,7 @@ class AnnotatedAction(BaseModel):
         # pylint: disable-next=import-error, import-outside-toplevel
         from dara.core.interactivity.plain_variable import Variable
 
-        self.update_forward_refs(Variable=Variable)
+        self.model_rebuild()
         super().__init__(**data, loading=Variable(False))
 
 
@@ -456,11 +526,12 @@ class ActionImpl(DaraBaseModel):
         """
         await ctx._push_action(self)
 
-    def dict(self, *args, **kwargs):
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
         """
         This structure is expected by the frontend, must match the JS implementation
         """
-        dict_form = super().dict(*args, **kwargs)
+        dict_form = nxt(self)
         dict_form['name'] = self.__class__.py_name or self.__class__.__name__
         dict_form['__typename'] = 'ActionImpl'
         return dict_form
@@ -497,14 +568,14 @@ class ActionDef(BaseModel):
 
     name: str
     py_module: str
-    js_module: Optional[str]
+    js_module: Optional[str] = None
 
 
 class ActionResolverDef(BaseModel):
     uid: str
     """Unique id of the action definition"""
 
-    resolver: Optional[Callable]
+    resolver: Optional[Callable] = None
     """Resolver function for the action"""
 
     execute_action: Callable[..., Awaitable[Any]]
@@ -512,7 +583,7 @@ class ActionResolverDef(BaseModel):
 
 
 class UploadResolverDef(BaseModel):
-    resolver: Optional[Callable]
+    resolver: Optional[Callable] = None
     """Optional custom resolver function for the upload"""
     upload: Callable
     """Upload handling function, default dara.core.interactivity.any_data_variable.upload"""
@@ -523,17 +594,3 @@ class ComponentType(Enum):
 
     JS = 'js'
     PY = 'py'
-
-
-class TemplateMarker(BaseModel):
-    """
-    Template marker used to mark fields that should be replaced with a data field on the client before being rendered.
-    See dara_core.definitions.template for details
-    """
-
-    field_name: str
-
-    def dict(self, *args, **kwargs):
-        dict_form = super().dict(*args, **kwargs)
-        dict_form['__typename'] = 'TemplateMarker'
-        return dict_form

dara/core/configuration.py

@@ -33,7 +33,7 @@ from typing import (
 )
 
 from fastapi.middleware import Middleware
-from pydantic.generics import GenericModel
+from pydantic import BaseModel, ConfigDict
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from dara.core.auth.base import BaseAuthConfig
@@ -65,7 +65,7 @@ from dara.core.visual.components import RawString
 from dara.core.visual.themes import BaseTheme, ThemeDef
 
 
-class Configuration(GenericModel):
+class Configuration(BaseModel):
     """Definition of the main framework configuration"""
 
     auth_config: BaseAuthConfig
@@ -85,7 +85,7 @@ class Configuration(GenericModel):
     static_files_dir: str
     package_tag_processors: List[Callable[[Dict[str, List[str]]], Dict[str, List[str]]]]
     template_extra_js: str
-    task_module: Optional[str]
+    task_module: Optional[str] = None
     template: str
     template_renderers: Dict[str, Callable[..., Template]]
     theme: Union[BaseTheme, str]
@@ -93,10 +93,7 @@ class Configuration(GenericModel):
     ws_handlers: Dict[str, Callable[[str, Any], Any]]
     encoders: Dict[Type[Any], Encoder]
     middlewares: List[Middleware]
-
-    class Config:
-        extra = 'forbid'
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)
 
     def get_package_map(self) -> Dict[str, str]:
         """
@@ -117,7 +114,7 @@ class Configuration(GenericModel):
                 packages[act_def.py_module] = act_def.js_module
 
         # Handle auth components
-        for comp in self.auth_config.component_config.dict().values():
+        for comp in self.auth_config.component_config.model_dump().values():
             packages[comp['py_module']] = comp['js_module']
 
         return packages

dara/core/defaults.py

@@ -39,8 +39,6 @@ from dara.core.visual.components import (
     DynamicComponent,
     DynamicComponentDef,
     Fallback,
-    For,
-    ForDef,
     Menu,
     MenuDef,
     ProgressTracker,
@@ -79,7 +77,6 @@ CORE_COMPONENTS: Dict[str, ComponentTypeAnnotation] = {
     TopBarFrame.__name__: TopBarFrameDef,
     Fallback.Default.py_component: DefaultFallbackDef,
     Fallback.Row.py_component: RowFallbackDef,
-    For.__name__: ForDef,
 }
 
 # These actions are provided by the core JS of this module