dara-core 1.24.3__py3-none-any.whl → 1.25.1__py3-none-any.whl

dara/core/interactivity/stream_variable.py

@@ -0,0 +1,354 @@
+"""
+Copyright 2023 Impulse Innovations Limited
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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
+
+import asyncio
+import contextlib
+from collections.abc import AsyncGenerator, Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Generic, Literal
+
+from fastapi import Request
+from pydantic import ConfigDict, Field, SerializerFunctionWrapHandler, field_validator, model_serializer
+from typing_extensions import TypeVar
+
+if TYPE_CHECKING:
+    from dara.core.interactivity.loop_variable import LoopVariable
+
+    # Type alias for static type checking
+    NestedKey = str | LoopVariable
+else:
+    # At runtime, use Any to avoid forward reference issues with Pydantic
+    NestedKey = Any
+
+from dara.core.base_definitions import BaseTask
+from dara.core.interactivity.any_variable import AnyVariable
+from dara.core.interactivity.client_variable import ClientVariable
+from dara.core.interactivity.stream_event import ReconnectException, StreamEvent
+from dara.core.internal.cache_store import CacheStore
+from dara.core.internal.tasks import TaskManager
+from dara.core.logging import dev_logger
+
+VariableType = TypeVar('VariableType', default=Any)
+
+
+class StreamVariable(ClientVariable, Generic[VariableType]):
+    """
+    A StreamVariable represents a stream of events that are accumulated on the client.
+
+    It takes an async generator function that yields StreamEvents, and dependencies
+    (other variables). When dependencies change, a new stream is opened. Old streams
+    might be cleaned up when unused to save resources.
+
+    The stream is managed via Server-Sent Events (SSE) and the client handles
+    reconnection automatically with exponential backoff.
+
+    IMPORTANT: Handling Reconnection
+    --------------------------------
+    Stream functions MUST be idempotent - they should produce the correct state even
+    when called multiple times due to reconnection. Streams can disconnect and reconnect
+    at any time (network issues, browser tab suspension, server restarts). Your stream
+    function runs from the beginning on each reconnection.
+
+    Always start with ``StreamEvent.replace()`` (keyed mode) or ``StreamEvent.json_snapshot()``
+    (custom mode) to set the full initial state atomically. This ensures clients always
+    converge to the correct state regardless of when they connect, and avoids a flash of
+    empty content on reconnection.
+
+    Keyed mode (when ``key_accessor`` is set):
+
+    - Items are stored in a dict keyed by the accessor, exposed as a list
+    - Use ``replace()``, ``add()``, ``remove()``, ``clear()`` events
+
+    Custom state mode (no ``key_accessor``):
+
+    - State can be any JSON structure
+    - Use ``json_snapshot()``, ``json_patch()`` events
+
+    Examples
+    --------
+    Keyed event stream (e.g., events with unique IDs):
+
+    ```python
+    from dara.core import StreamVariable, StreamEvent
+
+    async def events_stream(invocation_id: str):
+        # Set initial state atomically (handles reconnection, no flash of empty)
+        initial_events = await api.get_events(invocation_id)
+        yield StreamEvent.replace(*initial_events)
+
+        # Stream new events
+        async for event in api.stream_events(invocation_id):
+            yield StreamEvent.add(event)
+
+    events = StreamVariable(
+        events_stream,
+        variables=[invocation_id_var],
+        key_accessor='id',
+    )
+
+    # Use in template
+    For(items=events, renderer=EventCard(events.list_item))
+    ```
+
+    Custom state with JSON patches:
+
+    ```python
+    async def dashboard_stream(dashboard_id: str):
+        # Set initial state atomically (handles reconnection)
+        current_state = await api.get_dashboard_state(dashboard_id)
+        yield StreamEvent.json_snapshot(current_state)
+
+        async for update in api.stream_updates(dashboard_id):
+            yield StreamEvent.json_patch([
+                {"op": "add", "path": f"/items/{update.id}", "value": update},
+                {"op": "replace", "path": "/count", "value": update.count}
+            ])
+
+    dashboard = StreamVariable(dashboard_stream, variables=[dashboard_id_var])
+    ```
+    """
+
+    __typename: Literal['StreamVariable'] = 'StreamVariable'
+    uid: str
+    variables: list[AnyVariable] = Field(default_factory=list)
+    key_accessor: str | None = None
+    nested: list[NestedKey] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra='forbid')
+
+    @field_validator('variables')
+    @classmethod
+    def validate_variables(cls, variables: list[AnyVariable]) -> list[AnyVariable]:
+        """Validate that variables don't contain unsupported types."""
+        from dara.core.interactivity.derived_variable import DerivedVariable
+        from dara.core.internal.registries import derived_variable_registry
+
+        for v in variables:
+            # Disallow StreamVariable -> StreamVariable dependency
+            if isinstance(v, StreamVariable):
+                raise ValueError(
+                    'StreamVariable cannot depend on another StreamVariable. '
+                    'Compose generators in Python instead. Example:\n\n'
+                    'async def enriched_events(id):\n'
+                    '    async for event in source_stream(id):\n'
+                    '        yield StreamEvent.add(enrich(event))\n\n'
+                    'events = StreamVariable(enriched_events, variables=[id_var])'
+                )
+
+            # Disallow DerivedVariable with run_as_task=True
+            if isinstance(v, DerivedVariable):
+                entry = derived_variable_registry.get(str(v.uid))
+                if entry is not None and entry.run_as_task:
+                    raise ValueError(
+                        'StreamVariable cannot depend on a DerivedVariable with run_as_task=True. '
+                        'Task-based variables resolve asynchronously which is incompatible with '
+                        'streaming. Remove run_as_task=True or compute the value in the stream function.'
+                    )
+
+        return variables
+
+    def __init__(
+        self,
+        func: Callable[..., AsyncGenerator[StreamEvent, None]],
+        variables: list[AnyVariable] | None = None,
+        key_accessor: str | None = None,
+        uid: str | None = None,
+        nested: list[NestedKey] | None = None,
+        **kwargs,
+    ):
+        """
+        Create a new StreamVariable.
+
+        :param func: Async generator function that yields StreamEvents.
+                    The function receives resolved values of `variables` as arguments.
+        :param variables: List of variables whose resolved values are passed to `func`.
+                         When any of these change, a new stream is opened.
+        :param key_accessor: Property path to extract unique ID from items for deduplication.
+                            Required when using StreamEvent.add(). E.g., 'id' or 'data.id'.
+        :param uid: Unique identifier for this variable. Auto-generated if not provided.
+        :param nested: Internal use - tracks nested path for .get() chains.
+        """
+        if variables is None:
+            variables = []
+        if nested is None:
+            nested = []
+
+        super().__init__(
+            uid=uid,
+            variables=variables,
+            key_accessor=key_accessor,
+            nested=nested,
+            **kwargs,
+        )
+
+        # Register with the stream variable registry
+        from dara.core.internal.registries import stream_variable_registry
+
+        stream_variable_registry.register(
+            str(self.uid),
+            StreamVariableRegistryEntry(
+                uid=str(self.uid),
+                func=func,
+                variables=variables,
+                key_accessor=key_accessor,
+            ),
+        )
+
+    def get(self, *keys: NestedKey) -> StreamVariable[Any]:
+        """
+        Access a nested value within the stream's accumulated state.
+
+        This is useful when the stream accumulates complex state (via snapshot/patch)
+        and you want to access a specific part of it.
+
+        Keys can be strings or LoopVariables for dynamic access within a For loop.
+
+        Example::
+
+            dashboard = StreamVariable(dashboard_stream, variables=[id_var])
+
+            # Access nested value
+            Text(dashboard.get('meta', 'count'))
+
+            # Dynamic access using LoopVariable
+            items = Variable([{'id': 'a'}, {'id': 'b'}])
+            For(items=items, renderer=Text(dashboard.get(items.list_item.get('id'))))
+
+        :param keys: One or more keys to traverse into the nested structure.
+                    Can be strings or LoopVariables.
+        :return: A new StreamVariable pointing to the nested path.
+        """
+        from dara.core.interactivity.loop_variable import LoopVariable
+
+        # Preserve LoopVariables as-is, convert other types to strings
+        processed_keys: list[NestedKey] = [k if isinstance(k, LoopVariable) else str(k) for k in keys]
+        return self.model_copy(
+            update={'nested': [*self.nested, *processed_keys]},
+            deep=True,
+        )
+
+    @property
+    def list_item(self):
+        """
+        Get a LoopVariable that represents the current item when iterating.
+
+        This is used with the For component to access the current item in the loop.
+
+        Example::
+
+            For(items=events, renderer=EventCard(events.list_item))
+        """
+        from dara.core.interactivity.loop_variable import LoopVariable
+
+        return LoopVariable()
+
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
+        return {
+            **parent_dict,
+            '__typename': 'StreamVariable',
+            'uid': str(parent_dict['uid']),
+        }
+
+
+@dataclass
+class StreamVariableRegistryEntry:
+    """Registry entry for a StreamVariable."""
+
+    uid: str
+    func: Callable[..., AsyncGenerator[StreamEvent, None]]
+    variables: list[AnyVariable]
+    key_accessor: str | None
+
+
+class StreamVariableModeError(Exception):
+    """Raised when a StreamEvent is used with the wrong mode (keyed vs custom)."""
+
+    pass
+
+
+# Event types that require key_accessor (keyed mode)
+_KEYED_MODE_EVENT_TYPES = {'add', 'remove', 'replace', 'clear'}
+# Event types for custom mode (no key_accessor)
+_CUSTOM_MODE_EVENT_TYPES = {'json_snapshot', 'json_patch'}
+
+
+def _validate_event_mode(event: StreamEvent, key_accessor: str | None) -> None:
+    """
+    Validate that the event type matches the StreamVariable mode.
+
+    Raises StreamVariableModeError if:
+    - Keyed mode event (add/remove/replace/clear) is used without key_accessor
+    - Custom mode event (json_snapshot/json_patch) is used with key_accessor
+    """
+    event_type = event.type.value if hasattr(event.type, 'value') else str(event.type)
+
+    if event_type in _KEYED_MODE_EVENT_TYPES and key_accessor is None:
+        raise StreamVariableModeError(
+            f'StreamEvent.{event_type}() requires key_accessor to be set on StreamVariable. '
+            f"Either set key_accessor='your_id_field' on the StreamVariable, "
+            f'or use StreamEvent.json_snapshot()/json_patch() for custom state mode.'
+        )
+
+    if event_type in _CUSTOM_MODE_EVENT_TYPES and key_accessor is not None:
+        raise StreamVariableModeError(
+            f'StreamEvent.{event_type}() is for custom state mode but key_accessor is set. '
+            f'Either remove key_accessor from StreamVariable, '
+            f'or use StreamEvent.add()/remove()/replace()/clear() for keyed mode.'
+        )
+
+
+async def run_stream(
+    entry: StreamVariableRegistryEntry, request: Request, values: list[Any], store: CacheStore, task_mgr: TaskManager
+):
+    """Run a StreamVariable."""
+    # dynamic import due to circular import
+    from dara.core.internal.dependency_resolution import (
+        resolve_dependency,
+    )
+
+    resolved_values = await asyncio.gather(*[resolve_dependency(v, store, task_mgr) for v in values])
+
+    has_tasks = any(isinstance(v, BaseTask) for v in resolved_values)
+    if has_tasks:
+        raise NotImplementedError('StreamVariable does not support tasks')
+
+    generator = None
+    try:
+        generator = entry.func(*resolved_values)
+        async for event in generator:
+            if await request.is_disconnected():
+                break
+            # Validate event type matches the StreamVariable mode
+            _validate_event_mode(event, entry.key_accessor)
+            yield f'data: {event.model_dump_json()}\n\n'
+    except ReconnectException:
+        yield f'data: {StreamEvent.reconnect().model_dump_json()}\n\n'
+    except StreamVariableModeError as e:
+        dev_logger.error('Stream mode error', error=e)
+        yield f'data: {StreamEvent.error(str(e)).model_dump_json()}\n\n'
+    except Exception as e:
+        dev_logger.error('Stream error', error=e)
+        yield f'data: {StreamEvent.error(str(e)).model_dump_json()}\n\n'
+    finally:
+        # Cleanup: close generator if it's still open
+        if generator is not None:
+            with contextlib.suppress(Exception):
+                await generator.aclose()

