dara-core 1.21.0__py3-none-any.whl → 1.21.1__py3-none-any.whl

dara/core/internal/tasks.py

@@ -526,7 +526,7 @@ class TaskManager:
         """
         # the result is not deleted, the results are kept in an LRU cache
         # which will clean up older entries
-        return await self.store.get(TaskResultEntry, key=task_id)
+        return await self.store.get(TaskResultEntry, key=task_id, raise_for_missing=True)
 
     async def set_result(self, task_id: str, value: Any):
         """

dara/core/main.py

@@ -20,27 +20,22 @@ import json
 import os
 import sys
 import traceback
-from collections.abc import Mapping
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
 from importlib.util import find_spec
 from inspect import iscoroutine
 from pathlib import Path
-from typing import Annotated, Any, Dict, List, Optional
-from urllib.parse import unquote
+from typing import Optional
 
 from anyio import create_task_group
-from fastapi import Body, Depends, FastAPI, HTTPException, Request
-from fastapi import Path as PathParam
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.encoders import ENCODERS_BY_TYPE, jsonable_encoder
 from fastapi.staticfiles import StaticFiles
 from prometheus_client import start_http_server
-from pydantic import BaseModel, Field
 from starlette.responses import FileResponse
 from starlette.templating import Jinja2Templates, _TemplateResponse
 
 from dara.core.auth import auth_router
