dara-core 1.16.19__py3-none-any.whl → 1.16.20a1__py3-none-any.whl

dara/core/defaults.py

@@ -39,6 +39,8 @@ from dara.core.visual.components import (
     DynamicComponent,
     DynamicComponentDef,
     Fallback,
+    For,
+    ForDef,
     Menu,
     MenuDef,
     ProgressTracker,
@@ -77,6 +79,7 @@ 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

dara/core/interactivity/actions.py

@@ -1114,10 +1114,9 @@ class ActionCtx:
 
         ```python
 
-        from dara.core import action, ConfigurationBuilder, DataVariable, DownloadContent
+        from dara.core import action, ConfigurationBuilder, DataVariable
         from dara.components.components import Button, Stack
 
-
         # generate data, alternatively you could load it from a file
         df = pandas.DataFrame(data={'x': [1, 2, 3], 'y':[4, 5, 6]})
         my_var = DataVariable(df)
@@ -1126,18 +1125,14 @@ class ActionCtx:
 
         @action
         async def download_csv(ctx: action.Ctx, my_var_value: DataFrame) -> str:
-            # The file can be created and saved dynamically here, it should then return a string with a path to it
-            # To get the component value, e.g. a select component would return the selected value
-            component_value = ctx.input
-
             # Getting the value of data passed as extras to the action
             data = my_var_value
 
             # save the data to csv
             data.to_csv('<PATH_TO_CSV.csv>')
 
-            # Instruct the frontend to download the file
-            await ctx.download_file(path='<PATH_TO_CSV.csv>', cleanup=False)
+            # Instruct the frontend to download the file and clean up afterwards
+            await ctx.download_file(path='<PATH_TO_CSV.csv>', cleanup=True)
 
 
         def test_page():

dara/core/interactivity/loop_variable.py

@@ -0,0 +1,88 @@
+from typing import List, Optional
+
+from pydantic import Field, SerializerFunctionWrapHandler, model_serializer
+
+from .non_data_variable import NonDataVariable
+
+
+class LoopVariable(NonDataVariable):
+    """
+    A LoopVariable is a type of variable that represents an item in a list.
+    It should be constructed using a parent Variable's `list_item()` method.
+    It should only be used in conjunction with the `For` component.
+
+    By default, the entire value is used as the item and the index in the list is used as the unique key.
+
+    ```python
+    from dara.core import Variable
+    from dara.core.visual.components import For
+
+    my_list = Variable([1, 2, 3])
+
+    # Renders a list of Text component where each item is the corresponding item in the list
+    For(
+        items=my_list,
+        renderer=Text(text=my_list.list_item)
+    )
+    ```
+
+    Most of the time, you'll want to store objects in a list. You should then use the `get` property to access specific
+    properties of the object and the `key` on the `For` component to specify the unique key.
+
+    ```python
+    from dara.core import Variable
+    from dara.core.visual.components import For
+
+    my_list = Variable([{'id': 1, 'name': 'John', 'age': 30}, {'id': 2, 'name': 'Jane', 'age': 25}])
+
+    # Renders a list of Text component where each item is the corresponding item in the list
+    For(
+        items=my_list,
+        renderer=Text(text=my_list.list_item.get('name')),
+        key_accessor='id'
+    )
+    ```
+
+    Alternatively, you can use index access instead of `get` to access specific properties of the object.
+    Both `get` and `[]` are equivalent.
+    """
+
+    nested: List[str] = Field(default_factory=list)
+
+    def __init__(self, uid: Optional[str] = None, nested: Optional[List[str]] = None):
+        if nested is None:
+            nested = []
+        super().__init__(uid=uid, nested=nested)
+
+    def get(self, key: str):
+        """
+        Access a nested property of the current item in the list.
+
+        ```python
+        from dara.core import Variable
+
+        my_list_of_objects = Variable([
+            {'id': 1, 'name': 'John', 'data': {'city': 'London', 'country': 'UK'}},
+            {'id': 2, 'name': 'Jane', 'data': {'city': 'Paris', 'country': 'France'}},
+        ])
+
+        # Represents the item 'name' property
+        my_list_of_objects.list_item.get('name')
+
+        # Represents the item 'data.country' property
+        my_list_of_objects.list_item.get('data').get('country')
+        ```
+        """
+        return self.model_copy(update={'nested': [*self.nested, key]}, deep=True)
+
+    def __getitem__(self, key: str):
+        return self.get(key)
+
+    @property
+    def list_item(self):
+        raise RuntimeError('LoopVariable does not support list_item')
+
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler):
+        parent_dict = nxt(self)
+        return {**parent_dict, '__typename': 'LoopVariable', 'uid': str(parent_dict['uid'])}

dara/core/interactivity/non_data_variable.py

@@ -34,3 +34,38 @@ class NonDataVariable(AnyVariable, abc.ABC):
 
     def __init__(self, uid: Optional[str] = None, **kwargs) -> None:
         super().__init__(uid=uid, **kwargs)
+
+    @property
+    def list_item(self):
+        """
+        Get a LoopVariable that represents the current item in the list.
+        Should only be used in conjunction with the `For` component.
+
+        Note that it is a type of a Variable so it can be used in places where a regular Variable is expected.
+
+        By default, the entire list item is used as the item.
+
+        `LoopVariable` supports nested property access using `get` or index access i.e. `[]`.
+        You can mix and match those two methods to access nested properties as they are equivalent.
+
+        ```python
+        my_list = Variable(['foo', 'bar', 'baz'])
+
+        # Represents the entire item in the list
+        my_list.list_item
+
+        my_list_of_objects = Variable([
+            {'id': 1, 'name': 'John', 'data': {'city': 'London', 'country': 'UK'}},
+            {'id': 2, 'name': 'Jane', 'data': {'city': 'Paris', 'country': 'France'}},
+        ])
+
+        # Represents the item 'name' property
+        my_list_of_objects.list_item['name']
+
+        # Represents the item 'data.country' property
+        my_list_of_objects.list_item.get('data')['country']
+        """
+
+        from .loop_variable import LoopVariable
+
+        return LoopVariable()

dara/core/internal/normalization.py

@@ -161,7 +161,7 @@ def normalize(obj: JsonLike, check_root: bool = True) -> Tuple[JsonLike, Mapping
     if check_root and _is_referrable(obj):
         identifier = _get_identifier(obj)
         # Don't check root again otherwise we end up in an infinite loop, we know it's referrable
-        _normalized, _lookup = normalize(obj, False)
+        _normalized, _lookup = normalize(obj, check_root=False)
         lookup[identifier] = _normalized
         lookup.update(_lookup)
         output = Placeholder(__ref=identifier)