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

sempy_labs/_list_functions.py

@@ -756,6 +756,53 @@ def update_item(
         )
 
 
+@log
+def list_user_defined_functions(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a list of the user-defined functions within a semantic model.
+
+    Parameters
+    ----------
+    dataset: str | uuid.UUID
+        Name or UUID of the semantic model.
+    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 the user-defined functions within a semantic model.
+    """
+
+    from sempy_labs.tom import connect_semantic_model
+
+    columns = {
+        "Function Name": "string",
+        "Expression": "string",
+        "Lineage Tag": "string",
+    }
+    df = _create_dataframe(columns=columns)
+    rows = []
+    with connect_semantic_model(dataset=dataset, workspace=workspace) as tom:
+        for f in tom.model.Functions:
+            rows.append(
+                {
+                    "Function Name": f.Name,
+                    "Expression": f.Expression,
+                    "Lineage Tag": f.LineageTag,
+                }
+            )
+
+    if rows:
+        df = pd.DataFrame(rows)
+
+    return df
+
+
 @log
 def list_relationships(
     dataset: str | UUID, workspace: Optional[str | UUID] = None, extended: bool = False
@@ -1484,15 +1531,14 @@ def list_semantic_model_errors(
 
     from sempy_labs.tom import connect_semantic_model
 
-    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
-    (dataset_name, dataset_id) = resolve_dataset_name_and_id(
-        dataset, workspace=workspace_id
+    df = pd.DataFrame(
+        columns=["Object Type", "Table Name", "Object Name", "Error Message"]
     )
 
     error_rows = []
 
     with connect_semantic_model(
-        dataset=dataset_id, workspace=workspace_id, readonly=True
+        dataset=dataset, workspace=workspace, readonly=True
     ) as tom:
         # Define mappings of TOM objects to object types and attributes
         error_checks = [
@@ -1546,6 +1592,7 @@ def list_semantic_model_errors(
                     else ""
                 ),
             ),
+            ("Function", tom.all_functions, lambda o: o.ErrorMessage),
         ]
 
         # Iterate over all error checks
@@ -1562,7 +1609,10 @@ def list_semantic_model_errors(
                         }
                     )
 
-    return pd.DataFrame(error_rows)
+    if error_rows:
+        df = pd.DataFrame(error_rows)
+
+    return df
 
 
 @log

sempy_labs/_managed_private_endpoints.py

@@ -2,6 +2,7 @@ import pandas as pd
 import sempy_labs._icons as icons
 from typing import Optional
 from sempy_labs._helper_functions import (
+    resolve_item_id,
     resolve_workspace_name_and_id,
     _is_valid_uuid,
     _base_api,
@@ -24,7 +25,7 @@ def create_managed_private_endpoint(
     """
     Creates a managed private endpoint.
 
-    This is a wrapper function for the following API: `Managed Private Endpoints - Create Workspace Managed Private Endpoint <https://learn.microsoft.com/rest/api/fabric/core/managed-private-endpoints/create-workspace-managed-private-endpoint>`.
+    This is a wrapper function for the following API: `Managed Private Endpoints - Create Workspace Managed Private Endpoint <https://learn.microsoft.com/rest/api/fabric/core/managed-private-endpoints/create-workspace-managed-private-endpoint>`_.
 
     Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
 
@@ -190,3 +191,64 @@ def delete_managed_private_endpoint(
         workspace_name=workspace_name,
         action="deleted",
     )
+
+
+@log
+def list_managed_private_endpoint_fqdns(
+    managed_private_endpoint: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows a list of fully qualified domain names (FQDNs) associated with the specified managed private endpoint.
+
+    This is a wrapper function for the following API: `Managed Private Endpoints - List FQDNs <https://learn.microsoft.com/rest/api/fabric/core/managed-private-endpoints/list-fqd-ns>`.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    managed_private_endpoint : str | uuid.UUID
+        The managed private endpoint name or ID.
+    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 fully qualified domain names (FQDNs) associated with the specified managed private endpoint.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    if _is_valid_uuid(managed_private_endpoint):
+        item_id = managed_private_endpoint
+    else:
+        df = list_managed_private_endpoints(workspace=workspace_id)
+        df_filt = df[df["Managed Private Endpoint Name"] == managed_private_endpoint]
+        if df_filt.empty:
+            raise ValueError(
+                f"{icons.red_dot} The '{managed_private_endpoint}' managed private endpoint does not exist within the workspace."
+            )
+        item_id = df_filt["Managed Private Endpoint Id"].iloc[0]
+
+    columns = {"FQDN": "str"}
+    df = _create_dataframe(columns=columns)
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/managedPrivateEndpoints/{item_id}/targetFQDNs",
+        uses_pagination=True,
+        client="fabric_sp",
+    )
+
+    rows = []
+    for r in responses:
+        for v in r.get("value", []):
+            rows.append(
+                {
+                    "FQDN": v,
+                }
+            )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+
+    return df

sempy_labs/_model_bpa.py

@@ -300,6 +300,10 @@ def run_model_bpa(
                 tom.all_partitions(),
                 lambda obj: format_dax_object_name(obj.Parent.Name, obj.Name),
             ),
+            "Function": (
+                tom.all_functions(),
+                lambda obj: obj.Name,
+            ),
         }
 
         for i, r in rules.iterrows():
