dara-components 1.8.5__py3-none-any.whl → 1.22.1__py3-none-any.whl

dara/components/common/utils.py

@@ -17,40 +17,35 @@ limitations under the License.
 
 import os
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any
 
-from pydantic import BaseModel
-
-from dara.core.base_definitions import DaraBaseModel
+from dara.core.base_definitions import DaraBaseModel as BaseModel
 from dara.core.definitions import ComponentInstanceType
 
 
 class ItemBadge(BaseModel):
     """Add a badge to an item in a list"""
 
-    color: Optional[str]
+    color: str | None = None
     label: str
 
 
-class Item(DaraBaseModel):
+class Item(BaseModel):
     """
     A class for serializing a list of options for the select to show
     """
 
-    badge: Optional[ItemBadge]
-    image: Optional[str]
+    badge: ItemBadge | None = None
+    image: str | None = None
     label: str
-    value: Union[str, int, float, BaseModel]
-
-    class Config:
-        smart_union = True
+    value: str | int | float | BaseModel
 
     def __init__(
         self,
-        value: Union[str, int, float, BaseModel],
+        value: str | int | float | BaseModel,
         label: str,
-        badge: Optional[ItemBadge] = None,
-        image: Optional[str] = None,
+        badge: ItemBadge | None = None,
+        image: str | None = None,
     ):
         # Handle general enums in the value field
         if isinstance(value, Enum):
@@ -83,14 +78,14 @@ class Item(DaraBaseModel):
         try:
             label = str(item)
             return Item(label=label, value=item)
-        except Exception:
+        except Exception as e:
             raise ValueError(
                 f'Item: {item} could not be parsed correctly. If your item is a complex structure please pass in an '
                 f'Item class, with a string label defined'
-            )
+            ) from e
 
 
-class CarouselItem(DaraBaseModel):
+class CarouselItem(BaseModel):
     """
     CarouselItem provides with the following props:
 
@@ -103,25 +98,24 @@ class CarouselItem(DaraBaseModel):
     :param image_width: Optional string containing the width the image should take
     """
 
-    title: Optional[str]
-    subtitle: Optional[str]
-    component: Optional[ComponentInstanceType]
-    image: Optional[str]
-    image_alt: Optional[str]
-    image_height: Optional[str]
-    image_width: Optional[str]
+    title: str | None = None
+    subtitle: str | None = None
+    component: ComponentInstanceType | None = None
+    image: str | None = None
+    image_alt: str | None = None
+    image_height: str | None = None
+    image_width: str | None = None
 
     def __init__(
         self,
-        title: Optional[str] = None,
-        subtitle: Optional[str] = None,
-        component: Optional[ComponentInstanceType] = None,
-        image: Optional[str] = None,
-        image_alt: Optional[str] = None,
-        image_height: Optional[str] = None,
-        image_width: Optional[str] = None,
+        title: str | None = None,
+        subtitle: str | None = None,
+        component: ComponentInstanceType | None = None,
+        image: str | None = None,
+        image_alt: str | None = None,
+        image_height: str | None = None,
+        image_width: str | None = None,
     ):
-
         super().__init__(
             title=title,
             subtitle=subtitle,
@@ -154,8 +148,8 @@ class CarouselItem(DaraBaseModel):
         try:
             title = str(item)
             return CarouselItem(title=title)
-        except Exception:
+        except Exception as e:
             raise ValueError(
                 f'CarouselItem: {item} could not be parsed correctly. If your item is a complex structure please pass in an '
                 f'CarouselItem class'
-            )
+            ) from e

dara/components/graphs/__init__.py