dara/core/internal/dependency_resolution.py

@@ -17,6 +17,7 @@ limitations under the License.
 
 from typing import Any, Literal, TypeGuard
 
+from pydantic import BaseModel
 from typing_extensions import TypedDict
 
 from dara.core.base_definitions import BaseTask, PendingTask
@@ -75,16 +76,27 @@ def _resolve_nested(value: Any, nested: list[str] | None) -> Any:
     if not nested or len(nested) == 0:
         return value
 
-    # Not a dict (equivalent to frontend's object check)
-    if value is None or not isinstance(value, dict):
+    # Not a dict/model
+    if value is None or not isinstance(value, (dict, BaseModel)):
         return value
 
     result = value
     for key in nested:
-        # If the key doesn't exist, return None as we're referring to a path which doesn't exist yet
-        if not isinstance(result, dict) or key not in result:
-            return None
-        result = result[key]
+        # Defensive check: LoopVariable should have been resolved by frontend templating
+        if isinstance(key, dict):
+            raise ValueError(
+                'LoopVariable found in nested path during backend resolution. '
+                'This should have been resolved by frontend templating.'
+            )
+        # Can recurse into a dict or a pydantic model
+        if isinstance(result, dict):
+            # Path does not exist, resolve to None
+            if key not in result:
+                return None
+            result = result[key]
+        elif isinstance(result, BaseModel):
+            # fall back to None, if key doesn't exist/is None, we'll skip iterating anyway
+            result = getattr(result, key, None)
 
     return result
 

