semantic-link-labs 0.12.3__py3-none-any.whl → 0.12.4__py3-none-any.whl

sempy_labs/_sql_endpoints.py

@@ -128,10 +128,25 @@ def refresh_sql_endpoint_metadata(
     else:
         raise ValueError("Invalid type. Must be 'Lakehouse' or 'MirroredDatabase'.")
 
-    payload = None
     timeout_unit = timeout_unit.capitalize()
-    if timeout_unit != "Minutes" and timeout_value != 15:
-        payload = {"timeout": {"timeUnit": timeout_unit, "value": timeout_value}}
+    if timeout_unit not in ["Seconds", "Minutes", "Hours", "Days"]:
+        raise ValueError(
+            "Invalid timeout_unit. Must be 'Seconds', 'Minutes', 'Hours', or 'Days'."
+        )
+    if timeout_unit == "Hours" and timeout_value > 24:
+        raise ValueError("timeout_value cannot exceed 24 when timeout_unit is 'Hours'.")
+    if timeout_unit == "Days" and timeout_value > 1:
+        raise ValueError("timeout_value cannot exceed 1 when timeout_unit is 'Days'.")
+    if timeout_unit == "Minutes" and timeout_value > 1440:
+        raise ValueError(
+            "timeout_value cannot exceed 1440 when timeout_unit is 'Minutes'."
+        )
+    if timeout_unit == "Seconds" and timeout_value > 86400:
+        raise ValueError(
+            "timeout_value cannot exceed 86400 when timeout_unit is 'Seconds'."
+        )
+
+    payload = {"timeout": {"timeUnit": timeout_unit, "value": timeout_value}}
 
     result = _base_api(
         request=f"v1/workspaces/{workspace_id}/sqlEndpoints/{sql_endpoint_id}/refreshMetadata",

sempy_labs/_utils.py

@@ -66,4 +66,6 @@ items = {
     "DigitalTwinBuilder": "digitaltwinbuilders",
     "DigitalTwinBuilderFlow": "DigitalTwinBuilderFlows",
     "MirroredAzureDatabricksCatalog": "mirroredAzureDatabricksCatalogs",
+    "Map": "Maps",
+    "AnomalyDetector": "anomalydetectors",
 }

sempy_labs/admin/__init__.py

@@ -98,6 +98,10 @@ from ._sharing_links import (
     remove_all_sharing_links,
     remove_sharing_links,
 )
+from ._labels import (
+    bulk_set_labels,
+    bulk_remove_labels,
+)
 
 __all__ = [
     "list_items",
@@ -161,4 +165,6 @@ __all__ = [
     "rotate_tenant_key",
     "remove_all_sharing_links",
     "remove_sharing_links",
+    "bulk_set_labels",
+    "bulk_remove_labels",
 ]

sempy_labs/admin/_items.py

@@ -2,13 +2,13 @@ import pandas as pd
 from typing import Optional, Tuple
 from uuid import UUID
 import sempy_labs._icons as icons
-from ._basic_functions import (
+from sempy_labs.admin._basic_functions import (
     _resolve_workspace_name_and_id,
 )
-from ._capacities import (
+from sempy_labs.admin._capacities import (
     _resolve_capacity_name_and_id,
 )
-from .._helper_functions import (
+from sempy_labs._helper_functions import (
     _is_valid_uuid,
     _build_url,
     _base_api,

sempy_labs/admin/_labels.py

@@ -0,0 +1,211 @@
+from typing import Literal, List
+from uuid import UUID
+import sempy_labs._icons as icons
+from sempy_labs.admin._basic_functions import (
+    _resolve_workspace_name_and_id,
+)
+from sempy_labs.admin._items import (
+    list_items,
+)
+from sempy_labs._helper_functions import (
+    _is_valid_uuid,
+    _base_api,
+)
+from sempy._utils._log import log
+
+
+@log
+def bulk_set_labels(
+    items: List[dict],
+    label_id: UUID,
+    assignment_method: Literal["Standard", "Priviledged"] = "Standard",
+):
+    """
+    Sets sensitivity labels on Fabric items.
+
+    Note: Please use the sempy_labs.graph.resolve_sensitivity_label_id function to retrieve label IDs.
+
+    This is a wrapper function for the following API: `Labels - Bulk Set Labels <https://learn.microsoft.com/rest/api/fabric/admin/labels/bulk-set-labels>`_.
+
+    Parameters
+    ----------
+    items : List[dict]
+        A list of dictionaries containing the item details.
+
+        Example 1:
+        items = [
+            {
+            "id": "fe472f5e-636e-4c10-a1c6-7e9edc0b542a",
+            "type": "Dashboard"
+            },
+            {
+            "id": "fe472f5e-636e-4c10-a1c6-7e9edc0b542c",
+            "type": "Report"
+            },
+            {
+            "id": "fe472f5e-636e-4c10-a1c6-7e9edc0b542e",
+            "type": "SemanticModel"
+            },
+        ]
+
+        Example 2:
+        items = [
+            {
+            "id": "Dashboard 1",
+            "type": "Dashboard",
+            "workspace": "Sales Workspace"
+            },
+            {
+            "id": "Sales Report",
+            "type": "Report",
+            "workspace": "Sales Workspace"
+            },
+            {
+            "id": "KPI Model",
+            "type": "SemanticModel",
+            "workspace": "Workspace 2"
+            },
+        ]
+
+    label_id : uuid.UUID
+        The label ID, which must be in the user's label policy.
+    assignment_method : Literal["Standard", "Priviledged"], default="Standard"
+        Specifies whether the assigned label was set by an automated process or manually. Additional tenant setting property types may be added over time.
+    """
+
+    if assignment_method not in ["Standard", "Priviledged"]:
+        raise ValueError("assignment_method must be either 'Standard' or 'Priviledged'")
+
+    payload = {"items": []}
+    df = list_items()
+
+    for i in items:
+        item = i.get("item")
+        type = i.get("type")
+        workspace = i.get("workspace")
+        if _is_valid_uuid(item):
+            payload["items"].append(
+                {
+                    "id": item,
+                    "type": type,
+                }
+            )
+        else:
+            workspace_id = _resolve_workspace_name_and_id(workspace)[1]
+            df_filtered = df[
+                (df["Item Name"] == item)
+                & (df["Type"] == type)
+                & (df["Workspace Id"] == workspace_id)
+            ]
+            if df_filtered.empty:
+                raise ValueError(
+                    f"The item '{item}' of type '{type}' does not exist in workspace '{workspace}'."
+                )
+            else:
+                payload["items"].append(
+                    {
+                        "id": df_filtered["Item Id"].iloc[0],
+                        "type": type,
+                    }
+                )
+
+    payload["labelId"] = label_id
+    payload["assignmentMethod"] = assignment_method
+
+    _base_api(request="/v1/admin/items/bulkSetLabels", method="post", payload=payload)
+
+    print(
+        f"{icons.green_dot} Labels have been successfully set on the specified items."
+    )
+
+
+@log
+def bulk_remove_labels(
+    items: List[dict],
+):
+    """
+    Removes sensitivity labels from Fabric items.
+
+    This is a wrapper function for the following API: `Labels - Bulk Remove Labels <https://learn.microsoft.com/rest/api/fabric/admin/labels/bulk-remove-labels>`_.
+
+    Parameters
+    ----------
+    items : List[dict]
+        A list of dictionaries containing the item details.
+
+        Example 1:
+        items = [
+            {
+            "id": "fe472f5e-636e-4c10-a1c6-7e9edc0b542a",
+            "type": "Dashboard"
+            },
+            {
+            "id": "fe472f5e-636e-4c10-a1c6-7e9edc0b542c",
+            "type": "Report"
+            },
+            {
+            "id": "fe472f5e-636e-4c10-a1c6-7e9edc0b542e",
+            "type": "SemanticModel"
+            },
+        ]
+
+        Example 2:
+        items = [
+            {
+            "id": "Dashboard 1",
+            "type": "Dashboard",
+            "workspace": "Sales Workspace"
+            },
+            {
+            "id": "Sales Report",
+            "type": "Report",
+            "workspace": "Sales Workspace"
+            },
+            {
+            "id": "KPI Model",
+            "type": "SemanticModel",
+            "workspace": "Workspace 2"
+            },
+        ]
+    """
+
+    payload = {"items": []}
+    df = list_items()
+
+    for i in items:
+        item = i.get("item")
+        type = i.get("type")
+        workspace = i.get("workspace")
+        if _is_valid_uuid(item):
+            payload["items"].append(
+                {
+                    "id": item,
+                    "type": type,
+                }
+            )
+        else:
+            workspace_id = _resolve_workspace_name_and_id(workspace)[1]
+            df_filtered = df[
+                (df["Item Name"] == item)
+                & (df["Type"] == type)
+                & (df["Workspace Id"] == workspace_id)
+            ]
+            if df_filtered.empty:
+                raise ValueError(
+                    f"The item '{item}' of type '{type}' does not exist in workspace '{workspace}'."
+                )
+            else:
+                payload["items"].append(
+                    {
+                        "id": df_filtered["Item Id"].iloc[0],
+                        "type": type,
+                    }
+                )
+
+    _base_api(
+        request="/v1/admin/items/bulkRemoveLabels", method="post", payload=payload
+    )
+
+    print(
+        f"{icons.green_dot} Labels have been successfully removed from the specified items."
+    )

sempy_labs/directlake/_warm_cache.py

@@ -201,7 +201,9 @@ def _put_columns_into_memory(dataset, workspace, col_df, return_dataframe: bool
         if not dfT_filt.empty:
             row_count = dfT_filt["Row Count"].iloc[0]
             bar.set_description(f"Warming the '{table_name}' table...")
-            if row_count < row_limit:
+            if pd.isna(row_count):
+                pass
+            elif row_count < row_limit:
                 columns = col_df_filt["DAX Object"].tolist()
                 css = ", ".join(columns)
                 dax = f"EVALUATE TOPN(1, SELECTCOLUMNS('{table_name}', {css}))"

sempy_labs/eventstream/__init__.py

@@ -0,0 +1,37 @@
+from ._items import (
+    list_eventstreams,
+    create_eventstream,
+    delete_eventstream,
+    get_eventstream_definition,
+)
+from ._topology import (
+    get_eventstream_destination,
+    get_eventstream_destination_connection,
+    get_eventstream_source,
+    get_eventstream_source_connection,
+    get_eventstream_topology,
+    pause_eventstream,
+    pause_eventstream_destination,
+    pause_eventstream_source,
+    resume_eventstream,
+    resume_eventstream_destination,
+    resume_eventstream_source,
+)
+
+__all__ = [
+    "list_eventstreams",
+    "create_eventstream",
+    "delete_eventstream",
+    "get_eventstream_definition",
+    "get_eventstream_destination",
+    "get_eventstream_destination_connection",
+    "get_eventstream_source",
+    "get_eventstream_source_connection",
+    "get_eventstream_topology",
+    "pause_eventstream",
+    "pause_eventstream_destination",
+    "pause_eventstream_source",
+    "resume_eventstream",
+    "resume_eventstream_destination",
+    "resume_eventstream_source",
+]

sempy_labs/eventstream/_items.py

@@ -0,0 +1,263 @@
+import pandas as pd
+from typing import Optional
+from sempy_labs._helper_functions import (
+    _base_api,
+    delete_item,
+    _create_dataframe,
+    create_item,
+    resolve_workspace_id,
+    resolve_item_id,
+    _decode_b64,
+)
+from uuid import UUID
+import sempy_labs._icons as icons
+from sempy._utils._log import log
+import json
+
+
+@log
+def list_eventstreams(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Shows the eventstreams within a workspace.
+
+    This is a wrapper function for the following API: `Items - List Eventstreams <https://learn.microsoft.com/rest/api/fabric/environment/items/list-eventstreams>`_.
+
+    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 eventstreams within a workspace.
+    """
+
+    columns = {
+        "Eventstream Name": "string",
+        "Eventstream Id": "string",
+        "Description": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    workspace_id = resolve_workspace_id(workspace)
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/eventstreams", uses_pagination=True
+    )
+
+    rows = []
+    for r in responses:
+        for v in r.get("value", []):
+            rows.append(
+                {
+                    "Eventstream Name": v.get("displayName"),
+                    "Eventstream Id": v.get("id"),
+                    "Description": v.get("description"),
+                }
+            )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+
+    return df
+
+
+@log
+def create_eventstream(
+    name: str, description: Optional[str] = None, workspace: Optional[str | UUID] = None
+):
+    """
+    Creates a Fabric eventstream.
+
+    This is a wrapper function for the following API: `Items - Create Eventstream <https://learn.microsoft.com/rest/api/fabric/environment/items/create-eventstream>`_.
+
+    Parameters
+    ----------
+    name: str
+        Name of the eventstream.
+    description : str, default=None
+        A description of the environment.
+    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.
+    """
+
+    create_item(
+        name=name, description=description, type="Eventstream", workspace=workspace
+    )
+
+
+@log
+def delete_eventstream(
+    eventstream: str | UUID, workspace: Optional[str | UUID] = None, **kwargs
+):
+    """
+    Deletes a Fabric eventstream.
+
+    This is a wrapper function for the following API: `Items - Delete Eventstream <https://learn.microsoft.com/rest/api/fabric/environment/items/delete-eventstream>`_.
+
+    Parameters
+    ----------
+    eventstream: str | uuid.UUID
+        Name or ID of the eventstream.
+    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.
+    """
+
+    if "name" in kwargs:
+        eventstream = kwargs["name"]
+        print(
+            f"{icons.warning} The 'name' parameter is deprecated. Please use 'eventstream' instead."
+        )
+
+    delete_item(item=eventstream, type="Eventstream", workspace=workspace)
+
+
+@log
+def get_eventstream_definition(
+    eventstream: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    decode: bool = True,
+    return_dataframe: bool = False,
+) -> dict:
+
+    workspace_id = resolve_workspace_id(workspace)
+    item_id = resolve_item_id(item=eventstream, type="Eventstream", workspace=workspace)
+
+    result = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/eventstreams/{item_id}/getDefinition",
+        method="post",
+        client="fabric_sp",
+        status_codes=None,
+        lro_return_json=True,
+    )
+
+    if decode:
+        definition = {"definition": {"parts": []}}
+
+        for part in result.get("definition", {}).get("parts", []):
+            path = part.get("path")
+            payload = json.loads(_decode_b64(part.get("payload")))
+            definition["definition"]["parts"].append({"path": path, "payload": payload})
+    else:
+        definition = result.copy()
+
+    if return_dataframe:
+        df = pd.DataFrame(definition["definition"]["parts"])
+        df.columns = ["Path", "Payload", "Payload Type"]
+        return df
+    else:
+        return definition
+
+
+@log
+def list_eventstream_destinations(
+    eventstream: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Lists the destinations of the specified eventstream.
+
+    Parameters
+    ----------
+    eventstream : str | uuid.UUID
+        The name or ID of the eventstream.
+    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 destinations of the eventstream.
+    """
+
+    definition = get_eventstream_definition(
+        eventstream=eventstream, workspace=workspace
+    )
+
+    columns = {
+        "Destination Id": "string",
+        "Destination Name": "string",
+        "Destination Type": "string",
+    }
+
+    df = _create_dataframe(columns=columns)
+
+    rows = []
+    for part in definition.get("definition").get("parts"):
+        payload = part.get("payload")
+        if part.get("path") == "eventstream.json":
+            destinations = payload.get("destinations")
+            for d in destinations:
+                rows.append(
+                    {
+                        "Destination Id": d.get("id"),
+                        "Destination Name": d.get("name"),
+                        "Destination Type": d.get("type"),
+                    }
+                )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+
+    return df
+
+
+@log
+def list_eventstream_sources(
+    eventstream: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Lists the destinations of the specified eventstream.
+
+    Parameters
+    ----------
+    eventstream : str | uuid.UUID
+        The name or ID of the eventstream.
+    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 destinations of the eventstream.
+    """
+
+    definition = get_eventstream_definition(
+        eventstream=eventstream, workspace=workspace
+    )
+
+    columns = {
+        "Source Id": "string",
+        "Source Name": "string",
+        "Source Type": "string",
+    }
+
+    df = _create_dataframe(columns=columns)
+
+    rows = []
+    for part in definition.get("definition").get("parts"):
+        payload = part.get("payload")
+        if part.get("path") == "eventstream.json":
+            sources = payload.get("sources")
+            for s in sources:
+                rows.append(
+                    {
+                        "Source Id": s.get("id"),
+                        "Source Name": s.get("name"),
+                        "Source Type": s.get("type"),
+                    }
+                )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+
+    return df