@@ -14,6 +14,7 @@ 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.
 """
+# ruff: noqa: F401, F403
 
 from dara.components.graphs.components import *
 from dara.components.graphs.definitions import *

dara/components/graphs/components/base_graph_component.py

@@ -15,8 +15,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Dict, List, Optional, Union
+from typing import Any
 
+from pydantic import ConfigDict, SerializerFunctionWrapHandler, field_serializer
+
+from cai_causal_graph import CausalGraph, Skeleton
 from dara.components.graphs.definitions import (
     DEFAULT_LEGENDS,
     EditorMode,
@@ -54,25 +57,34 @@ class BaseGraphComponent(StyledComponentInstance):
     :param zoom_thresholds: Optional user-defined zoom thresholds. See [ZoomThresholds](../definitions/#zoomthresholds) for more details.
     """
 
-    additional_legends: Optional[List[GraphLegend]] = None
-    allow_selection_when_not_editable: Optional[bool] = False
-    available_inputs: Optional[List[str]] = None
-    default_legends: Dict[Union[EditorMode, str], List[GraphLegend]] = DEFAULT_LEGENDS
-    disable_edge_add: Optional[bool] = None
-    disable_latent_node_add: Optional[bool] = None
-    disable_node_removal: Optional[bool] = None
-    editable: Optional[bool] = False
-    graph_layout: Optional[GraphLayout] = FcoseLayout()
-    non_removable_nodes: Optional[List[str]] = None
-    on_click_edge: Optional[Action] = None
-    on_click_node: Optional[Action] = None
-    on_update: Optional[Action] = None
-    require_focus_to_zoom: Optional[bool] = True
-    simultaneous_edge_node_selection: Optional[bool] = False
-    tooltip_size: Optional[int] = None
-    verbose_descriptions: Optional[bool] = None
-    zoom_thresholds: Optional[ZoomThresholds] = None
+    additional_legends: list[GraphLegend] | None = None
+    allow_selection_when_not_editable: bool | None = False
+    available_inputs: list[str] | None = None
+    default_legends: dict[EditorMode | str, list[GraphLegend]] = DEFAULT_LEGENDS
+    disable_edge_add: bool | None = None
+    disable_latent_node_add: bool | None = None
+    disable_node_removal: bool | None = None
+    editable: bool | None = False
+    graph_layout: GraphLayout | None = FcoseLayout()
+    non_removable_nodes: list[str] | None = None
+    on_click_edge: Action | None = None
+    on_click_node: Action | None = None
+    on_update: Action | None = None
+    require_focus_to_zoom: bool | None = True
+    simultaneous_edge_node_selection: bool | None = False
+    tooltip_size: int | None = None
+    verbose_descriptions: bool | None = None
+    zoom_thresholds: ZoomThresholds | None = None
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra='forbid',
+    )
+
+    @field_serializer('*', mode='wrap')
+    def serialize_graphs(self, value: Any, nxt: SerializerFunctionWrapHandler):
+        # handle serializing fields of type CausalGraph and Skeleton
+        if isinstance(value, (CausalGraph, Skeleton)):
+            return value.to_dict()
 
-    class Config:
-        arbitrary_types_allowed = True
-        extra = 'forbid'
+        return nxt(value)

dara/components/graphs/components/causal_graph_viewer.py

@@ -15,11 +15,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Optional, Union
+from pydantic import field_validator, model_validator
 
 from cai_causal_graph import CausalGraph, Skeleton
-from pydantic import root_validator, validator
-
 from dara.components.graphs.components.base_graph_component import BaseGraphComponent
 from dara.components.graphs.definitions import EditorMode
 from dara.components.graphs.graph_layout import PlanarLayout
@@ -228,6 +226,10 @@ class CausalGraphViewer(BaseGraphComponent):
     :param disable_latent_node_add: Optional flag for disabling latent node addition
     :param disable_node_removal: Optional flag for disabling node removal
     :param editable: Optional flag to enable editing the graph by showing an editor frame around the graph
+    :param editor_mode: Optional editor mode to use. The following options are available:
+        EditorMode.DEFAULT - Default DAG viewer, assumes all edges are directed.
+        EditorMode.PAG - PAG viewer, displays all edge types.
+        EditorMode.RESOLVER - Resolver mode, allows users to accept edges.
     :param graph_layout: Optional layout configuration object
     :param non_removable_nodes: Optional list of node names that cannot be removed
     :param on_click_edge: Event handler for clicking on an edge