dara/core/internal/normalization.py

@@ -21,7 +21,6 @@ from typing import (
     Generic,
     TypeGuard,
     TypeVar,
-    cast,
     overload,
 )
 
@@ -57,13 +56,26 @@ class Referrable(TypedDict):
 
 
 class ReferrableWithNested(Referrable):
-    nested: list[str]
+    nested: list[str | dict]  # dict represents serialized LoopVariable
 
 
 class ReferrableWithFilters(Referrable):
     filters: dict
 
 
+def _serialize_nested_key(key: str | dict) -> str:
+    """
+    Serialize a single nested key for identifier computation.
+
+    Handles both string keys and LoopVariable dicts.
+    """
+    if isinstance(key, dict) and key.get('__typename') == 'LoopVariable':
+        # Format: LoopVar:uid:nested.joined
+        loop_nested = ','.join(key.get('nested', []))
+        return f'LoopVar:{key["uid"]}:{loop_nested}'
+    return str(key)
+
+
 def _get_identifier(obj: Referrable) -> str:
     """
     Get a unique identifier from a 'referrable' object
@@ -74,7 +86,9 @@ def _get_identifier(obj: Referrable) -> str:
 
     # If it's a Variable with 'nested', the property should be included in the identifier
     if _is_referrable_nested(obj) and len(obj['nested']) > 0:
-        nested = ','.join(cast(list[str], obj['nested']))
+        # Handle mixed string/LoopVariable nested
+        nested_parts = [_serialize_nested_key(k) for k in obj['nested']]
+        nested = ','.join(nested_parts)
         identifier = f'{identifier}:{nested}'
 
     return identifier

dara/core/internal/registries.py

@@ -32,6 +32,7 @@ from dara.core.interactivity.derived_variable import (
     LatestValueRegistryEntry,
 )
 from dara.core.interactivity.server_variable import ServerVariableRegistryEntry
+from dara.core.interactivity.stream_variable import StreamVariableRegistryEntry
 from dara.core.internal.download import DownloadDataEntry
 from dara.core.internal.registry import Registry, RegistryType
 from dara.core.internal.websocket import CustomClientMessagePayload
@@ -75,3 +76,6 @@ backend_store_registry = Registry[BackendStoreEntry](RegistryType.BACKEND_STORE,
 
 download_code_registry = Registry[DownloadDataEntry](RegistryType.DOWNLOAD_CODE, allow_duplicates=False)
 """map of download codes -> download data entry, used only to allow overriding download code behaviour via RegistryLookup"""
+
+stream_variable_registry = Registry[StreamVariableRegistryEntry](RegistryType.STREAM_VARIABLE, allow_duplicates=False)
+"""map of stream variable uid -> stream variable registry entry"""

dara/core/internal/registry.py

@@ -45,6 +45,7 @@ class RegistryType(str, Enum):
     CUSTOM_WS_HANDLERS = 'Custom WS handlers'
     BACKEND_STORE = 'Backend Store'
     DOWNLOAD_CODE = 'Download Code'
+    STREAM_VARIABLE = 'StreamVariable'
 
 
 class Registry(Generic[T]):

dara/core/internal/routing.py

@@ -39,6 +39,7 @@ from fastapi import (
     HTTPException,
     Path,
     Query,
+    Request,
     Response,
     UploadFile,
 )
@@ -56,6 +57,8 @@ from dara.core.interactivity.actions import ACTION_CONTEXT
 from dara.core.interactivity.any_data_variable import upload
 from dara.core.interactivity.filtering import FilterQuery, Pagination
 from dara.core.interactivity.server_variable import ServerVariable
+from dara.core.interactivity.stream_utils import track_stream
+from dara.core.interactivity.stream_variable import run_stream
 from dara.core.internal.cache_store import CacheStore
 from dara.core.internal.devtools import print_stacktrace
 from dara.core.internal.download import DownloadRegistryEntry
@@ -72,6 +75,7 @@ from dara.core.internal.registries import (
     latest_value_registry,
     server_variable_registry,
     static_kwargs_registry,
+    stream_variable_registry,
     upload_resolver_registry,
     utils_registry,
 )
@@ -508,6 +512,57 @@ async def get_version():
 core_api_router.add_api_websocket_route('/ws', ws_handler)
 
 
+class StreamRequestBody(BaseModel):
+    """Request body for StreamVariable SSE endpoint."""
+
+    values: NormalizedPayload[list[Any]]
+    """Normalized payload of resolved variable values to pass to the stream generator."""
+
+
+@core_api_router.post('/stream/{stream_uid}', dependencies=[Depends(verify_session)])
+async def stream_endpoint(
+    request: Request,
+    stream_uid: str,
+    body: StreamRequestBody,
+):
+    """
+    SSE endpoint for StreamVariable.
+
+    Opens a Server-Sent Events connection and streams events from the
+    StreamVariable's async generator.
+
+    :param stream_uid: The UID of the StreamVariable
+    :param body: Request body containing resolved variable values
+    """
+    registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
+    store: CacheStore = utils_registry.get('Store')
+    task_mgr: TaskManager = utils_registry.get('TaskManager')
+
+    try:
+        entry = await registry_mgr.get(stream_variable_registry, stream_uid)
+    except (KeyError, ValueError) as err:
+        raise HTTPException(status_code=404, detail=f'StreamVariable {stream_uid} not found') from err
+
+    # Denormalize the values (resolve any nested structures)
+    values = denormalize(body.values.data, body.values.lookup)
+
+    @track_stream
+    async def stream():
+        async for event in run_stream(entry, request, values, store, task_mgr):
+            yield event
+
+    return StreamingResponse(
+        stream(),
+        media_type='text/event-stream',
+        headers={
+            'Cache-Control': 'no-cache',
+            'X-Accel-Buffering': 'no',
+            'Connection': 'keep-alive',
+            'Content-Type': 'text/event-stream',
+        },
+    )
+
+
 class ActionPayload(BaseModel):
     uid: str
     definition_uid: str

dara/core/main.py

@@ -44,6 +44,7 @@ from dara.core.defaults import (
     top_template,
 )
 from dara.core.definitions import JsComponentDef
+from dara.core.interactivity.stream_utils import setup_signal_handlers
 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
@@ -136,6 +137,7 @@ def _start_application(config: Configuration):
     @asynccontextmanager
     async def lifespan(app: FastAPI):
         # STARTUP
+        setup_signal_handlers()
 
         # Retrieve the existing Store instance for the application
         # Store must exist before the app starts as instantiating e.g. Variables

dara/core/router/dependency_graph.py

@@ -4,6 +4,14 @@ from dara.core.definitions import ComponentInstance
 from dara.core.interactivity.derived_variable import DerivedVariable
 from dara.core.visual.dynamic_component import PyComponentInstance
 
+# Control flow components have conditional children that shouldn't be preloaded
+# since only one branch will actually render at runtime
+CONTROL_FLOW_SKIP_ATTRS: dict[str, set[str]] = {
+    'If': {'true_children', 'false_children'},
+    'Match': {'when', 'default'},
+    'For': {'renderer', 'placeholder'},
+}
+
 
 class DependencyGraph(BaseModel):
     """
