acryl-datahub 1.2.0.9rc2__py3-none-any.whl → 1.2.0.10__py3-none-any.whl

datahub/metadata/schemas/GlobalSettingsInfo.avsc

@@ -198,6 +198,78 @@
       "default": null,
       "doc": "SSO integrations between DataHub and identity providers"
     },
+    {
+      "type": [
+        "null",
+        {
+          "type": "record",
+          "name": "OAuthSettings",
+          "namespace": "com.linkedin.pegasus2avro.settings.global",
+          "fields": [
+            {
+              "type": {
+                "type": "array",
+                "items": {
+                  "type": "record",
+                  "name": "OAuthProvider",
+                  "namespace": "com.linkedin.pegasus2avro.settings.global",
+                  "fields": [
+                    {
+                      "type": "boolean",
+                      "name": "enabled",
+                      "doc": "Whether this OAuth provider is enabled."
+                    },
+                    {
+                      "type": "string",
+                      "name": "name",
+                      "doc": "The name of this OAuth provider. This is used for display purposes only."
+                    },
+                    {
+                      "type": [
+                        "null",
+                        "string"
+                      ],
+                      "name": "jwksUri",
+                      "default": null,
+                      "doc": "The URI of the JSON Web Key Set (JWKS) endpoint for this OAuth provider."
+                    },
+                    {
+                      "type": "string",
+                      "name": "issuer",
+                      "doc": "The expected issuer (iss) claim in the JWTs issued by this OAuth provider."
+                    },
+                    {
+                      "type": "string",
+                      "name": "audience",
+                      "doc": "The expected audience (aud) claim in the JWTs issued by this OAuth provider."
+                    },
+                    {
+                      "type": "string",
+                      "name": "algorithm",
+                      "default": "RS256",
+                      "doc": "The JWT signing algorithm required for this provider.\nPrevents algorithm confusion attacks. Common values: RS256, RS384, RS512, PS256, ES256"
+                    },
+                    {
+                      "type": "string",
+                      "name": "userIdClaim",
+                      "default": "sub",
+                      "doc": "The JWT claim to use as the user identifier for this provider.\nDifferent providers use different claims (sub, email, preferred_username, etc.)"
+                    }
+                  ],
+                  "doc": "An OAuth Provider. This provides information required to validate inbound\nrequests with OAuth 2.0 bearer tokens."
+                }
+              },
+              "name": "providers",
+              "doc": "Trusted OAuth Providers"
+            }
+          ],
+          "doc": "Trust oauth providers to use for authentication."
+        }
+      ],
+      "name": "oauth",
+      "default": null,
+      "doc": "Settings related to the oauth authentication provider"
+    },
     {
       "type": [
         "null",

datahub/metadata/schemas/InstitutionalMemory.avsc

@@ -84,6 +84,28 @@
               "name": "updateStamp",
               "default": null,
               "doc": "Audit stamp associated with updation of this record"
+            },
+            {
+              "type": [
+                "null",
+                {
+                  "type": "record",
+                  "name": "InstitutionalMemoryMetadataSettings",
+                  "namespace": "com.linkedin.pegasus2avro.common",
+                  "fields": [
+                    {
+                      "type": "boolean",
+                      "name": "showInAssetPreview",
+                      "default": false,
+                      "doc": "Show record in asset preview like on entity header and search previews"
+                    }
+                  ],
+                  "doc": "Settings related to a record of InstitutionalMemoryMetadata"
+                }
+              ],
+              "name": "settings",
+              "default": null,
+              "doc": "Settings for this record"
             }
           ],
           "doc": "Metadata corresponding to a record of institutional memory."

datahub/metadata/schemas/LogicalParent.avsc

@@ -140,5 +140,6 @@
       "name": "parent",
       "default": null
     }
-  ]
+  ],
+  "doc": "Relates a physical asset to a logical model."
 }

datahub/metadata/schemas/MLModelGroupKey.avsc

@@ -21,7 +21,8 @@
       "forms",
       "testResults",
       "subTypes",
-      "container"
+      "container",
+      "institutionalMemory"
     ]
   },
   "name": "MLModelGroupKey",