@@ -244,10 +246,10 @@ class CausalGraphViewer(BaseGraphComponent):
 
     js_module = '@darajs/components'
 
-    causal_graph: Optional[Union[CausalGraph, DerivedVariable, Variable, dict, Skeleton]]
-    editor_mode: Optional[EditorMode] = None
+    causal_graph: CausalGraph | DerivedVariable | Variable | dict | Skeleton
+    editor_mode: EditorMode | None = None
 
-    @validator('causal_graph')
+    @field_validator('causal_graph')
     @classmethod
     def validate_causal_graph(cls, causal_graph):
         """
@@ -262,15 +264,11 @@ class CausalGraphViewer(BaseGraphComponent):
             )
         return causal_graph
 
-    @root_validator
-    @classmethod
-    def validate_layout(cls, values: dict):
-        if (
-            isinstance(values.get('graph_layout'), PlanarLayout)
-            and values.get('editor_mode', EditorMode.DEFAULT) != EditorMode.DEFAULT
-        ):
+    @model_validator(mode='after')
+    def validate_layout(self):
+        if isinstance(self.graph_layout, PlanarLayout) and self.editor_mode != EditorMode.DEFAULT:
             dev_logger.warning(
                 'Planar Layout is currently only supported with EditorMode.DEFAULT. Setting editor_mode to EditorMode.DEFAULT.'
             )
-            values['editor_mode'] = EditorMode.DEFAULT
-        return values
+            self.editor_mode = EditorMode.DEFAULT
+        return self

dara/components/graphs/components/edge_encoder.py

@@ -15,13 +15,19 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Dict, List, Optional, Union
+from typing import Any
+
+from fastapi.encoders import jsonable_encoder
+from pydantic import (
+    ConfigDict,
+    SerializerFunctionWrapHandler,
+    field_serializer,
+    model_validator,
+)
+from typing_extensions import TypedDict
 
 from cai_causal_graph.graph_components import Node
 from cai_causal_graph.type_definitions import EdgeConstraint as EdgeConstraintType
-from pydantic import root_validator
-from typing_extensions import TypedDict
-
 from dara.components.graphs.definitions import DEFAULT_LEGENDS, EditorMode, GraphLegend
 from dara.components.graphs.graph_layout import (
     GraphLayout,
@@ -30,7 +36,7 @@ from dara.components.graphs.graph_layout import (
 )
 from dara.core.base_definitions import Action
 from dara.core.definitions import StyledComponentInstance
-from dara.core.interactivity import NonDataVariable
+from dara.core.interactivity import AnyVariable, ClientVariable
 
 
 class EdgeConstraint(TypedDict):
@@ -123,26 +129,43 @@ class VisualEdgeEncoder(StyledComponentInstance):
 
     js_module = '@darajs/components'
 
-    additional_legends: Optional[List[GraphLegend]] = None
-    allow_selection_when_not_editable: Optional[bool] = False
-    default_legends: Dict[Union[EditorMode, str], List[GraphLegend]] = DEFAULT_LEGENDS
-    editable: Optional[bool] = False
-    graph_layout: Optional[GraphLayout] = MarketingLayout()
-    initial_constraints: Optional[Union[List[EdgeConstraint], NonDataVariable]] = None
-    nodes: Union[List[str], Dict[str, Node], NonDataVariable]
-    on_click_edge: Optional[Action] = None
-    on_click_node: Optional[Action] = None
-    on_update: Optional[Action] = None
-    require_focus_to_zoom: Optional[bool] = True
-    tooltip_size: Optional[str] = None
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    @root_validator
-    @classmethod
-    def validate_layout(cls, values: dict):
-        if isinstance(values.get('graph_layout'), PlanarLayout):
+    additional_legends: list[GraphLegend] | None = None
+    allow_selection_when_not_editable: bool | None = False
+    default_legends: dict[EditorMode | str, list[GraphLegend]] = DEFAULT_LEGENDS
+    editable: bool | None = False
+    graph_layout: GraphLayout | None = MarketingLayout()
+    initial_constraints: list[EdgeConstraint] | ClientVariable | None = None
+    nodes: list[str] | dict[str, Node] | ClientVariable
+    on_click_edge: Action | None = None
+    on_click_node: Action | None = None
+    on_update: Action | None = None
+    require_focus_to_zoom: bool | None = True
+    tooltip_size: str | None = None
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra='forbid',
+    )
+
+    @model_validator(mode='after')
+    def validate_layout(self):
+        if isinstance(self.graph_layout, PlanarLayout):
             raise ValueError('Planar Layout is not currently supported by EdgeEncoder.')
 
-        return values
+        return self
+
+    @field_serializer('nodes', mode='wrap')
+    def serialize_nodes(self, value: Any, nxt: SerializerFunctionWrapHandler):
+        if isinstance(value, dict):
+            if len(value.keys()) == 0:
+                return value
+            # Handle dict[str, Node]
+            if isinstance(value.get(list(value.keys())[0]), Node):
+                result = {k: v.to_dict() for k, v in value.items()}
+                return result
+
+        # For some reason just invoking nxt() in it will not invoke the proper variable serialization
+        if isinstance(value, AnyVariable):
+            return jsonable_encoder(value)
+
+        return nxt(value)

dara/components/graphs/components/node_hierarchy_builder.py

@@ -15,27 +15,28 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, ClassVar
 
-from pydantic import BaseModel, validator
+from pydantic import field_validator
 
 from dara.core.base_definitions import Action
+from dara.core.base_definitions import DaraBaseModel as BaseModel
 from dara.core.definitions import StyledComponentInstance
-from dara.core.interactivity import NonDataVariable
+from dara.core.interactivity import ClientVariable
 
 
 class NodeMeta(BaseModel):
-    label_size: Optional[int] = None
-    wrap_text: Optional[bool] = None
-    label: Optional[str] = None
-    tooltip: Optional[Union[str, Dict[str, str]]] = None
+    label_size: int | None = None
+    wrap_text: bool | None = None
+    label: str | None = None
+    tooltip: str | dict[str, str] | None = None
 
 
 class Node(BaseModel):
     name: str
-    meta: Optional[NodeMeta] = None
+    meta: NodeMeta | None = None
 
-    Meta = NodeMeta
+    Meta: ClassVar[type[NodeMeta]] = NodeMeta
 
 
 class NodeHierarchyBuilder(StyledComponentInstance):
@@ -108,16 +109,16 @@ class NodeHierarchyBuilder(StyledComponentInstance):
     js_module = '@darajs/components'
 
     editable: bool = True
-    nodes: Union[List[List[str]], List[str], List[Node], List[List[Node]], NonDataVariable]
-    node_font_size: Optional[int] = None
-    node_size: Optional[int] = None
-    on_update: Optional[Action] = None
+    nodes: list[list[str]] | list[str] | list[Node] | list[list[Node]] | ClientVariable
+    node_font_size: int | None = None
+    node_size: int | None = None
+    on_update: Action | None = None
     wrap_node_text: bool = True
 
-    @validator('nodes')
+    @field_validator('nodes')
     @classmethod
-    def validate_nodes(cls, nodes: Any) -> Union[NonDataVariable, List[List[str]], List[List[Node]]]:
-        if isinstance(nodes, NonDataVariable):
+    def validate_nodes(cls, nodes: Any) -> ClientVariable | list[list[str]] | list[list[Node]]:
+        if isinstance(nodes, ClientVariable):
             return nodes
         if not isinstance(nodes, list):
             raise ValueError('Nodes provided to NodeHierarchyBuilder must be a Variable or a list of strings/Nodes')

dara/components/graphs/definitions.py

@@ -16,9 +16,11 @@ limitations under the License.
 """
 
 from enum import Enum
