semantic-link-labs 0.12.8__py3-none-any.whl

sempy_labs/lakehouse/_lakehouse.py

@@ -0,0 +1,351 @@
+from tqdm.auto import tqdm
+from typing import List, Optional, Union
+from sempy._utils._log import log
+from uuid import UUID
+from sempy_labs._helper_functions import (
+    _base_api,
+    resolve_lakehouse_name_and_id,
+    resolve_workspace_name_and_id,
+    _create_spark_session,
+    _pure_python_notebook,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+    resolve_workspace_id,
+)
+import sempy_labs._icons as icons
+import re
+import pandas as pd
+
+
+@log
+def list_lakehouses(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Shows the lakehouses within a workspace.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing the lakehouses within a workspace.
+    """
+
+    columns = {
+        "Lakehouse Name": "string",
+        "Lakehouse ID": "string",
+        "Description": "string",
+        "OneLake Tables Path": "string",
+        "OneLake Files Path": "string",
+        "SQL Endpoint Connection String": "string",
+        "SQL Endpoint ID": "string",
+        "SQL Endpoint Provisioning Status": "string",
+        "Schema Enabled": "bool",
+        "Default Schema": "string",
+        "Sensitivity Label Id": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    workspace_id = resolve_workspace_id(workspace)
+
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses",
+        uses_pagination=True,
+        client="fabric_sp",
+    )
+
+    rows = []
+    for r in responses:
+        for v in r.get("value", []):
+            prop = v.get("properties", {})
+            sqlEPProp = prop.get("sqlEndpointProperties", {})
+            default_schema = prop.get("defaultSchema", None)
+
+            rows.append(
+                {
+                    "Lakehouse Name": v.get("displayName"),
+                    "Lakehouse ID": v.get("id"),
+                    "Description": v.get("description"),
+                    "OneLake Tables Path": prop.get("oneLakeTablesPath"),
+                    "OneLake Files Path": prop.get("oneLakeFilesPath"),
+                    "SQL Endpoint Connection String": sqlEPProp.get("connectionString"),
+                    "SQL Endpoint ID": sqlEPProp.get("id"),
+                    "SQL Endpoint Provisioning Status": sqlEPProp.get(
+                        "provisioningStatus"
+                    ),
+                    "Schema Enabled": True if default_schema else False,
+                    "Default Schema": default_schema,
+                    "Sensitivity Label Id": v.get("sensitivityLabel", {}).get(
+                        "sensitivityLabelId"
+                    ),
+                }
+            )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+        _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+@log
+def lakehouse_attached() -> bool:
+    """
+    Identifies if a lakehouse is attached to the notebook.
+
+    Returns
+    -------
+    bool
+        Returns True if a lakehouse is attached to the notebook.
+    """
+
+    from sempy_labs._helper_functions import _get_fabric_context_setting
+
+    lake_id = _get_fabric_context_setting(name="trident.lakehouse.id")
+
+    if len(lake_id) > 0:
+        return True
+    else:
+        return False
+
+
+@log
+def _optimize_table(path):
+
+    if _pure_python_notebook():
+        from deltalake import DeltaTable
+
+        DeltaTable(path).optimize.compact()
+    else:
+        from delta import DeltaTable
+
+        spark = _create_spark_session()
+        DeltaTable.forPath(spark, path).optimize().executeCompaction()
+
+
+@log
+def _vacuum_table(path, retain_n_hours):
+
+    if _pure_python_notebook():
+        from deltalake import DeltaTable
+
+        DeltaTable(path).vacuum(retention_hours=retain_n_hours)
+    else:
+        from delta import DeltaTable
+
+        spark = _create_spark_session()
+        spark.conf.set("spark.databricks.delta.vacuum.parallelDelete.enabled", "true")
+        DeltaTable.forPath(spark, path).vacuum(retain_n_hours)
+
+
+@log
+def optimize_lakehouse_tables(
+    tables: Optional[Union[str, List[str]]] = None,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Runs the `OPTIMIZE <https://docs.delta.io/latest/optimizations-oss.html>`_ function over the specified lakehouse tables.
+
+    Parameters
+    ----------
+    tables : str | List[str], default=None
+        The table(s) to optimize.
+        Defaults to None which resovles to optimizing all tables within the lakehouse.
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
+
+    df = get_lakehouse_tables(
+        lakehouse=lakehouse, workspace=workspace, exclude_shortcuts=True
+    )
+    df_delta = df[df["Format"] == "delta"]
+
+    if isinstance(tables, str):
+        tables = [tables]
+
+    df_tables = df_delta[df_delta["Table Name"].isin(tables)] if tables else df_delta
+    df_tables.reset_index(drop=True, inplace=True)
+
+    total = len(df_tables)
+    for idx, r in (bar := tqdm(df_tables.iterrows(), total=total, bar_format="{desc}")):
+        table_name = r["Table Name"]
+        path = r["Location"]
+        bar.set_description(
+            f"Optimizing the '{table_name}' table ({idx + 1}/{total})..."
+        )
+        _optimize_table(path=path)
+
+
+@log
+def vacuum_lakehouse_tables(
+    tables: Optional[Union[str, List[str]]] = None,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+    retain_n_hours: Optional[int] = None,
+):
+    """
+    Runs the `VACUUM <https://docs.delta.io/latest/delta-utility.html#remove-files-no-longer-referenced-by-a-delta-table>`_ function over the specified lakehouse tables.
+
+    Parameters
+    ----------
+    tables : str | List[str] | None
+        The table(s) to vacuum. If no tables are specified, all tables in the lakehouse will be vacuumed.
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    retain_n_hours : int, default=None
+        The number of hours to retain historical versions of Delta table files.
+        Files older than this retention period will be deleted during the vacuum operation.
+        If not specified, the default retention period configured for the Delta table will be used.
+        The default retention period is 168 hours (7 days) unless manually configured via table properties.
+    """
+
+    from sempy_labs.lakehouse._get_lakehouse_tables import get_lakehouse_tables
+
+    df = get_lakehouse_tables(
+        lakehouse=lakehouse, workspace=workspace, exclude_shortcuts=True
+    )
+    df_delta = df[df["Format"] == "delta"]
+
+    if isinstance(tables, str):
+        tables = [tables]
+
+    df_tables = df_delta[df_delta["Table Name"].isin(tables)] if tables else df_delta
+    df_tables.reset_index(drop=True, inplace=True)
+
+    total = len(df_tables)
+    for idx, r in (bar := tqdm(df_tables.iterrows(), total=total, bar_format="{desc}")):
+        table_name = r["Table Name"]
+        path = r["Location"]
+        bar.set_description(f"Vacuuming the '{table_name}' table ({idx}/{total})...")
+        _vacuum_table(path=path, retain_n_hours=retain_n_hours)
+
+
+@log
+def run_table_maintenance(
+    table_name: str,
+    optimize: bool = False,
+    v_order: bool = False,
+    vacuum: bool = False,
+    retention_period: Optional[str] = None,
+    schema: Optional[str] = None,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+) -> pd.DataFrame:
+    """
+    Runs table maintenance operations on the specified table within the lakehouse.
+
+    This is a wrapper function for the following API: `Background Jobs - Run On Demand Table Maintenance <https://learn.microsoft.com/rest/api/fabric/lakehouse/background-jobs/run-on-demand-table-maintenance>`_.
+
+    Parameters
+    ----------
+    table_name : str
+        Name of the delta table on which to run maintenance operations.
+    optimize : bool, default=False
+        If True, the `OPTIMIZE <https://docs.delta.io/latest/optimizations-oss.html>`_ function will be run on the table.
+    v_order : bool, default=False
+        If True, v-order will be enabled for the table.
+    vacuum : bool, default=False
+        If True, the `VACUUM <https://docs.delta.io/latest/delta-utility.html#remove-files-no-longer-referenced-by-a-delta-table>`_ function will be run on the table.
+    retention_period : str, default=None
+        If specified, the retention period for the vacuum operation. Must be in the 'd:hh:mm:ss' format.
+    schema : str, default=None
+        The schema of the tables within the lakehouse.
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A DataFrame containing the job instance details of the table maintenance operation.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
+
+    if not optimize and not vacuum:
+        raise ValueError(
+            f"{icons.warning} At least one of 'optimize' or 'vacuum' must be set to True."
+        )
+    if not vacuum and retention_period is not None:
+        raise ValueError(
+            f"{icons.warning} The 'retention_period' parameter can only be set if 'vacuum' is set to True."
+        )
+    if retention_period is not None:
+
+        def is_valid_format(time_string):
+            pattern = r"^\d+:[0-2][0-9]:[0-5][0-9]:[0-5][0-9]$"
+            return bool(re.match(pattern, time_string))
+
+        if not is_valid_format(retention_period):
+            raise ValueError(
+                f"{icons.red_dot} The 'retention_period' parameter must be in the 'd:hh:mm:ss' format."
+            )
+
+    payload = {
+        "executionData": {
+            "tableName": table_name,
+        }
+    }
+    if schema is not None:
+        payload["executionData"]["schemaName"] = schema
+    if optimize:
+        payload["executionData"]["optimizeSettings"] = {}
+    if v_order:
+        payload["executionData"]["optimizeSettings"] = {"vOrder": True}
+    if vacuum:
+        payload["executionData"]["vacuumSettings"] = {}
+    if vacuum and retention_period is not None:
+        payload["executionData"]["vacuumSettings"]["retentionPeriod"] = retention_period
+
+    print(
+        f"{icons.in_progress} The table maintenance job for the '{table_name}' table in the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has been initiated."
+    )
+
+    df = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/jobs/instances?jobType=TableMaintenance",
+        method="post",
+        payload=payload,
+        status_codes=[200, 202],
+        client="fabric_sp",
+        lro_return_df=True,
+    )
+
+    status = df["Status"].iloc[0]
+
+    if status == "Completed":
+        print(
+            f"{icons.green_dot} The table maintenance job for the '{table_name}' table in the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has succeeded."
+        )
+    else:
+        print(status)
+        print(
+            f"{icons.red_dot} The table maintenance job for the '{table_name}' table in the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has failed."
+        )
+
+    return df