@@ -320,6 +324,8 @@ def run_model_bpa(
                         x = ["Model"]
                 elif scope == "Measure":
                     x = [nm(obj) for obj in tom.all_measures() if expr(obj, tom)]
+                elif scope == "Function":
+                    x = [nm(obj) for obj in tom.all_functions() if expr(obj, tom)]
                 elif scope == "Column":
                     x = [nm(obj) for obj in tom.all_columns() if expr(obj, tom)]
                 elif scope == "Partition":

sempy_labs/_notebooks.py

@@ -163,7 +163,7 @@ def import_notebook_from_web(
     if len(dfI_filt) == 0:
         create_notebook(
             name=notebook_name,
-            notebook_content=response.content,
+            notebook_content=response.content.decode("utf-8"),
             workspace=workspace_id,
             description=description,
             format="ipynb",
@@ -216,7 +216,9 @@ def create_notebook(
         Defaults to None which places the notebook in the root of the workspace.
     """
 
-    notebook_payload = base64.b64encode(notebook_content).decode("utf-8")
+    notebook_payload = base64.b64encode(notebook_content.encode("utf-8")).decode(
+        "utf-8"
+    )
 
     definition_payload = {
         "parts": [

sempy_labs/_onelake.py

@@ -0,0 +1,131 @@
+from sempy_labs._helper_functions import (
+    _base_api,
+    resolve_workspace_id,
+    resolve_lakehouse_name_and_id,
+    resolve_workspace_name_and_id,
+)
+from sempy._utils._log import log
+from uuid import UUID
+from typing import Optional
+import pandas as pd
+import sempy_labs._icons as icons
+
+
+@log
+def get_onelake_settings(workspace: Optional[str | UUID] = None):
+    """
+    Obtains the workspace OneLake settings.
+
+    This is a wrapper function for the following API: `OneLake Settings - Get Settings <https://learn.microsoft.com/rest/api/fabric/core/onelake-settings/get-settings>`_.
+
+    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 name or ID of the workspace.
+        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
+        The workspace OneLake settings.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    result = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/onelake/settings", client="fabric_sp"
+    ).json()
+
+    d = result.get("diagnostics", {})
+    enabled = True if d.get("status", {}) == "Enabled" else False
+    rows = []
+    rows.append(
+        {
+            "Enabled": enabled,
+            "Destination Type": (
+                d.get("destination", {}).get("type", {}) if enabled else None
+            ),
+            "Destination Id": (
+                d.get("destination", {}).get("lakehouse", {}).get("itemId", {})
+                if enabled
+                else None
+            ),
+            "Destination Workspace Id": (
+                d.get("destination", {}).get("lakehouse", {}).get("workspaceId", {})
+                if enabled
+                else None
+            ),
+        }
+    )
+
+    return pd.DataFrame(rows)
+
+
+def modify_onelake_diagnostics(
+    workspace: Optional[str | UUID] = None,
+    enabled: bool = True,
+    destination_lakehouse: Optional[str | UUID] = None,
+    destination_workspace: Optional[str | UUID] = None,
+):
+    """
+    Obtains the workspace OneLake settings.
+
+    This is a wrapper function for the following API: `OneLake Settings - Modify Diagnostics <https://learn.microsoft.com/rest/api/fabric/core/onelake-settings/modify-diagnostics>`_.
+
+    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 name or ID of the workspace.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    enabled : bool, default=True
+        Whether to enable or disable OneLake diagnostics.
+    destination_lakehouse : str | uuid.UUID, default=None
+        The name or ID of the destination lakehouse.
+        Defaults to None which resolves to the lakehouse of the attached lakehouse
+        or if no lakehouse attached, resolves to the lakehouse of the notebook.
+    destination_workspace : str | uuid.UUID, default=None
+        The name or ID of the destination workspace.
+        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)
+    (destination_workspace_name, destination_workspace_id) = (
+        resolve_workspace_name_and_id(destination_workspace)
+    )
+    (destination_lakehouse_name, destination_lakehouse_id) = (
+        resolve_lakehouse_name_and_id(destination_lakehouse, destination_workspace_id)
+    )
+
+    if enabled:
+        payload = {
+            "status": "Enabled",
+            "destination": {
+                "type": "Lakehouse",
+                "lakehouse": {
+                    "referenceType": "ById",
+                    "itemId": destination_lakehouse_id,
+                    "workspaceId": destination_workspace_id,
+                },
+            },
+        }
+    else:
+        payload = {"status": "Disabled"}
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/onelake/settings/modifyDiagnostics",
+        client="fabric_sp",
+        method="post",
+        payload=payload,
+    )
+
+    if enabled:
+        print(
+            f"{icons.green_dot} OneLake diagnostics have been enabled and updated to use the '{destination_lakehouse_name}' lakehouse in the '{destination_workspace_name}' workspace as the destination."
+        )
+    else:
+        print(f"{icons.green_dot} OneLake diagnostics have been disabled.")

sempy_labs/_sql_audit_settings.py

@@ -0,0 +1,208 @@
+from sempy_labs._helper_functions import (
+    resolve_item_id,
+    resolve_workspace_name_and_id,
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+    resolve_workspace_id,
+    resolve_item_name_and_id,
+)
+import pandas as pd
+from typing import Optional, List, Literal
+import sempy_labs._icons as icons
+from uuid import UUID
+from sempy._utils._log import log
+
+
+def _get_base_url(item, type, workspace):
+
+    workspace_id = resolve_workspace_id(workspace)
+    item_id = resolve_item_id(item=item, type=type, workspace=workspace)
+
+    type_dict = {
+        "Warehouse": "warehouses",
+        "SQLEndpoint": "sqlEndpoints",
+    }
+    type_for_url = type_dict.get(type)
+
+    if type in ["SQLEndpoint", "Warehouse"]:
+        url = f"/v1/workspaces/{workspace_id}/{type_for_url}/{item_id}"
+    else:
+        raise ValueError(
+            f"{icons.red_dot} The type must be 'Warehouse' or 'SQLEndpoint'."
+        )
+
+    return url
+
+
+@log
+def get_sql_audit_settings(
+    item: str | UUID,
+    type: Literal["Warehouse", "SQLEndpoint"],
+    workspace: Optional[str | UUID] = None,
+) -> pd.DataFrame:
+    """
+    Shows the SQL audit settings of a Fabric item.
+
+    This is a wrapper function for the following API: `SQL Audit Settings - Get SQL Audit Settings <https://learn.microsoft.com/rest/api/fabric/warehouse/sql-audit-settings/get-sql-audit-settings>`_.
+
+    Service Principal Authentication is supported (see `here <https://learn.microsoft.com/rest/api/fabric/warehouse/sql-audit-settings/get-sql-audit-settings#service-principal-authentication>`_).
+
+    Parameters
+    ----------
+    item : str | uuid.UUID
+        The name or ID of the item (Warehouse or SQLEndpoint).
+    type : Literal['Warehouse', 'SQLEndpoint']
+        The type of the item. Must be 'Warehouse' or 'SQLEndpoint'.
+    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 containing the SQL audit settings of the specified warehouse.
+    """
+
+    columns = {
+        "State": "string",
+        "Retention Days": "int",
+        "Audit Actions And Group": "list",
+    }
+
+    df = _create_dataframe(columns=columns)
+
+    url = _get_base_url(item=item, type=type, workspace=workspace)
+    response = _base_api(
+        request=f"{url}/settings/sqlAudit",
+        client="fabric_sp",
+    ).json()
+
+    rows = []
+    rows.append(
+        {
+            "State": response.get("state"),
+            "Retention Days": response.get("retentionDays"),
+            "Audit Actions And Group": response.get("auditActionsAndGroups"),
+        }
+    )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
+        _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+@log
+def update_sql_audit_settings(
+    item: str | UUID,
+    type: Literal["Warehouse", "SQLEndpoint"],
+    workspace: Optional[str | UUID] = None,
+    retention_days: Optional[int] = None,
+    state: Optional[str] = None,
+):
+    """
+    Update settings associated with the item.
+
+    This is a wrapper function for the following API: SQL Audit Settings - Update SQL Audit Settings <https://learn.microsoft.com/rest/api/fabric/warehouse/sql-audit-settings/update-sql-audit-settings>`_.
+
+    Service Principal Authentication is supported (see `here <https://learn.microsoft.com/rest/api/fabric/warehouse/sql-audit-settings/get-sql-audit-settings#service-principal-authentication>`_).
+
+    Parameters
+    ----------
+    item : str | uuid.UUID
+        The name or ID of the item (Warehouse or SQLEndpoint).
+    type : Literal['Warehouse', 'SQLEndpoint']
+        The type of the item. Must be 'Warehouse' or 'SQLEndpoint'.
+    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.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    payload = {}
+    if retention_days is not None:
+        if not isinstance(retention_days, int) or retention_days < 0:
+            raise ValueError(
+                f"{icons.red_dot} retention_days must be a non-negative integer."
+            )
+        payload["retentionDays"] = retention_days
+    if state is not None:
+        state = state.capitalize()
+        if state not in ["Enabled", "Disabled"]:
+            raise ValueError(
+                f"{icons.red_dot} state must be either 'Enabled' or 'Disabled'."
+            )
+        payload["state"] = state
+
+    if not payload:
+        print(
+            f"{icons.info} No updates were made as neither retention_days nor state were provided."
+        )
+        return
+
+    url = _get_base_url(item=item, type=type, workspace=workspace)
+    _base_api(
+        request=f"{url}/settings/sqlAudit",
+        client="fabric_sp",
+        method="patch",
+        payload=payload,
+    )
+
+    print(
+        f"{icons.green_dot} The SQL audit settings for the '{item}' {type.lower()} within the '{workspace_name}' workspace have been updated accordingly."
+    )
+
+
+@log
+def set_audit_actions_and_group(
+    item: str | UUID,
+    type: Literal["Warehouse", "SQLEndpoint"],
+    sql_audit_groups: List[str],
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Update the audit actions and groups for this item.
+
+    This is a wrapper function for the following API: SQL Audit Settings - Set Audit Actions And Groups <https://learn.microsoft.com/rest/api/fabric/warehouse/sql-audit-settings/set-audit-actions-and-groups>`_.
+
+    Service Principal Authentication is supported (see `here <https://learn.microsoft.com/rest/api/fabric/warehouse/sql-audit-settings/get-sql-audit-settings#service-principal-authentication>`_).
+
+    Parameters
+    ----------
+    item : str | uuid.UUID
+        The name or ID of the item (Warehouse or SQLEndpoint).
+    type : Literal['Warehouse', 'SQLEndpoint']
+        The type of the item. Must be 'Warehouse' or 'SQLEndpoint'.
+    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.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    if (
+        not sql_audit_groups
+        or not isinstance(sql_audit_groups, list)
+        or not all(isinstance(item, str) for item in sql_audit_groups)
+    ):
+        raise ValueError(
+            f"{icons.red_dot} sql_audit_groups must be a non-empty list of strings."
+        )
+
+    url = _get_base_url(item=item, type=type, workspace=workspace)
+    _base_api(
+        request=f"{url}/settings/sqlAudit/setAuditActionsAndGroups",
+        client="fabric_sp",
+        method="post",
+        payload=sql_audit_groups,
+    )
+
+    print(
+        f"{icons.green_dot} The SQL audit actions and groups for the '{item}' {type.lower()} within the '{workspace_name}' workspace have been updated accordingly."
+    )

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/_basic_functions.py

@@ -1,10 +1,9 @@
 from typing import Optional, List, Union, Tuple
 from uuid import UUID
 import sempy_labs._icons as icons
-from .._helper_functions import (
+from sempy_labs._helper_functions import (
     _is_valid_uuid,
     _build_url,
-    _update_dataframe_datatypes,
     _base_api,
     _create_dataframe,
 )
@@ -337,16 +336,23 @@ def list_workspace_access_details(
         request=f"/v1/admin/workspaces/{workspace_id}/users", client="fabric_sp"
     )
 
+    rows = []
     for v in response.json().get("accessDetails", []):
-        new_data = {
-            "User Id": v.get("principal", {}).get("id"),
-            "User Name": v.get("principal", {}).get("displayName"),
-            "User Type": v.get("principal", {}).get("type"),
-            "Workspace Name": workspace_name,
-            "Workspace Id": workspace_id,
-            "Workspace Role": v.get("workspaceAccessDetails", {}).get("workspaceRole"),
-        }
-        df = pd.concat([df, pd.DataFrame([new_data])], ignore_index=True)
+        rows.append(
+            {
+                "User Id": v.get("principal", {}).get("id"),
+                "User Name": v.get("principal", {}).get("displayName"),
+                "User Type": v.get("principal", {}).get("type"),
+                "Workspace Name": workspace_name,
+                "Workspace Id": workspace_id,
+                "Workspace Role": v.get("workspaceAccessDetails", {}).get(
+                    "workspaceRole"
+                ),
+            }
+        )
+
+    if rows:
+        df = pd.DataFrame(rows, columns=list(columns.keys()))
 
     return df
 
@@ -454,6 +460,4 @@ def list_workspace_users(workspace: Optional[str | UUID] = None) -> pd.DataFrame
     if rows:
         df = pd.DataFrame(rows, columns=list(columns.keys()))
 
-    _update_dataframe_datatypes(dataframe=df, column_map=columns)
-
     return df

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,