-from typing import ClassVar, Dict, List, Literal, Optional, Type, Union
+from typing import ClassVar, Literal
 
-from pydantic import BaseModel, Field
+from pydantic import Field
+
+from dara.core.base_definitions import DaraBaseModel as BaseModel
 
 
 class EditorMode(str, Enum):
@@ -47,12 +49,17 @@ class CenterSymbol(str, Enum):
     BIDIRECTED = 'bidirected'
 
 
+EdgeLegendType = type['EdgeLegend']
+SpacerLegendType = type['SpacerLegend']
+NodeLegendType = type['NodeLegend']
+
+
 class Legend(BaseModel):
     type: str
 
-    Edge: ClassVar[Type['EdgeLegend']]
-    Spacer: ClassVar[Type['SpacerLegend']]
-    Node: ClassVar[Type['NodeLegend']]
+    Edge: ClassVar[EdgeLegendType]
+    Spacer: ClassVar[SpacerLegendType]
+    Node: ClassVar[NodeLegendType]
 
 
 class SpacerLegend(Legend):
@@ -62,8 +69,8 @@ class SpacerLegend(Legend):
     :param label: Optional label to show in the legend
     """
 
-    type: Literal['spacer'] = Field(default='spacer', const=True)
-    label: Optional[str] = None
+    type: Literal['spacer'] = Field(default='spacer', frozen=True)  # type: ignore
+    label: str | None = None
 
 
 class EdgeLegend(Legend):
@@ -77,12 +84,12 @@ class EdgeLegend(Legend):
     :param dash_array: Optional [stroke-dasharray](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-dasharray) SVG path property - line will be dashed if specified
     """
 