-from dara.core.auth.routes import verify_session
 from dara.core.configuration import Configuration, ConfigurationBuilder
 from dara.core.defaults import (
     blank_template,
@@ -51,30 +46,26 @@ from dara.core.defaults import (
 from dara.core.internal.cache_store import CacheStore
 from dara.core.internal.cgroup import get_cpu_count, set_memory_limit
 from dara.core.internal.custom_response import CustomResponse
-from dara.core.internal.devtools import print_stacktrace, send_error_for_session
+from dara.core.internal.devtools import send_error_for_session
 from dara.core.internal.encoder_registry import encoder_registry
-from dara.core.internal.execute_action import CURRENT_ACTION_ID, execute_action_sync
-from dara.core.internal.normalization import NormalizedPayload, denormalize, normalize
 from dara.core.internal.pool import TaskPool
 from dara.core.internal.registries import (
     action_def_registry,
-    action_registry,
     auth_registry,
     component_registry,
     config_registry,
     custom_ws_handlers_registry,
     latest_value_registry,
     sessions_registry,
-    static_kwargs_registry,
     utils_registry,
     websocket_registry,
 )
 from dara.core.internal.registry_lookup import RegistryLookup
-from dara.core.internal.routing import create_router, error_decorator
+from dara.core.internal.routing import core_api_router, create_loader_route, error_decorator
 from dara.core.internal.settings import get_settings
 from dara.core.internal.tasks import TaskManager
 from dara.core.internal.utils import enforce_sso, import_config
-from dara.core.internal.websocket import WS_CHANNEL, WebsocketManager
+from dara.core.internal.websocket import WebsocketManager
 from dara.core.js_tooling.js_utils import (
     BuildCache,
     BuildMode,
@@ -352,9 +343,6 @@ def _start_application(config: Configuration):
         """
         return {'status': 'ok'}
 
-    # Register the core routes of the application
-    core_api_router = create_router(config)
-
     # Start metrics server in a daemon thread
     if os.environ.get('DARA_DISABLE_METRICS') != 'TRUE' and os.environ.get('DARA_TEST_FLAG', None) is None:
         port = int(os.environ.get('DARA_METRICS_PORT', '10000'))
@@ -397,72 +385,9 @@ def _start_application(config: Configuration):
         dev_logger.info('Registering pages:')
         # TODO: convert this to use the logger?
         config.router.print_route_tree()
-        route_map = config.router.to_route_map()
-
-        class ActionPayload(BaseModel):
-            uid: str
-            definition_uid: str
-            values: NormalizedPayload[Mapping[str, Any]]
-
-        class RouteDataRequestBody(BaseModel):
-            action_payloads: List[ActionPayload] = Field(default_factory=list)
-            ws_channel: Optional[str] = None
-            params: Dict[str, str] = Field(default_factory=dict)
-
-        @app.post('/api/core/route/{route_id}', dependencies=[Depends(verify_session)])
-        async def get_route_data(route_id: Annotated[str, PathParam()], body: Annotated[RouteDataRequestBody, Body()]):
-            # unquote route_id since it can be url-encoded
-            route_id = unquote(route_id)
-
-            # TODO: This will accept DV inputs etc and stream those back
-            route_data = route_map.get(route_id)
-
-            if route_data is None:
-                raise HTTPException(status_code=404, detail=f'Route {route_id} not found')
-
-            action_results: Dict[str, Any] = {}
-
-            if len(body.action_payloads) > 0:
-                store: CacheStore = utils_registry.get('Store')
-                task_mgr: TaskManager = utils_registry.get('TaskManager')
-                registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-
-                # Ws channel can be null for top-level layouts rendered above the ws client
-                if body.ws_channel is not None:
-                    WS_CHANNEL.set(body.ws_channel)
-
-                # Run actions in order to guarantee execution order
-                for action_payload in body.action_payloads:
-                    action_def = await registry_mgr.get(action_registry, action_payload.definition_uid)
-                    static_kwargs = await registry_mgr.get(static_kwargs_registry, action_payload.uid)
-
-                    CURRENT_ACTION_ID.set(action_payload.uid)
-                    values = denormalize(action_payload.values.data, action_payload.values.lookup)
-                    try:
-                        action_results[action_payload.uid] = await execute_action_sync(
-                            action_def,
-                            inp={'params': body.params, 'route': route_data.definition},
-                            values=values,
-                            static_kwargs=static_kwargs,
-                            store=store,
-                            task_mgr=task_mgr,
-                        )
-                    except BaseException as e:
-                        assert route_data.definition is not None
-                        route_path = route_data.definition.full_path
-                        action_name = str(action_def.resolver)
-                        raise HTTPException(
-                            status_code=500,
-                            detail={
-                                'error': str(e),
-                                'stacktrace': print_stacktrace(e),
-                                'path': route_path,
-                                'action_name': action_name,
-                            },
-                        ) from e
-
-            normalized_template, lookup = normalize(jsonable_encoder(route_data.content))
-            return {'template': {'data': normalized_template, 'lookup': lookup}, 'action_results': action_results}
+
+        # Add the page data loader route
+        create_loader_route(config, app)
 
         # Catch-all, must add after adding the last api route
         @app.get('/api/{rest_of_path:path}')

dara/core/persistence.py

@@ -415,7 +415,7 @@ class BackendStore(PersistenceStore):
 
             await self.backend.subscribe(_on_value)
 
-    async def write_partial(self, data: Union[List[Dict[str, Any]], Any], notify: bool = True):
+    async def write_partial(self, data: Union[List[Dict[str, Any]], Any], notify: bool = True, in_place: bool = False):
         """
         Apply partial updates to the store using JSON Patch operations or automatic diffing.
 
@@ -424,6 +424,10 @@ class BackendStore(PersistenceStore):
 
         :param data: Either a list of JSON patch operations (RFC 6902) or a full object to diff against current value
         :param notify: whether to broadcast the patches to clients
+        :param in_place: whether to apply the patches in-place or return a new value.
+        When set to True, the value will be mutated when applying the patches rather than deep-cloned.
+        This is recommended when the updated value is large and deep-cloning it can be expensive; however, users should exercise
+        caution when using the option as previous results retrieved from `store.read()` will potentially be mutated, depending on the backend used.
         """
         if self.readonly:
             raise ValueError('Cannot write to a read-only store')
@@ -451,7 +455,7 @@ class BackendStore(PersistenceStore):
 
             # Apply patches to current value
             try:
-                updated_value = jsonpatch.apply_patch(current_value, patches)
+                updated_value = jsonpatch.apply_patch(current_value, patches, in_place=in_place)
             except (jsonpatch.InvalidJsonPatch, jsonpatch.JsonPatchException) as e:
                 raise ValueError(f'Invalid JSON patch operation: {e}') from e
         else:

dara/core/router/__init__.py

@@ -1,4 +1,5 @@
 # ruff: noqa: F403
 from .compat import *
 from .components import *
+from .dependency_graph import *
 from .router import *

dara/core/router/components.py

@@ -51,15 +51,14 @@ class Link(StyledComponentInstance):
     - with `end=True`, be considered inactive because of the missing '123' part
     """
 
-    # TODO: not implemented yet
-    # prefetch: Literal['none', 'intent', 'render', 'viewport'] = 'none'
-    # """
-    # Defines the data and module prefetching behavior for the link.
-    # - none — default, no prefetching
-    # - intent — prefetches when the user hovers or focuses the link
-    # - render — prefetches when the link renders
-    # - viewport — prefetches when the link is in the viewport, very useful for mobile
-    # """
+    # TODO: consider making it True by default in Dara v2
+    prefetch: bool = False
+    """
+    Whether to prefetch the navigation data when user intends to navigate to the link.
+    When set to True, whenever the user hovers or focuses the link, the navigation data will be prefetched
+    and cached for a short period of time to speed up navigation.
+    Defaults to False.
+    """
 
     relative: Literal['route', 'path'] = 'route'
     """
@@ -107,3 +106,38 @@ class Link(StyledComponentInstance):
         if 'children' not in kwargs:
             kwargs['children'] = components
         super().__init__(**kwargs)
+
+
+MenuLinkDef = JsComponentDef(name='MenuLink', js_module='@darajs/core', py_module='dara.core')
+
+
+class MenuLink(Link):
+    """
+    Styled version of Link component, ready to be used with e.g. the built-in SideBarFrame component.
+    Accepts all the same props as the Link component, can be used as a drop-in replacement.
+
+    ```python
+    from dara.core.visual.components import MenuLink, SideBarFrame
+    from dara.core.router import Router, Outlet
+
+    router = Router()
+
+    def RootLayout():
+        routes = router.get_navigable_routes()
+
+        return SideBarFrame(
+            side_bar=Stack(
+                *[MenuLink(Text(path['name']), to=path['path']) for path in routes],
+            ),
+            content=Outlet(),
+        )
+
+    root = router.add_layout(content=RootLayout)
+    ```
+    """
+
+    def __init__(self, *children: ComponentInstance, **kwargs):
+        els = list(children)
+        if 'children' not in kwargs:
+            kwargs['children'] = els
+        super().__init__(**kwargs)

dara/core/router/dependency_graph.py

@@ -0,0 +1,62 @@
+from typing import Dict
+
+from pydantic import BaseModel, Field, SerializeAsAny
+
+from dara.core.definitions import ComponentInstance
+from dara.core.interactivity.derived_variable import DerivedVariable
+from dara.core.visual.dynamic_component import PyComponentInstance
+
+
+class DependencyGraph(BaseModel):
+    """
+    Data structure representing dependencies for derived state on a page
+    """
+
+    derived_variables: SerializeAsAny[Dict[str, DerivedVariable]] = Field(default_factory=dict)
+    """
+    Map of DerivedVariable instances
+    """
+
+    py_components: SerializeAsAny[Dict[str, PyComponentInstance]] = Field(default_factory=dict)
+    """
+    Map of PyComponentInstance instances
+    """
+
+    @staticmethod
+    def from_component(component: ComponentInstance) -> 'DependencyGraph':
+        """
+        Create a DependencyGraph from a ComponentInstance
+        """
+        graph = DependencyGraph()
+        _analyze_component_dependencies(component, graph)
+        return graph
+
+
+def _analyze_component_dependencies(component: ComponentInstance, graph: DependencyGraph) -> None:
+    """
+    Recursively analyze a component tree to build a dependency graph of DerivedVariables and PyComponentInstances.
+    """
+    # The component itself is a PyComponentInstance
+    if isinstance(component, PyComponentInstance):
+        if component.uid not in graph.py_components:
+            graph.py_components[component.uid] = component
+        return
+
+    # otherwise check each field
+    for attr in component.model_fields_set:
+        value = getattr(component, attr, None)
+
+        # Handle encountered variables and py_components
+        if isinstance(value, DerivedVariable) and value.uid not in graph.derived_variables:
+            graph.derived_variables[value.uid] = value
+        elif isinstance(value, PyComponentInstance) and value.uid not in graph.py_components:
+            graph.py_components[value.uid] = value
+        # Recursion cases:
+        # component instances
+        elif isinstance(value, ComponentInstance):
+            _analyze_component_dependencies(value, graph)
+        # component lists
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, ComponentInstance):
+                    _analyze_component_dependencies(item, graph)

dara/core/router/router.py

@@ -20,6 +20,8 @@ from dara.core.definitions import ComponentInstance
 from dara.core.interactivity import Variable
 from dara.core.persistence import PersistenceStore  # noqa: F401
 
+from .dependency_graph import DependencyGraph
+
 # Matches :param or :param? (captures the name without the colon)
 PARAM_REGEX = re.compile(r':([\w-]+)\??')
 
@@ -86,6 +88,7 @@ class RouteData(BaseModel):
     content: Optional[ComponentInstance] = None
     on_load: Optional[Action] = None
     definition: Optional['BaseRoute'] = None
+    dependency_graph: Optional[DependencyGraph] = Field(default=None, exclude=True)
 
 
 class BaseRoute(BaseModel):
@@ -251,8 +254,10 @@ class BaseRoute(BaseModel):
         props['__typename'] = self.__class__.__name__
         props['full_path'] = self.full_path
         props['id'] = quote(self.get_identifier())
-        if not props.get('name'):
-            props['name'] = self.get_name()
+        props['name'] = self.get_name()
+
+        assert self.compiled_data is not None
+        props['dependency_graph'] = self.compiled_data.dependency_graph
         return props
 
 
@@ -484,8 +489,13 @@ class IndexRoute(BaseRoute):
 
     def compile(self):
         super().compile()
+        content = _execute_route_func(self.content, self.full_path)
+
+        # Analyze component dependencies
+        dependency_graph = DependencyGraph.from_component(content)
+
         self.compiled_data = RouteData(
-            content=_execute_route_func(self.content, self.full_path), on_load=self.on_load, definition=self
+            content=content, on_load=self.on_load, definition=self, dependency_graph=dependency_graph
         )
 
 
@@ -505,8 +515,13 @@ class PageRoute(BaseRoute, HasChildRoutes):
 
     def compile(self):
         super().compile()
+        content = _execute_route_func(self.content, self.full_path)
+
+        # Analyze component dependencies
+        dependency_graph = DependencyGraph.from_component(content)
+
         self.compiled_data = RouteData(
-            content=_execute_route_func(self.content, self.full_path), on_load=self.on_load, definition=self
+            content=content, on_load=self.on_load, definition=self, dependency_graph=dependency_graph
         )
         for child in self.children:
             child.compile()
@@ -550,8 +565,12 @@ class LayoutRoute(BaseRoute, HasChildRoutes):
 
     def compile(self):
         super().compile()
+
+        content = _execute_route_func(self.content, self.full_path)
+        dependency_graph = DependencyGraph.from_component(content)
+
         self.compiled_data = RouteData(
-            on_load=self.on_load, content=_execute_route_func(self.content, self.full_path), definition=self
+            on_load=self.on_load, content=content, definition=self, dependency_graph=dependency_graph
         )
         for child in self.children:
             child.compile()