@@ -33,6 +41,9 @@ class DependencyGraph(BaseModel):
 def _analyze_component_dependencies(component: ComponentInstance, graph: DependencyGraph) -> None:
     """
     Recursively analyze a component tree to build a dependency graph of DerivedVariables and PyComponentInstances.
+
+    Note: Control flow components (If, Match, For) are treated as boundaries - their conditional
+    child properties are not recursed into since only one branch will render at runtime.
     """
     try:
         from dara.components import Table
@@ -45,8 +56,15 @@ def _analyze_component_dependencies(component: ComponentInstance, graph: Depende
             graph.py_components[component.uid] = component
         return
 
+    # Get properties to skip for control flow components
+    component_name = type(component).__name__
+    skip_attrs = CONTROL_FLOW_SKIP_ATTRS.get(component_name, set())
+
     # otherwise check each field
     for attr in component.model_fields_set:
+        # Skip conditional child properties of control flow components
+        if attr in skip_attrs:
+            continue
         value = getattr(component, attr, None)
 
         # Handle encountered variables and py_components

{dara_core-1.24.3.dist-info → dara_core-1.25.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dara-core
-Version: 1.24.3
+Version: 1.25.1
 Summary: Dara Framework Core
 Home-page: https://dara.causalens.com/
 License: Apache-2.0
@@ -21,10 +21,10 @@ Requires-Dist: cachetools (>=5.0.0)
 Requires-Dist: certifi (>=2024.7.4)
 Requires-Dist: click (>=8.1.3,<9.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
-Requires-Dist: create-dara-app (==1.24.3)
+Requires-Dist: create-dara-app (==1.25.1)
 Requires-Dist: croniter (>=6.0.0,<7.0.0)
 Requires-Dist: cryptography (>=42.0.4)
-Requires-Dist: dara-components (==1.24.3) ; extra == "all"
+Requires-Dist: dara-components (==1.25.1) ; extra == "all"
 Requires-Dist: exceptiongroup (>=1.1.3,<2.0.0)
 Requires-Dist: fastapi (>=0.115.0,<0.121.0)
 Requires-Dist: fastapi_vite_dara (==0.4.0)
@@ -55,7 +55,7 @@ Description-Content-Type: text/markdown
 
 # Dara Application Framework
 
-<img src="https://github.com/causalens/dara/blob/v1.24.3/img/dara_light.svg?raw=true">
+<img src="https://github.com/causalens/dara/blob/v1.25.1/img/dara_light.svg?raw=true">
 
 ![Master tests](https://github.com/causalens/dara/actions/workflows/tests.yml/badge.svg?branch=master)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
@@ -100,7 +100,7 @@ source .venv/bin/activate
 dara start
 ```
 
-![Dara App](https://github.com/causalens/dara/blob/v1.24.3/img/components_gallery.png?raw=true)
+![Dara App](https://github.com/causalens/dara/blob/v1.25.1/img/components_gallery.png?raw=true)
 
 Note: `pip` installation uses [PEP 660](https://peps.python.org/pep-0660/) `pyproject.toml`-based editable installs which require `pip >= 21.3` and `setuptools >= 64.0.0`. You can upgrade both with:
 
@@ -117,9 +117,9 @@ Explore some of our favorite apps - a great way of getting started and getting t
 
 | Dara App                                                                                                 | Description                                                                                                                                                                                                       |
 | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ![Large Language Model](https://github.com/causalens/dara/blob/v1.24.3/img/llm.png?raw=true)              | Demonstrates how to use incorporate a LLM chat box into your decision app to understand model insights                                                                                                            |
-| ![Plot Interactivity](https://github.com/causalens/dara/blob/v1.24.3/img/plot_interactivity.png?raw=true) | Demonstrates how to enable the user to interact with plots, trigger actions based on clicks, mouse movements and other interactions with `Bokeh` or `Plotly` plots                                                |
-| ![Graph Editor](https://github.com/causalens/dara/blob/v1.24.3/img/graph_viewer.png?raw=true)             | Demonstrates how to use the `CausalGraphViewer` component to display your graphs or networks, customising the displayed information through colors and tooltips, and updating the page based on user interaction. |
+| ![Large Language Model](https://github.com/causalens/dara/blob/v1.25.1/img/llm.png?raw=true)              | Demonstrates how to use incorporate a LLM chat box into your decision app to understand model insights                                                                                                            |
+| ![Plot Interactivity](https://github.com/causalens/dara/blob/v1.25.1/img/plot_interactivity.png?raw=true) | Demonstrates how to enable the user to interact with plots, trigger actions based on clicks, mouse movements and other interactions with `Bokeh` or `Plotly` plots                                                |
+| ![Graph Editor](https://github.com/causalens/dara/blob/v1.25.1/img/graph_viewer.png?raw=true)             | Demonstrates how to use the `CausalGraphViewer` component to display your graphs or networks, customising the displayed information through colors and tooltips, and updating the page based on user interaction. |
 
 Check out our [App Gallery](https://dara.causalens.com/gallery) for more inspiration!
 
@@ -146,9 +146,9 @@ And the supporting UI packages and tools.
 - `ui-utils` - miscellaneous utility functions
 - `ui-widgets` - widget components
 
-More information on the repository structure can be found in the [CONTRIBUTING.md](https://github.com/causalens/dara/blob/v1.24.3/CONTRIBUTING.md) file.
+More information on the repository structure can be found in the [CONTRIBUTING.md](https://github.com/causalens/dara/blob/v1.25.1/CONTRIBUTING.md) file.
 
 ## License
 
-Dara is open-source and licensed under the [Apache 2.0 License](https://github.com/causalens/dara/blob/v1.24.3/LICENSE).
+Dara is open-source and licensed under the [Apache 2.0 License](https://github.com/causalens/dara/blob/v1.25.1/LICENSE).