-    type: Literal['edge'] = Field(default='edge', const=True)
-    label: Optional[str] = None
-    arrow_type: Optional[ArrowType] = ArrowType.NORMAL
-    center_symbol: Optional[CenterSymbol] = CenterSymbol.NONE
-    color: Optional[str] = 'theme.grey5'
-    dash_array: Optional[str] = None
+    type: Literal['edge'] = Field(default='edge', frozen=True)  # type: ignore
+    label: str | None = None
+    arrow_type: ArrowType | None = ArrowType.NORMAL
+    center_symbol: CenterSymbol | None = CenterSymbol.NONE
+    color: str | None = 'theme.grey5'
+    dash_array: str | None = None
 
 
 class NodeLegend(Legend):
@@ -94,26 +101,26 @@ class NodeLegend(Legend):
     :param highlight_color: Optional color for the node symbol rim in the legend
     """
 
-    type: Literal['node'] = Field(default='node', const=True)
-    label: Optional[str] = None
-    color: Optional[str] = 'theme.blue4'
-    highlight_color: Optional[str] = 'theme.primary'
+    type: Literal['node'] = Field(default='node', frozen=True)  # type: ignore
+    label: str | None = None
+    color: str | None = 'theme.blue4'
+    highlight_color: str | None = 'theme.primary'
 
 
 Legend.Edge = EdgeLegend
 Legend.Spacer = SpacerLegend
 Legend.Node = NodeLegend
 
-GraphLegend = Union[EdgeLegend, SpacerLegend, NodeLegend]
+GraphLegend = EdgeLegend | SpacerLegend | NodeLegend
 
-DEFAULT_NODE_LEGENDS: List[GraphLegend] = [
+DEFAULT_NODE_LEGENDS: list[GraphLegend] = [
     Legend.Node(color='theme.blue1', label='Latent'),
     Legend.Node(color='theme.secondary', label='Target'),
     Legend.Node(label='Other'),
 ]
 
 # Default legends for each editor mode
-DEFAULT_LEGENDS: Dict[Union[EditorMode, str], List[GraphLegend]] = {
+DEFAULT_LEGENDS: dict[EditorMode | str, list[GraphLegend]] = {
     EditorMode.DEFAULT: DEFAULT_NODE_LEGENDS,
     EditorMode.PAG: [
         *DEFAULT_NODE_LEGENDS,