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

dara/core/definitions.py

@@ -25,8 +25,8 @@ from typing import (
     Awaitable,
     Callable,
     ClassVar,
-    Generic,
     List,
+    Literal,
     Mapping,
     Optional,
     Protocol,
@@ -38,15 +38,16 @@ from typing import (
 
 from fastapi.encoders import jsonable_encoder
 from fastapi.params import Depends
-from pydantic import BaseModel, Field, validator
-from pydantic.generics import GenericModel
-
-from dara.core.base_definitions import (
-    Action,
-    ComponentType,
-    DaraBaseModel,
-    TemplateMarker,
+from pydantic import (
+    ConfigDict,
+    Field,
+    SerializerFunctionWrapHandler,
+    field_validator,
+    model_serializer,
 )
+
+from dara.core.base_definitions import Action, ComponentType
+from dara.core.base_definitions import DaraBaseModel as BaseModel
 from dara.core.css import CSSProperties
 from dara.core.interactivity import AnyVariable
 
@@ -62,7 +63,7 @@ class HttpMethod(Enum):
 
 
 class Session(BaseModel):
-    session_id: Optional[str]
+    session_id: Optional[str] = None
 
 
 DEFAULT_ERROR_TITLE = 'Unexpected error occurred'
@@ -79,74 +80,25 @@ class ErrorHandlingConfig(BaseModel):
     raw_css: Optional[Union[CSSProperties, dict, str]] = None
     """Raw styling to apply to the displayed error boundary"""
 
-    def dict(self, *args, **kwargs):
-        result = super().dict(*args, **kwargs)
+    def model_dump(self, *args, **kwargs):
+        result = super().model_dump(*args, **kwargs)
 
         # Exclude raw_css if not set
         if 'raw_css' in result and result.get('raw_css') is None:
             result.pop('raw_css')
         elif isinstance(self.raw_css, CSSProperties):
             # If it's an instance of CSSProperties, serialize but exclude none
-            result['raw_css'] = self.raw_css.dict(exclude_none=True)
+            result['raw_css'] = self.raw_css.model_dump(exclude_none=True)
 
         return result
 
 
-class TemplateMarkerCreator:
-    """
-    Creates a TemplateMarker instance for a given field name when accessing
-    any attribute on the instance. Should not be used standalone, it is injected
-    into function parameters when using the @template decorator.
-
-    Example
-
-    ```python
-    from dara.core.definitions import TemplateMarkerCreator
-
-    creator = TemplateMarkerCreator()
-    creator.foo
-    # <TemplateMarker field_name='foo'>
-    ```
-    """
-
-    def __getattribute__(self, __name: str) -> Any:
-        return TemplateMarker(field_name=__name)
-
-
-class BaseFallback(DaraBaseModel):
-    suspend_render: Union[bool, int] = 200
-    """
-    :param suspend_render: bool or int, optional
-        Determines the suspense behavior of the component during state updates.
-
-        - If True, the component will always use suspense during state updates.
-          This means the component will suspend rendering and show a fallback UI until the new state is ready.
-
-        - If False, the component will always show the previous state while loading the new state.
-          This means the component will never suspend during state updates. The fallback UI will only
-          be shown on the first render.
-
-        - If a positive integer (default is 200), this denotes the threshold in milliseconds.
-          The component will show the previous state while loading the new state,
-          but will suspend and show a fallback UI after the given timeout if the new state is not ready.
-    """
-
-    @validator('suspend_render')
-    @classmethod
-    def validate_suspend_render(cls, value):
-        if isinstance(value, int):
-            if value < 0:
-                raise ValueError('suspend_render must be a positive integer')
-
-        return value
-
-
-class ComponentInstance(DaraBaseModel):
+class ComponentInstance(BaseModel):
     """
     Definition of a Component Instance
     """
 
-    uid: Optional[str] = None
+    uid: Optional[str] = Field(default_factory=lambda: str(uuid.uuid4()))
 
     js_module: ClassVar[Optional[str]] = None
     """
@@ -191,9 +143,6 @@ class ComponentInstance(DaraBaseModel):
     ```
     """
 
-    templated: bool = False
-    """Whether the component is templated, created by the @template decorator"""
-
     track_progress: Optional[bool] = False
     """Whether to use ProgressTracker to display progress updates from a task the component is subscribed to"""
 
@@ -219,18 +168,10 @@ class ComponentInstance(DaraBaseModel):
     This has no runtime effect and are intended to help identify components with human-readable names in the serialized trees, not in the DOM
     """
 
-    def __init__(self, *args, **kwargs):
-        uid = kwargs.get('uid', None)
-        if uid is None:
-            uid = str(uuid.uuid4())
-            kwargs = {**kwargs, 'uid': uid}
-
-        super().__init__(*args, **kwargs)
-
     def __repr__(self):
         return '__dara__' + json.dumps(jsonable_encoder(self))
 
-    @validator('raw_css', pre=True)
+    @field_validator('raw_css', mode='before')
     @classmethod
     def parse_css(cls, css: Optional[Union[CSSProperties, dict, str]]):
         # If it's a plain dict, change kebab case to camel case
@@ -244,8 +185,14 @@ class ComponentInstance(DaraBaseModel):
 
         return css
 
-    def dict(self, *args, **kwargs):
-        props = super().dict(*args, **kwargs)
+    @classmethod
+    def isinstance(cls, obj: Any) -> bool:
+        return isinstance(obj, cls)
+
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        props = nxt(self)
+
         props.pop('uid')
 
         # Exclude raw_css if not set
@@ -253,7 +200,7 @@ class ComponentInstance(DaraBaseModel):
             props.pop('raw_css')
         elif isinstance(self.raw_css, CSSProperties):
             # If it's an instance of CSSProperties, serialize but exclude none
-            props['raw_css'] = self.raw_css.dict(exclude_none=True)
+            props['raw_css'] = self.raw_css.model_dump(exclude_none=True)
 
         # Exclude track_progress if not set
         if 'track_progress' in props and props.get('track_progress') is False:
@@ -263,10 +210,6 @@ class ComponentInstance(DaraBaseModel):
         if 'error_handler' in props and props.get('error_handler') is None:
             props.pop('error_handler')
 
-        # Exclude template if not set
-        if 'templated' in props and props.get('templated') is False:
-            props.pop('templated')
-
         # Exclude fallback if not set
         if 'fallback' in props and props.get('fallback') is None:
             props.pop('fallback')
@@ -311,6 +254,26 @@ def discover(outer_obj: DiscoverT) -> DiscoverT:
     return outer_obj
 
 
+AlignItems = Literal[
+    '-moz-initial',
+    'baseline',
+    'center',
+    'end',
+    'flex-end',
+    'flex-start',
+    'inherit',
+    'initial',
+    'normal',
+    'revert',
+    'self-end',
+    'self-start',
+    'start',
+    'stretch',
+    'unset',
+    None,
+]
+
+
 class StyledComponentInstance(ComponentInstance):
     """
     Base class for a component implementing the common styling props
@@ -341,13 +304,13 @@ class StyledComponentInstance(ComponentInstance):
     :param width: the width of the component, can be an number, which will be converted to pixels, or a string
     """
 
-    align: Optional[str] = None
+    align: Optional[AlignItems] = None
     background: Optional[str] = None
     basis: Optional[Union[int, str, bool]] = None
     bold: bool = False
     border: Optional[str] = None
     border_radius: Optional[Union[float, int, str]] = None
-    children: Optional[List[Union[ComponentInstance, TemplateMarker]]] = None
+    children: Optional[List[ComponentInstance]] = None
     color: Optional[str] = None
     font: Optional[str] = None
     font_size: Optional[str] = None
@@ -368,10 +331,7 @@ class StyledComponentInstance(ComponentInstance):
     underline: bool = False
     width: Optional[Union[float, int, str]] = None
 
-    class Config:
-        smart_union = True
-
-    @validator(
+    @field_validator(
         'height',
         'basis',
         'border_radius',
@@ -383,7 +343,7 @@ class StyledComponentInstance(ComponentInstance):
         'min_height',
         'padding',
         'width',
-        pre=True,
+        mode='before',
     )
     @classmethod
     def validate_dimension(cls, value):
@@ -392,7 +352,7 @@ class StyledComponentInstance(ComponentInstance):
 
         return value
 
-    @validator('grow', 'shrink', pre=True)
+    @field_validator('grow', 'shrink', mode='before')
     @classmethod
     def validate_flex(cls, value):
         if isinstance(value, (bool)):
@@ -400,7 +360,7 @@ class StyledComponentInstance(ComponentInstance):
 
         return value
 
-    @validator('children', pre=True)
+    @field_validator('children', mode='before')
     @classmethod
     def validate_children(cls, children):
         # Filter out None children
@@ -409,13 +369,44 @@ class StyledComponentInstance(ComponentInstance):
         return children
 
 
+class BaseFallback(StyledComponentInstance):
+    suspend_render: Union[bool, int] = 200
+    """
+    :param suspend_render: bool or int, optional
+        Determines the suspense behavior of the component during state updates.
+
+        - If True, the component will always use suspense during state updates.
+          This means the component will suspend rendering and show a fallback UI until the new state is ready.
+
+        - If False, the component will always show the previous state while loading the new state.
+          This means the component will never suspend during state updates. The fallback UI will only
+          be shown on the first render.
+
+        - If a positive integer (default is 200), this denotes the threshold in milliseconds.
+          The component will show the previous state while loading the new state,
+          but will suspend and show a fallback UI after the given timeout if the new state is not ready.
+    """
+
+    @field_validator('suspend_render')
+    @classmethod
+    def validate_suspend_render(cls, value):
+        if isinstance(value, int):
+            if value < 0:
+                raise ValueError('suspend_render must be a positive integer')
+
+        return value
+
+
+ComponentInstance.model_rebuild()
+
+
 ComponentInstanceType = Union[ComponentInstance, Callable[..., ComponentInstance]]
 
 
 class JsComponentDef(BaseModel):
     """Definition of a JS Component"""
 
-    js_module: Optional[str]
+    js_module: Optional[str] = None
     """
     JS module where the component implementation lives.
 
@@ -433,13 +424,13 @@ class JsComponentDef(BaseModel):
     name: str
     """Name of the component, must match the Python definition and JS implementation"""
 
-    type: str = Field(default=ComponentType.JS, const=True)
+    type: Literal[ComponentType.JS] = ComponentType.JS
 
 
 class PyComponentDef(BaseModel):
     """Definition of a Python Component"""
 
-    func: Optional[Callable[..., Any]]
+    func: Optional[Callable[..., Any]] = None
     name: str
     dynamic_kwargs: Optional[Mapping[str, AnyVariable]] = None
     fallback: Optional[BaseFallback] = None
@@ -447,126 +438,7 @@ class PyComponentDef(BaseModel):
     render_component: Callable[..., Awaitable[Any]]
     """Handler to render the component. Defaults to dara.core.visual.dynamic_component.render_component"""
 
-    type: str = Field(default=ComponentType.PY, const=True)
-
-
-ComponentT = TypeVar('ComponentT', bound=ComponentInstance)
-
-
-class TemplateComponentDef(GenericModel, Generic[ComponentT]):
-    """
-    Definition of a Template Component, as returned by the @template decorator.
-    When called, executes the decorated function with the marker creator injected and returns a component instance,
-    annotated with `templated=True`.
-    """
-
-    func: Callable[..., ComponentT]
-    name: str
-
-    def __call__(self, *args, **kwds) -> ComponentT:
-        creator = TemplateMarkerCreator()
-        result = self.func(creator, *args, **kwds)
-        result.templated = True
-        return result
-
-
-class template(Generic[ComponentT]):
-    """
-    The @template decorator is used to define reusable components that can be
-    dynamically rendered based on input data. It allows you to create template
-    components with customizable properties that can be injected into certain
-    components equipped to handle such templates.
-
-    Usage:
-    ------
-
-    1. Define a template component using the `@template` decorator and provide a
-    function that accepts a first argument of type `template.Value`.
-    This argument is automatically injected by the decorator, and its name can be
-    chosen by the user. Inside the function, use the first argument to access
-    properties that will be injected into the component when rendered.
-
-    Example:
-
-    ```
-    from dara.core import template
-    from dara_dashboarding_extension import Card, Heading, Text, Button
-
-    @template
-    def ExperimentCard(data: template.Value):
-        return Card(
-            Heading(data.title, level=2),
-            Text(data.description),
-            Button(data.button_text, raw_css={'backgroundColor': data.button_color}),
-            ...
-        )
-    ```
-
-    2. Use the template component in certain components that can handle such
-       templates, like the `For` component.
-
-    Example:
-
-    ```
-    from dara.core import Variable, For
-
-    var = Variable([
-        {
-            'title': 'Experiment 1',
-            'description': 'This is a description of experiment 1',
-            'button_text': 'Run Experiment 1',
-            'button_color': 'red',
-        },
-        ...
-    ])
-
-    For(
-        key_accessor='title',
-        data=var,
-        template=ExperimentCard(),
-    )
-    ```
-
-    The `For` component will dynamically render elements according to the
-    template, using the properties specified by the `template.Value`. As opposed
-    to `py_component`, the decorated component only executes once, when called.
-
-    Note that only certain components are equipped to handle template components,
-    so refer to the component documentation for compatibility information.
-    """
-
-    Value = TemplateMarkerCreator
-    """
-    The `template.Value` is a special class used with the @template decorator to
-    define dynamic properties that will be injected into a template component
-    when it is rendered.
-
-    When defining a template component, use the `template.Value` as the type
-    for the first argument of the function. This argument is automatically
-    injected by the `@template` decorator, and its name can be chosen by the user.
-    Access the properties of the Value within the function to create
-    dynamic components based on the injected data.
-
-    Example usage:
-
-    ```
-    from dara.core import template
-    from dara_dashboarding_extension import Card, Heading, Text, Button
-
-    @template
-    def ExperimentCard(data: template.Value):
-        return Card(
-            Heading(data.title, level=2),
-            Text(data.description),
-            Button(data.button_text, raw_css={'backgroundColor': data.button_color}),
-            ...
-        )
-    ```
-
-    """
-
-    def __new__(cls, func: Callable[..., ComponentT]) -> TemplateComponentDef[ComponentT]:   # type: ignore
-        return TemplateComponentDef(func=func, name=func.__name__)
+    type: Literal[ComponentType.PY] = ComponentType.PY
 
 
 # Helper type annotation for working with components
@@ -593,9 +465,7 @@ class ApiRoute(BaseModel):
     handler: Callable
     method: HttpMethod
     url: str
-
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     def __hash__(self):
         return hash((self.handler, self.method, self.url, tuple(self.dependencies)))
@@ -604,37 +474,31 @@ class ApiRoute(BaseModel):
 class Page(BaseModel):
     """Definition of a Page"""
 
-    icon: Optional[str]
+    icon: Optional[str] = None
     content: ComponentInstanceType
     name: str
     sub_pages: Optional[List['Page']] = []
     url_safe_name: str
-    include_in_menu: Optional[bool]
+    include_in_menu: Optional[bool] = None
     on_load: Optional[Action] = None
-
-    class Config:
-        extra = 'forbid'
-
-
-# This is required by pydantic to support the self referential type subpages.
-Page.update_forward_refs()
+    model_config = ConfigDict(extra='forbid')
 
 
 class TemplateRoute(BaseModel):
     """Definition of a route for the TemplateRouter"""
 
     content: ComponentInstance
-    icon: Optional[str]
+    icon: Optional[str] = None
     name: str
     route: str
-    include_in_menu: Optional[bool]
+    include_in_menu: Optional[bool] = None
     on_load: Optional[Action] = None
 
 
 class TemplateRouterLink(BaseModel):
     """Definition of a link for the TemplateRouter"""
 
-    icon: Optional[str]
+    icon: Optional[str] = None
     name: str
     route: str
 
@@ -645,7 +509,7 @@ class TemplateRouterContent(BaseModel):
     content: ComponentInstance
     route: str
     on_load: Optional[Action] = None
-    name: Optional[str]
+    name: Optional[str] = None
 
 
 class Template(BaseModel):

dara/core/interactivity/__init__.py

@@ -17,6 +17,8 @@ limitations under the License.
 
 from __future__ import annotations
 
+from pydantic import BaseModel
+
 from dara.core.interactivity.actions import (
     DownloadContent,
     DownloadContentImpl,
@@ -41,24 +43,6 @@ from dara.core.interactivity.non_data_variable import NonDataVariable
 from dara.core.interactivity.plain_variable import Variable
 from dara.core.interactivity.url_variable import UrlVariable
 
-# Update references to variable types in these actions
-refs = {
-    'AnyDataVariable': AnyDataVariable,
-    'DerivedVariable': DerivedVariable,
-    'Variable': Variable,
-    'AnyVariable': AnyVariable,
-    'DataVariable': DataVariable,
-    'UrlVariable': UrlVariable,
-}
-DownloadVariable.update_forward_refs(**refs)
-ResetVariables.update_forward_refs(**refs)
-TriggerVariable.update_forward_refs(**refs)
-UpdateVariable.update_forward_refs(**refs)
-UpdateVariableImpl.update_forward_refs(**refs)
-Condition.update_forward_refs(**refs)
-Notify.update_forward_refs(**refs)
-
-
 __all__ = [
     'action',
     'AnyVariable',
@@ -78,7 +62,17 @@ __all__ = [
     'ResetVariables',
     'TriggerVariable',
     'UpdateVariable',
+    'UpdateVariableImpl',
     'SideEffect',
     'Condition',
     'Operator',
 ]
+
+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}')