sempy_labs/lakehouse/_livy_sessions.py

@@ -0,0 +1,143 @@
+from sempy_labs._helper_functions import (
+    resolve_workspace_id,
+    resolve_lakehouse_id,
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+)
+import pandas as pd
+from typing import Optional
+from uuid import UUID
+from sempy._utils._log import log
+
+
+@log
+def list_livy_sessions(
+    lakehouse: Optional[str | UUID] = None, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a list of livy sessions from the specified item identifier.
+
+    This is a wrapper function for the following API: `Livy Sessions - List Livy Sessions <https://learn.microsoft.com/rest/api/fabric/lakehouse/livy-sessions/list-livy-sessions>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of livy sessions from the specified item identifier.
+    """
+
+    columns = {
+        "Spark Application Id": "string",
+        "State:": "string",
+        "Livy Id": "string",
+        "Origin": "string",
+        "Attempt Number": "int",
+        "Max Number Of Attempts": "int",
+        "Livy Name": "string",
+        "Submitter Id": "string",
+        "Submitter Type": "string",
+        "Item Workspace Id": "string",
+        "Item Id": "string",
+        "Item Reference Type": "string",
+        "Item Name": "string",
+        "Item Type": "string",
+        "Job Type": "string",
+        "Submitted Date Time": "str",
+        "Start Date Time": "str",
+        "End Date Time": "string",
+        "Queued Duration Value": "int",
+        "Queued Duration Time Unit": "string",
+        "Running Duration Value": "int",
+        "Running Duration Time Unit": "string",
+        "Total Duration Value": "int",
+        "Total Duration Time Unit": "string",
+        "Job Instance Id": "string",
+        "Creator Item Workspace Id": "string",
+        "Creator Item Id": "string",
+        "Creator Item Reference Type": "string",
+        "Creator Item Name": "string",
+        "Creator Item Type": "string",
+        "Cancellation Reason": "string",
+        "Capacity Id": "string",
+        "Operation Name": "string",
+        "Runtime Version": "string",
+        "Livy Session Item Resource Uri": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    workspace_id = resolve_workspace_id(workspace)
+    lakehouse_id = resolve_lakehouse_id(lakehouse, workspace_id)
+
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/livySessions",
+        uses_pagination=True,
+        client="fabric_sp",
+    )
+
+    rows = []
+    for r in responses:
+        for v in r.get("value", []):
+            queued_duration = v.get("queuedDuration", {})
+            running_duration = v.get("runningDuration", {})
+            total_duration = v.get("totalDuration", {})
+            rows.append(
+                {
+                    "Spark Application Id": v.get("sparkApplicationId"),
+                    "State:": v.get("state"),
+                    "Livy Id": v.get("livyId"),
+                    "Origin": v.get("origin"),
+                    "Attempt Number": v.get("attemptNumber"),
+                    "Max Number Of Attempts": v.get("maxNumberOfAttempts"),
+                    "Livy Name": v.get("livyName"),
+                    "Submitter Id": v["submitter"].get("id"),
+                    "Submitter Type": v["submitter"].get("type"),
+                    "Item Workspace Id": v["item"].get("workspaceId"),
+                    "Item Id": v["item"].get("itemId"),
+                    "Item Reference Type": v["item"].get("referenceType"),
+                    "Item Name": v.get("itemName"),
+                    "Item Type": v.get("itemType"),
+                    "Job Type": v.get("jobType"),
+                    "Submitted Date Time": v.get("submittedDateTime"),
+                    "Start Date Time": v.get("startDateTime"),
+                    "End Date Time": v.get("endDateTime"),
+                    "Queued Duration Value": queued_duration.get("value"),
+                    "Queued Duration Time Unit": queued_duration.get("timeUnit"),
+                    "Running Duration Value": running_duration.get("value"),
+                    "Running Duration Time Unit": running_duration.get("timeUnit"),
+                    "Total Duration Value": total_duration.get("value"),
+                    "Total Duration Time Unit": total_duration.get("timeUnit"),
+                    "Job Instance Id": v.get("jobInstanceId"),
+                    "Creator Item Workspace Id": v["creatorItem"].get("workspaceId"),
+                    "Creator Item Id": v["creatorItem"].get("itemId"),
+                    "Creator Item Reference Type": v["creatorItem"].get(
+                        "referenceType"
+                    ),
+                    "Creator Item Name": v.get("creatorItemName"),
+                    "Creator Item Type": v.get("creatorItemType"),
+                    "Cancellation Reason": v.get("cancellationReason"),
+                    "Capacity Id": v.get("capacityId"),
+                    "Operation Name": v.get("operationName"),
+                    "Runtime Version": v.get("runtimeVersion"),
+                    "Livy Session Item Resource Uri": v.get(
+                        "livySessionItemResourceUri"
+                    ),
+                }
+            )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+        _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df

sempy_labs/lakehouse/_materialized_lake_views.py

@@ -0,0 +1,157 @@
+from typing import Optional
+from sempy_labs._helper_functions import (
+    resolve_workspace_id,
+    resolve_workspace_name_and_id,
+    resolve_lakehouse_name_and_id,
+    _base_api,
+    _create_dataframe,
+)
+from uuid import UUID
+from sempy._utils._log import log
+import sempy_labs._icons as icons
+import pandas as pd
+
+
+@log
+def refresh_materialized_lake_views(
+    lakehouse: Optional[str | UUID] = None, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Run on-demand Refresh MaterializedLakeViews job instance.
+
+    This is a wrapper function for the following API: `Background Jobs - Run On Demand Refresh Materialized Lake Views <https://learn.microsoft.com/rest/api/fabric/lakehouse/background-jobs/run-on-demand-refresh-materialized-lake-views>`_.
+
+    Parameters
+    ----------
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A DataFrame containing the job instance details of the refresh materialized lake views operation.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
+
+    print(
+        f"{icons.in_progress} The refresh materialized lake views job for the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has been initiated."
+    )
+
+    df = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/jobs/instances?jobType=RefreshMaterializedLakeViews",
+        lro_return_df=True,
+        method="post",
+    )
+
+    status = df["Status"].iloc[0]
+
+    if status == "Completed":
+        print(
+            f"{icons.green_dot} The refresh materialized lake views job for the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has succeeded."
+        )
+    else:
+        print(status)
+        print(
+            f"{icons.red_dot} The refresh materialized lake views job for the '{lakehouse_name}' lakehouse within the '{workspace_name}' workspace has failed."
+        )
+
+    return df
+
+
+def _get_materialized_lake_views_schedule(
+    lakehouse: Optional[str | UUID] = None, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Get the schedule details for the MaterializedLakeViews job instance.
+
+    Parameters
+    ----------
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A DataFrame containing the schedule details of the materialized lake views job instance.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
+
+    columns = {
+        "Job Schedule Id": "string",
+        "Enabled": "bool",
+        "Created DateTime": "datetime",
+        "Type": "string",
+        "Start DateTime": "datetime",
+        "End DateTime": "datetime",
+        "Local TimeZoneId": "string",
+        "Interval": "int",
+        "Owner Id": "string",
+        "Owner Type": "string",
+    }
+
+    df = _create_dataframe(columns=columns)
+
+    response = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/jobs/RefreshMaterializedLakeViews/schedules",
+    )
+
+    df = pd.json_normalize(response.json().get("value", []))
+
+    return df
+
+
+@log
+def _delete_materialized_lake_view_schedule(
+    schedule_id: UUID,
+    lakehouse: Optional[str | UUID] = None,
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Delete an existing Refresh MaterializedLakeViews schedule for a lakehouse.
+
+    This is a wrapper function for the following API: `Background Jobs - Delete Refresh Materialized Lake Views Schedule <https://learn.microsoft.com/rest/api/fabric/lakehouse/background-jobs/delete-refresh-materialized-lake-views-schedule>`_.
+
+    Parameters
+    ----------
+    schedule_id : uuid.UUID
+        The ID of the job schedule to delete.
+    lakehouse : str | uuid.UUID, default=None
+        The Fabric lakehouse name or ID.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the lakehouse.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    (lakehouse_name, lakehouse_id) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=workspace_id
+    )
+
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/lakehouses/{lakehouse_id}/jobs/RefreshMaterializedLakeViews/schedules/{schedule_id}",
+        method="delete",
+    )
+
+    print(
+        f"{icons.green_dot} The materialized lake view schedule with ID '{schedule_id}' has been deleted from the '{lakehouse_name}' lakehouse within the '{workspace_id}' workspace."
+    )