datahub/metadata/schemas/MetadataChangeEvent.avsc

@@ -1143,6 +1143,28 @@
                                 "name": "updateStamp",
                                 "default": null,
                                 "doc": "Audit stamp associated with updation of this record"
+                              },
+                              {
+                                "type": [
+                                  "null",
+                                  {
+                                    "type": "record",
+                                    "name": "InstitutionalMemoryMetadataSettings",
+                                    "namespace": "com.linkedin.pegasus2avro.common",
+                                    "fields": [
+                                      {
+                                        "type": "boolean",
+                                        "name": "showInAssetPreview",
+                                        "default": false,
+                                        "doc": "Show record in asset preview like on entity header and search previews"
+                                      }
+                                    ],
+                                    "doc": "Settings related to a record of InstitutionalMemoryMetadata"
+                                  }
+                                ],
+                                "name": "settings",
+                                "default": null,
+                                "doc": "Settings for this record"
                               }
                             ],
                             "doc": "Metadata corresponding to a record of institutional memory."

datahub/sdk/_shared.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import warnings
+from abc import ABC, abstractmethod
 from datetime import datetime
 from typing import (
     TYPE_CHECKING,
@@ -61,6 +62,7 @@ DataPlatformInstanceUrnOrStr: TypeAlias = Union[str, DataPlatformInstanceUrn]
 DataPlatformUrnOrStr: TypeAlias = Union[str, DataPlatformUrn]
 
 ActorUrn: TypeAlias = Union[CorpUserUrn, CorpGroupUrn]
+ActorUrnOrStr: TypeAlias = Union[str, ActorUrn]
 StructuredPropertyUrnOrStr: TypeAlias = Union[str, StructuredPropertyUrn]
 StructuredPropertyValueType: TypeAlias = Union[str, float, int]
 StructuredPropertyInputType: TypeAlias = Dict[
@@ -110,6 +112,130 @@ def parse_time_stamp(ts: Optional[models.TimeStampClass]) -> Optional[datetime]:
     return parse_ts_millis(ts.time)
 
 
+class ChangeAuditStampsMixin(ABC):
+    """Mixin class for managing audit stamps on entities."""
+
+    __slots__ = ()
+
+    @abstractmethod
+    def _get_audit_stamps(self) -> models.ChangeAuditStampsClass:
+        """Get the audit stamps from the entity properties."""
+        pass
+
+    @abstractmethod
+    def _set_audit_stamps(self, audit_stamps: models.ChangeAuditStampsClass) -> None:
+        """Set the audit stamps on the entity properties."""
+        pass
+
+    @property
+    def last_modified(self) -> Optional[datetime]:
+        """Get the last modification timestamp from audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        if audit_stamps.lastModified.time == 0:
+            return None
+        return datetime.fromtimestamp(
+            audit_stamps.lastModified.time / 1000
+        )  # supports only seconds precision
+
+    def set_last_modified(self, last_modified: datetime) -> None:
+        """Set the last modification timestamp in audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        audit_stamps.lastModified.time = make_ts_millis(last_modified)
+        self._set_audit_stamps(audit_stamps)
+
+    @property
+    def last_modified_by(self) -> Optional[str]:
+        """Get the last modification actor from audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        if audit_stamps.lastModified.actor == builder.UNKNOWN_USER:
+            return None
+        return audit_stamps.lastModified.actor
+
+    def set_last_modified_by(self, last_modified_by: ActorUrnOrStr) -> None:
+        """Set the last modification actor in audit stamps."""
+        if isinstance(last_modified_by, str):
+            last_modified_by = make_user_urn(last_modified_by)
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        audit_stamps.lastModified.actor = str(last_modified_by)
+        self._set_audit_stamps(audit_stamps)
+
+    @property
+    def created_at(self) -> Optional[datetime]:
+        """Get the creation timestamp from audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        if audit_stamps.created.time == 0:
+            return None
+        return datetime.fromtimestamp(
+            audit_stamps.created.time / 1000
+        )  # supports only seconds precision
+
+    def set_created_at(self, created_at: datetime) -> None:
+        """Set the creation timestamp in audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        audit_stamps.created.time = make_ts_millis(created_at)
+        self._set_audit_stamps(audit_stamps)
+
+    @property
+    def created_by(self) -> Optional[ActorUrnOrStr]:
+        """Get the creation actor from audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        if audit_stamps.created.actor == builder.UNKNOWN_USER:
+            return None
+        return audit_stamps.created.actor
+
+    def set_created_by(self, created_by: ActorUrnOrStr) -> None:
+        """Set the creation actor in audit stamps."""
+        if isinstance(created_by, str):
+            created_by = make_user_urn(created_by)
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        audit_stamps.created.actor = str(created_by)
+        self._set_audit_stamps(audit_stamps)
+
+    @property
+    def deleted_on(self) -> Optional[datetime]:
+        """Get the deletion timestamp from audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        if audit_stamps.deleted is None or audit_stamps.deleted.time == 0:
+            return None
+        return datetime.fromtimestamp(
+            audit_stamps.deleted.time / 1000
+        )  # supports only seconds precision
+
+    def set_deleted_on(self, deleted_on: datetime) -> None:
+        """Set the deletion timestamp in audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        # Default constructor sets deleted to None
+        if audit_stamps.deleted is None:
+            audit_stamps.deleted = models.AuditStampClass(
+                time=0, actor=builder.UNKNOWN_USER
+            )
+        audit_stamps.deleted.time = make_ts_millis(deleted_on)
+        self._set_audit_stamps(audit_stamps)
+
+    @property
+    def deleted_by(self) -> Optional[ActorUrnOrStr]:
+        """Get the deletion actor from audit stamps."""
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        if (
+            audit_stamps.deleted is None
+            or audit_stamps.deleted.actor == builder.UNKNOWN_USER
+        ):
+            return None
+        return audit_stamps.deleted.actor
+
+    def set_deleted_by(self, deleted_by: ActorUrnOrStr) -> None:
+        """Set the deletion actor in audit stamps."""
+        if isinstance(deleted_by, str):
+            deleted_by = make_user_urn(deleted_by)
+        audit_stamps: models.ChangeAuditStampsClass = self._get_audit_stamps()
+        if audit_stamps.deleted is None:
+            audit_stamps.deleted = models.AuditStampClass(
+                time=0, actor=builder.UNKNOWN_USER
+            )
+        audit_stamps.deleted.actor = str(deleted_by)
+        self._set_audit_stamps(audit_stamps)
+
+
 class HasPlatformInstance(Entity):
     __slots__ = ()
 

datahub/sdk/chart.py

@@ -10,6 +10,8 @@ import datahub.metadata.schema_classes as models
 from datahub.emitter.enum_helpers import get_enum_options
 from datahub.metadata.urns import ChartUrn, DatasetUrn, Urn
 from datahub.sdk._shared import (
+    ActorUrnOrStr,
+    ChangeAuditStampsMixin,
     DataPlatformInstanceUrnOrStr,
     DataPlatformUrnOrStr,
     DatasetUrnOrStr,
@@ -34,6 +36,7 @@ from datahub.utilities.sentinels import Unset, unset
 
 
 class Chart(
+    ChangeAuditStampsMixin,
     HasPlatformInstance,
     HasSubtype,
     HasOwnership,
@@ -70,6 +73,11 @@ class Chart(
         chart_url: Optional[str] = None,
         custom_properties: Optional[Dict[str, str]] = None,
         last_modified: Optional[datetime] = None,
+        last_modified_by: Optional[ActorUrnOrStr] = None,
+        created_at: Optional[datetime] = None,
+        created_by: Optional[ActorUrnOrStr] = None,
+        deleted_on: Optional[datetime] = None,
+        deleted_by: Optional[ActorUrnOrStr] = None,
         last_refreshed: Optional[datetime] = None,
         chart_type: Optional[Union[str, models.ChartTypeClass]] = None,
         access: Optional[str] = None,
@@ -94,13 +102,60 @@ class Chart(
         self._set_extra_aspects(extra_aspects)
 
         self._set_platform_instance(platform, platform_instance)
-
         self._ensure_chart_props(display_name=display_name)
+        self._init_chart_properties(
+            description,
+            display_name,
+            external_url,
+            chart_url,
+            custom_properties,
+            last_modified,
+            last_modified_by,
+            created_at,
+            created_by,
+            last_refreshed,
+            deleted_on,
+            deleted_by,
+            chart_type,
+            access,
+            input_datasets,
+        )
+        self._init_standard_aspects(
+            parent_container, subtype, owners, links, tags, terms, domain
+        )
 
-        if display_name is not None:
-            self.set_display_name(display_name)
+    @classmethod
+    def _new_from_graph(cls, urn: Urn, current_aspects: models.AspectBag) -> Self:
+        assert isinstance(urn, ChartUrn)
+        entity = cls(
+            platform=urn.dashboard_tool,
+            name=urn.chart_id,
+        )
+        return entity._init_from_graph(current_aspects)
+
+    def _init_chart_properties(
+        self,
+        description: Optional[str],
+        display_name: Optional[str],
+        external_url: Optional[str],
+        chart_url: Optional[str],
+        custom_properties: Optional[Dict[str, str]],
+        last_modified: Optional[datetime],
+        last_modified_by: Optional[ActorUrnOrStr],
+        created_at: Optional[datetime],
+        created_by: Optional[ActorUrnOrStr],
+        last_refreshed: Optional[datetime],
+        deleted_on: Optional[datetime],
+        deleted_by: Optional[ActorUrnOrStr],
+        chart_type: Optional[Union[str, models.ChartTypeClass]],
+        access: Optional[str],
+        input_datasets: Optional[Sequence[Union[DatasetUrnOrStr, Dataset]]],
+    ) -> None:
+        """Initialize chart-specific properties."""
         if description is not None:
             self.set_description(description)
+        if display_name is not None:
+            self.set_display_name(display_name)
         if external_url is not None:
             self.set_external_url(external_url)
         if chart_url is not None:
@@ -109,6 +164,16 @@ class Chart(
             self.set_custom_properties(custom_properties)
         if last_modified is not None:
             self.set_last_modified(last_modified)
+        if last_modified_by is not None:
+            self.set_last_modified_by(last_modified_by)
+        if created_at is not None:
+            self.set_created_at(created_at)
+        if created_by is not None:
+            self.set_created_by(created_by)
+        if deleted_on is not None:
+            self.set_deleted_on(deleted_on)
+        if deleted_by is not None:
+            self.set_deleted_by(deleted_by)
         if last_refreshed is not None:
             self.set_last_refreshed(last_refreshed)
         if chart_type is not None:
@@ -118,6 +183,17 @@ class Chart(
         if input_datasets is not None:
             self.set_input_datasets(input_datasets)
 
+    def _init_standard_aspects(
+        self,
+        parent_container: ParentContainerInputType | Unset,
+        subtype: Optional[str],
+        owners: Optional[OwnersInputType],
+        links: Optional[LinksInputType],
+        tags: Optional[TagsInputType],
+        terms: Optional[TermsInputType],
+        domain: Optional[DomainInputType],
+    ) -> None:
+        """Initialize standard aspects."""
         if parent_container is not unset:
             self._set_container(parent_container)
         if subtype is not None:
@@ -133,15 +209,6 @@ class Chart(
         if domain is not None:
             self.set_domain(domain)
 
-    @classmethod
-    def _new_from_graph(cls, urn: Urn, current_aspects: models.AspectBag) -> Self:
-        assert isinstance(urn, ChartUrn)
-        entity = cls(
-            platform=urn.dashboard_tool,
-            name=urn.chart_id,
-        )
-        return entity._init_from_graph(current_aspects)
-
     @property
     def urn(self) -> ChartUrn:
         assert isinstance(self._urn, ChartUrn)
@@ -159,6 +226,14 @@ class Chart(
             )
         )
 
+    def _get_audit_stamps(self) -> models.ChangeAuditStampsClass:
+        """Get the audit stamps from the chart properties."""
+        return self._ensure_chart_props().lastModified
+
+    def _set_audit_stamps(self, audit_stamps: models.ChangeAuditStampsClass) -> None:
+        """Set the audit stamps on the chart properties."""
+        self._ensure_chart_props().lastModified = audit_stamps
+
     @property
     def name(self) -> str:
         """Get the name of the chart."""
@@ -220,24 +295,6 @@ class Chart(
         """Set the custom properties of the chart."""
         self._ensure_chart_props().customProperties = custom_properties
 
-    @property
-    def last_modified(self) -> Optional[datetime]:
-        """Get the last modification timestamp of the chart."""
-        last_modified_time = self._ensure_chart_props().lastModified.lastModified.time
-        if not last_modified_time:
-            return None
-        return datetime.fromtimestamp(last_modified_time)
-
-    def set_last_modified(self, last_modified: datetime) -> None:
-        """Set the last modification timestamp of the chart."""
-        chart_props = self._ensure_chart_props()
-        chart_props.lastModified = models.ChangeAuditStampsClass(
-            lastModified=models.AuditStampClass(
-                time=int(last_modified.timestamp()),
-                actor="urn:li:corpuser:datahub",
-            )
-        )
-
     @property
     def last_refreshed(self) -> Optional[datetime]:
         """Get the last refresh timestamp of the chart."""

datahub/sdk/dashboard.py

@@ -9,6 +9,8 @@ from typing_extensions import Self
 import datahub.metadata.schema_classes as models
 from datahub.metadata.urns import ChartUrn, DashboardUrn, DatasetUrn, Urn
 from datahub.sdk._shared import (
+    ActorUrnOrStr,
+    ChangeAuditStampsMixin,
     ChartUrnOrStr,
     DashboardUrnOrStr,
     DataPlatformInstanceUrnOrStr,
@@ -36,6 +38,7 @@ from datahub.utilities.sentinels import Unset, unset
 
 
 class Dashboard(
+    ChangeAuditStampsMixin,
     HasPlatformInstance,
     HasSubtype,
     HasOwnership,
@@ -72,6 +75,11 @@ class Dashboard(
         dashboard_url: Optional[str] = None,
         custom_properties: Optional[Dict[str, str]] = None,
         last_modified: Optional[datetime] = None,
+        last_modified_by: Optional[ActorUrnOrStr] = None,
+        created_at: Optional[datetime] = None,
+        created_by: Optional[ActorUrnOrStr] = None,
+        deleted_on: Optional[datetime] = None,
+        deleted_by: Optional[ActorUrnOrStr] = None,
         last_refreshed: Optional[datetime] = None,
         input_datasets: Optional[Sequence[Union[DatasetUrnOrStr, Dataset]]] = None,
         charts: Optional[Sequence[Union[ChartUrnOrStr, Chart]]] = None,
@@ -96,17 +104,48 @@ class Dashboard(
         self._set_extra_aspects(extra_aspects)
 
         self._set_platform_instance(platform, platform_instance)
+        self._ensure_dashboard_props(display_name=display_name)
+
+        self._init_dashboard_properties(
+            description,
+            display_name,
+            external_url,
+            dashboard_url,
+            custom_properties,
+            last_modified,
+            last_modified_by,
+            created_at,
+            created_by,
+            last_refreshed,
+            deleted_on,
+            deleted_by,
+            input_datasets,
+            charts,
+            dashboards,
+        )
+        self._init_standard_aspects(
+            parent_container, subtype, owners, links, tags, terms, domain
+        )
 
-        # Initialize DashboardInfoClass with default values
-        dashboard_info = self._ensure_dashboard_props(display_name=display_name)
-        if last_modified:
-            dashboard_info.lastModified = models.ChangeAuditStampsClass(
-                lastModified=models.AuditStampClass(
-                    time=int(last_modified.timestamp()),
-                    actor="urn:li:corpuser:datahub",
-                ),
-            )
-
+    def _init_dashboard_properties(
+        self,
+        description: Optional[str],
+        display_name: Optional[str],
+        external_url: Optional[str],
+        dashboard_url: Optional[str],
+        custom_properties: Optional[Dict[str, str]],
+        last_modified: Optional[datetime],
+        last_modified_by: Optional[ActorUrnOrStr],
+        created_at: Optional[datetime],
+        created_by: Optional[ActorUrnOrStr],
+        last_refreshed: Optional[datetime],
+        deleted_on: Optional[datetime],
+        deleted_by: Optional[ActorUrnOrStr],
+        input_datasets: Optional[Sequence[Union[DatasetUrnOrStr, Dataset]]],
+        charts: Optional[Sequence[Union[ChartUrnOrStr, Chart]]],
+        dashboards: Optional[Sequence[Union[DashboardUrnOrStr, Dashboard]]],
+    ) -> None:
+        """Initialize dashboard-specific properties."""
         if description is not None:
             self.set_description(description)
         if display_name is not None:
@@ -119,6 +158,16 @@ class Dashboard(
             self.set_custom_properties(custom_properties)
         if last_modified is not None:
             self.set_last_modified(last_modified)
+        if last_modified_by is not None:
+            self.set_last_modified_by(last_modified_by)
+        if created_at is not None:
+            self.set_created_at(created_at)
+        if created_by is not None:
+            self.set_created_by(created_by)
+        if deleted_on is not None:
+            self.set_deleted_on(deleted_on)
+        if deleted_by is not None:
+            self.set_deleted_by(deleted_by)
         if last_refreshed is not None:
             self.set_last_refreshed(last_refreshed)
         if input_datasets is not None:
@@ -128,6 +177,17 @@ class Dashboard(
         if dashboards is not None:
             self.set_dashboards(dashboards)
 
+    def _init_standard_aspects(
+        self,
+        parent_container: ParentContainerInputType | Unset,
+        subtype: Optional[str],
+        owners: Optional[OwnersInputType],
+        links: Optional[LinksInputType],
+        tags: Optional[TagsInputType],
+        terms: Optional[TermsInputType],
+        domain: Optional[DomainInputType],
+    ) -> None:
+        """Initialize standard aspects."""
         if parent_container is not unset:
             self._set_container(parent_container)
         if subtype is not None:
@@ -165,18 +225,20 @@ class Dashboard(
             models.DashboardInfoClass(
                 title=display_name or self.urn.dashboard_id,
                 description="",
-                lastModified=models.ChangeAuditStampsClass(
-                    lastModified=models.AuditStampClass(
-                        time=0, actor="urn:li:corpuser:unknown"
-                    )
-                ),
+                lastModified=models.ChangeAuditStampsClass(),
                 customProperties={},
-                chartEdges=[],
-                datasetEdges=[],
                 dashboards=[],
             )
         )
 
+    def _get_audit_stamps(self) -> models.ChangeAuditStampsClass:
+        """Get the audit stamps from the dashboard properties."""
+        return self._ensure_dashboard_props().lastModified
+
+    def _set_audit_stamps(self, audit_stamps: models.ChangeAuditStampsClass) -> None:
+        """Set the audit stamps on the dashboard properties."""
+        self._ensure_dashboard_props().lastModified = audit_stamps
+
     @property
     def name(self) -> str:
         """Get the name of the dashboard."""
@@ -240,23 +302,6 @@ class Dashboard(
         """Set the custom properties of the dashboard."""
         self._ensure_dashboard_props().customProperties = custom_properties
 
-    @property
-    def last_modified(self) -> Optional[datetime]:
-        """Get the last modification timestamp of the dashboard."""
-        props = self._ensure_dashboard_props()
-        if props.lastModified.lastModified.time == 0:
-            return None
-        return datetime.fromtimestamp(props.lastModified.lastModified.time)
-
-    def set_last_modified(self, last_modified: datetime) -> None:
-        """Set the last modification timestamp of the dashboard."""
-        self._ensure_dashboard_props().lastModified = models.ChangeAuditStampsClass(
-            lastModified=models.AuditStampClass(
-                time=int(last_modified.timestamp()),
-                actor="urn:li:corpuser:datahub",
-            ),
-        )
-
     @property
     def last_refreshed(self) -> Optional[datetime]:
         """Get the last refresh timestamp of the dashboard."""