semantic-link-labs 0.11.2__py3-none-any.whl → 0.12.0__py3-none-any.whl

sempy_labs/_generate_semantic_model.py

@@ -4,7 +4,7 @@ import json
 import os
 from typing import Optional, List
 from sempy._utils._log import log
-from ._helper_functions import (
+from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     resolve_dataset_name_and_id,
     _conv_b64,
@@ -13,9 +13,9 @@ from ._helper_functions import (
     _mount,
     resolve_workspace_id,
 )
-from .lakehouse._lakehouse import lakehouse_attached
+from sempy_labs.lakehouse._lakehouse import lakehouse_attached
 import sempy_labs._icons as icons
-from ._refresh_semantic_model import refresh_semantic_model
+from sempy_labs._refresh_semantic_model import refresh_semantic_model
 from uuid import UUID
 
 
@@ -284,13 +284,9 @@ def deploy_semantic_model(
         source_workspace
     )
 
-    if target_workspace is None:
-        target_workspace_name = source_workspace_name
-        target_workspace_id = resolve_workspace_id(workspace=target_workspace_name)
-    else:
-        (target_workspace_name, target_workspace_id) = resolve_workspace_name_and_id(
-            target_workspace
-        )
+    (target_workspace_name, target_workspace_id) = resolve_workspace_name_and_id(
+        target_workspace
+    )
 
     if target_dataset is None:
         target_dataset = source_dataset
@@ -306,13 +302,12 @@ def deploy_semantic_model(
 
     dfD = fabric.list_datasets(workspace=target_workspace_id, mode="rest")
     dfD_filt = dfD[dfD["Dataset Name"] == target_dataset]
-    if len(dfD_filt) > 0 and not overwrite:
+    if not dfD_filt.empty and not overwrite:
         raise ValueError(
             f"{icons.warning} The '{target_dataset}' semantic model already exists within the '{target_workspace_name}' workspace. The 'overwrite' parameter is set to False so the source semantic model was not deployed to the target destination."
         )
 
     if perspective is not None:
-
         from sempy_labs.tom import connect_semantic_model
 
         with connect_semantic_model(

sempy_labs/_git.py

@@ -1,7 +1,7 @@
 import pandas as pd
 import sempy_labs._icons as icons
 from typing import Optional, List
-from ._helper_functions import (
+from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     _base_api,
     _create_dataframe,

sempy_labs/_graphQL.py

@@ -1,7 +1,7 @@
 import pandas as pd
 from uuid import UUID
 from typing import Optional
-from ._helper_functions import (
+from sempy_labs._helper_functions import (
     _base_api,
     _create_dataframe,
     resolve_workspace_id,

sempy_labs/_helper_functions.py

@@ -20,6 +20,8 @@ import sempy_labs._authentication as auth
 from jsonpath_ng.ext import parse
 from jsonpath_ng.jsonpath import Fields, Index
 from sempy._utils._log import log
+from os import PathLike
+import sempy_labs._utils as utils
 
 
 def _build_url(url: str, params: dict) -> str:
@@ -225,8 +227,6 @@ def delete_item(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    from sempy_labs._utils import item_types
-
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     (item_name, item_id) = resolve_item_name_and_id(item, type, workspace_id)
     item_type = item_types.get(type)[0].lower()
@@ -238,6 +238,18 @@ def delete_item(
     )
 
 
+@log
+def create_folder_if_not_exists(
+    folder: str | PathLike, workspace: Optional[str | UUID] = None
+) -> UUID:
+    try:
+        x = fabric.resolve_folder_id(folder=folder, workspace=workspace)
+    except:
+        x = fabric.create_folder(folder=folder, workspace=workspace)
+
+    return x
+
+
 @log
 def create_item(
     name: str,
@@ -245,6 +257,7 @@ def create_item(
     description: Optional[str] = None,
     definition: Optional[dict] = None,
     workspace: Optional[str | UUID] = None,
+    folder: Optional[str | PathLike] = None,
 ):
     """
     Creates an item in a Fabric workspace.
@@ -263,12 +276,14 @@ def create_item(
         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.
+    folder : str | os.PathLike, default=None
+        The folder within the workspace where the item will be created.
+        Defaults to None which places the item in the root of the workspace.
     """
-    from sempy_labs._utils import item_types
 
     (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
-    item_type = item_types.get(type)[0].lower()
-    item_type_url = item_types.get(type)[1]
+    item_type = utils.item_types.get(type)[0].lower()
+    item_type_url = utils.item_types.get(type)[1]
 
     payload = {
         "displayName": name,
@@ -277,6 +292,10 @@ def create_item(
         payload["description"] = description
     if definition:
         payload["definition"] = definition
+    if folder:
+        payload["folderId"] = create_folder_if_not_exists(
+            folder=folder, workspace=workspace_id
+        )
 
     _base_api(
         request=f"/v1/workspaces/{workspace_id}/{item_type_url}",
@@ -290,8 +309,249 @@ def create_item(
     )
 
 
+@log
+def copy_item(
+    item: str | UUID,
+    type: str,
+    target_name: Optional[str] = None,
+    source_workspace: Optional[str | UUID] = None,
+    target_workspace: Optional[str | UUID] = None,
+    overwrite: bool = False,
+    keep_existing_bindings: bool = False,
+):
+    """
+    Copies an item (with its definition) from one location to another location.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    item : str | uuid.UUID
+        The name or ID of the item to be copied.
+    type : str
+        The type of the item.
+    target_name: str, default=None
+        The name of the item in the target workspace. Defaults to the same name as the source item.
+    source_workspace : str | uuid.UUID, default=None
+        The workspace name or ID in which the item exists.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    target_workspace : str | uuid.UUID, default=None
+        The workspace name or ID to which the item will be copied.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    overwrite : bool, default=False
+        If True, overwrites the item in the target workspace if it already exists.
+    keep_existing_bindings : bool, default=False
+        If True, ensures that reports are re-bound to the original semantic model.
+        If False, reports are binded to the semantic model to which the item is bound.
+    """
+
+    from sempy_labs.report import report_rebind
+
+    (item_name, item_id) = resolve_item_name_and_id(
+        item=item, type=type, workspace=source_workspace
+    )
+    (source_workspace_name, source_workspace_id) = resolve_workspace_name_and_id(
+        source_workspace
+    )
+    (target_workspace_name, target_workspace_id) = resolve_workspace_name_and_id(
+        target_workspace
+    )
+
+    if target_name is None:
+        target_name = item_name
+
+    if source_workspace_id == target_workspace_id and target_name == item_name:
+        raise ValueError(
+            f"{icons.red_dot} The source and target workspaces are the same and the target name is the same as the source name. No action taken."
+        )
+
+    type_url = utils.items.get(type)
+    result = _base_api(
+        request=f"v1/workspaces/{source_workspace_id}/{type_url}/{item_id}",
+        client="fabric_sp",
+    )
+    description = result.json().get("description")
+
+    payload = get_item_definition(
+        item=item_id,
+        type=type,
+        workspace=source_workspace_id,
+        return_dataframe=False,
+        decode=False,
+    )
+    payload["displayName"] = target_name
+    if description:
+        payload["description"] = description
+
+    # Check if item exists in target workspace
+    exists = False
+    try:
+        target_item_id = resolve_item_id(
+            item=target_name, type=type, workspace=target_workspace_id
+        )
+        exists = True
+    except Exception:
+        exists = False
+
+    if exists and not overwrite:
+        raise ValueError(
+            f"{icons.warning} The item '{target_name}' of type '{type}' already exists in the target workspace '{target_workspace_name}' and overwrite is set to False."
+        )
+    elif exists and overwrite:
+        # Update item definition
+        print(
+            f"{icons.in_progress} Updating existing item '{target_name}' of type '{type}' in the target workspace '{target_workspace_name}'..."
+        )
+        # Get the existing source model
+        if type == "Report" and keep_existing_bindings:
+            result = _base_api(
+                request=f"v1.0/myorg/groups/{target_workspace_id}/reports/{target_item_id}"
+            ).json()
+            dataset_id = result.get("datasetId")
+            dataset_workspace_id = result.get("datasetWorkspaceId")
+        _base_api(
+            request=f"/v1/workspaces/{target_workspace_id}/{type_url}/{target_item_id}/updateDefinition",
+            method="post",
+            client="fabric_sp",
+            payload=payload,
+            lro_return_status_code=True,
+            status_codes=None,
+        )
+        print(
+            f"{icons.green_dot} The item '{target_name}' of type '{type}' has been successfully updated in the target workspace '{target_workspace_name}'."
+        )
+
+        if keep_existing_bindings:
+            report_rebind(
+                report=target_item_id,
+                dataset=dataset_id,
+                report_workspace=target_workspace,
+                dataset_workspace=dataset_workspace_id,
+            )
+
+    else:
+        print(
+            f"{icons.in_progress} Creating new item '{target_name}' of type '{type}' in the target workspace '{target_workspace_name}'..."
+        )
+        create_item(
+            name=target_name,
+            type=type,
+            definition=payload["definition"],
+            workspace=target_workspace_id,
+        )
+
+
+@log
+def is_base64(s):
+    try:
+        # Add padding if needed
+        s_padded = s + "=" * (-len(s) % 4)
+        decoded = base64.b64decode(s_padded, validate=True)
+        # Optional: check if re-encoding gives the original (excluding padding)
+        return base64.b64encode(decoded).decode().rstrip("=") == s.rstrip("=")
+    except Exception:
+        return False
+
+
+@log
+def decode_payload(payload):
+
+    if is_base64(payload):
+        try:
+            decoded_payload = json.loads(base64.b64decode(payload).decode("utf-8"))
+        except Exception:
+            decoded_payload = base64.b64decode(payload)
+    elif isinstance(payload, dict):
+        decoded_payload = payload
+    else:
+        raise ValueError("Payload must be a dictionary or a base64 encoded value.")
+
+    return decoded_payload
+
+
 @log
 def get_item_definition(
+    item: str | UUID,
+    type: str,
+    workspace: Optional[str | UUID] = None,
+    return_dataframe: bool = False,
+    decode: bool = True,
+    format: Optional[str] = None,
+) -> dict | pd.DataFrame:
+    """
+    Gets a Fabric item's defintion.
+
+    This is a wrapper function for the following API: `<https://learn.microsoft.com/rest/api/fabric/core/items/get-item-definition>`_.
+
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
+    Parameters
+    ----------
+    item : str | uuid.UUID
+        The name or ID of the item to be copied.
+    type : str
+        The `type <https://learn.microsoft.com/rest/api/fabric/core/items/list-items?tabs=HTTP#itemtype>`_ of the item.
+    target_name: str, default=None
+        The name of the item in the target workspace. Defaults to the same name as the source item.
+    workspace : str | uuid.UUID, default=None
+        The 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.
+    return_dataframe : bool, default=False
+        If True, returns a pandas dataframe.
+        If False, returns a dictionary.
+    decode : bool, default=True
+        If True, decodes the base64 payload.
+    format : str, default=None
+        The `format <https://learn.microsoft.com/rest/api/fabric/core/items/get-item-definition?tabs=HTTP#itemdefinition>`_ of the item definition.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    item_id = resolve_item_id(item=item, type=type, workspace=workspace_id)
+
+    item_type_url = utils.items.get(type)
+    if not item_type_url:
+        raise ValueError(f"{icons.red_dot} Invalid item type '{type}'.")
+
+    url = f"/v1/workspaces/{workspace_id}/{item_type_url}/{item_id}/getDefinition"
+    if format:
+        url += f"?format={format}"
+
+    result = _base_api(
+        request=url,
+        method="post",
+        status_codes=None,
+        lro_return_json=True,
+    )
+
+    if return_dataframe:
+        return pd.json_normalize(result["definition"]["parts"]).rename(
+            columns={
+                "path": "Path",
+                "payload": "Payload",
+                "payloadType": "Payload Type",
+            }
+        )
+
+    definition = {"definition": {"parts": []}}
+    if decode:
+        for part in result.get("definition", {}).get("parts", []):
+            path = part.get("path")
+            payload = part.get("payload")
+            decoded_payload = decode_payload(payload)
+
+            # Keep structure similar to original but replace payload with decoded version
+            definition["definition"]["parts"].append(
+                {"path": path, "payload": decoded_payload}
+            )
+    else:
+        return result
+
+
+@log
+def _get_item_definition(
     item: str | UUID,
     type: str,
     workspace: Optional[str | UUID] = None,
@@ -299,12 +559,11 @@ def get_item_definition(
     return_dataframe: bool = True,
     decode: bool = True,
 ):
-    from sempy_labs._utils import item_types
 
     workspace_id = resolve_workspace_id(workspace)
     item_id = resolve_item_id(item, type, workspace_id)
-    item_type_url = item_types.get(type)[1]
-    path = item_types.get(type)[2]
+    item_type_url = utils.item_types.get(type)[1]
+    path = utils.item_types.get(type)[2]
 
     url = f"/v1/workspaces/{workspace_id}/{item_type_url}/{item_id}/getDefinition"
     if format:
@@ -825,7 +1084,9 @@ def resolve_workspace_id(
 
 
 @log
-def resolve_workspace_name(workspace_id: Optional[UUID] = None) -> str:
+def resolve_workspace_name(
+    workspace_id: Optional[UUID] = None, throw_error: bool = True
+) -> str:
 
     if workspace_id is None:
         workspace_id = _get_fabric_context_setting(name="trident.workspace.id")
@@ -835,9 +1096,12 @@ def resolve_workspace_name(workspace_id: Optional[UUID] = None) -> str:
             request=f"/v1/workspaces/{workspace_id}", client="fabric_sp"
         ).json()
     except FabricHTTPException:
-        raise ValueError(
-            f"{icons.red_dot} The '{workspace_id}' workspace was not found."
-        )
+        if throw_error:
+            raise ValueError(
+                f"{icons.red_dot} The '{workspace_id}' workspace was not found."
+            )
+        else:
+            return workspace_id
 
     return response.get("displayName")
 
@@ -997,15 +1261,15 @@ def _decode_b64(file, format: Optional[str] = "utf-8"):
 
 @log
 def is_default_semantic_model(
-    dataset: str, workspace: Optional[str | UUID] = None
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
 ) -> bool:
     """
     Identifies whether a semantic model is a default semantic model.
 
     Parameters
     ----------
-    dataset : str
-        The name of the semantic model.
+    dataset : str | uuid.UUID
+        The name or ID 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
@@ -1017,7 +1281,10 @@ def is_default_semantic_model(
         A True/False value indicating whether the semantic model is a default semantic model.
     """
 
-    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    workspace_id = resolve_workspace_id(workspace)
+    (dataset_name, dataset_id) = resolve_item_name_and_id(
+        item=dataset, type="SemanticModel", workspace=workspace_id
+    )
 
     dfI = fabric.list_items(workspace=workspace_id)
     filtered_df = dfI.groupby("Display Name").filter(
@@ -1026,7 +1293,7 @@ def is_default_semantic_model(
     )
     default_semantic_models = filtered_df["Display Name"].unique().tolist()
 
-    return dataset in default_semantic_models
+    return dataset_name in default_semantic_models
 
 
 @log
@@ -1926,17 +2193,21 @@ def _base_api(
     if (lro_return_json or lro_return_status_code) and status_codes is None:
         status_codes = [200, 202]
 
-    def get_token(audience="pbi"):
-        return notebookutils.credentials.getToken(audience)
+    class FabricDefaultCredential(TokenCredential):
+
+        def get_token(self, *scopes, **kwargs) -> AccessToken:
+            from sempy.fabric._credentials import build_access_token
+
+            return build_access_token(notebookutils.credentials.getToken("pbi"))
 
     if isinstance(status_codes, int):
         status_codes = [status_codes]
 
     if client == "fabric":
-        c = fabric.FabricRestClient(token_provider=get_token)
+        c = fabric.FabricRestClient(credential=FabricDefaultCredential())
     elif client == "fabric_sp":
-        token = auth.token_provider.get() or get_token
-        c = fabric.FabricRestClient(token_provider=token)
+        token = auth.token_provider.get() or FabricDefaultCredential()
+        c = fabric.FabricRestClient(credential=token)
     elif client in ["azure", "graph"]:
         pass
     else:

sempy_labs/_job_scheduler.py

@@ -1,7 +1,7 @@
 from sempy._utils._log import log
 import pandas as pd
 from typing import Optional, List
-from ._helper_functions import (
+from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     resolve_item_name_and_id,
     _update_dataframe_datatypes,
@@ -22,6 +22,8 @@ def list_item_job_instances(
 
     This is a wrapper function for the following API: `Job Scheduler - List Item Job Instances <https://learn.microsoft.com/rest/api/fabric/core/job-scheduler/list-item-job-instances>`_.
 
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
     Parameters
     ----------
     item : str | uuid.UUID
@@ -62,6 +64,7 @@ def list_item_job_instances(
     responses = _base_api(
         request=f"v1/workspaces/{workspace_id}/items/{item_id}/jobs/instances",
         uses_pagination=True,
+        client="fabric_sp",
     )
 
     if not responses[0].get("value"):
@@ -185,6 +188,9 @@ def list_item_schedules(
         "Times": "string",
         "Owner Id": "string",
         "Owner Type": "string",
+        "Recurrence": "int",
+        "Occurrence Type": "string",
+        "Occurrence Day of Month": "int",
     }
     df = _create_dataframe(columns=columns)
 
@@ -210,6 +216,11 @@ def list_item_schedules(
                 "Times": config.get("times"),
                 "Owner Id": own.get("id"),
                 "Owner Type": own.get("type"),
+                "Recurrence": config.get("recurrence"),
+                "Occurrence Type": config.get("occurence", {}).get("occurrenceType"),
+                "Occurrence Day of Month": config.get("occurrence", {}).get(
+                    "dayOfMonth"
+                ),
             }
         )
 

sempy_labs/_kql_databases.py

@@ -1,6 +1,6 @@
 import pandas as pd
 from typing import Optional
-from ._helper_functions import (
+from sempy_labs._helper_functions import (
     _base_api,
     _create_dataframe,
     delete_item,

sempy_labs/_kql_querysets.py

@@ -1,7 +1,7 @@
 import pandas as pd
 import sempy_labs._icons as icons
 from typing import Optional
-from ._helper_functions import (
+from sempy_labs._helper_functions import (
     resolve_workspace_id,
     _base_api,
     _create_dataframe,
@@ -19,6 +19,8 @@ def list_kql_querysets(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
 
     This is a wrapper function for the following API: `Items - List KQL Querysets <https://learn.microsoft.com/rest/api/fabric/kqlqueryset/items/list-kql-querysets>`_.
 
+    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
@@ -42,7 +44,9 @@ def list_kql_querysets(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
     workspace_id = resolve_workspace_id(workspace)
 
     responses = _base_api(
-        request=f"v1/workspaces/{workspace_id}/kqlQuerysets", uses_pagination=True
+        request=f"v1/workspaces/{workspace_id}/kqlQuerysets",
+        uses_pagination=True,
+        client="fabric_sp",
     )
 
     rows = []
@@ -71,6 +75,8 @@ def create_kql_queryset(
 
     This is a wrapper function for the following API: `Items - Create KQL Queryset <https://learn.microsoft.com/rest/api/fabric/kqlqueryset/items/create-kql-queryset>`_.
 
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
     Parameters
     ----------
     name: str
@@ -97,6 +103,8 @@ def delete_kql_queryset(
 
     This is a wrapper function for the following API: `Items - Delete KQL Queryset <https://learn.microsoft.com/rest/api/fabric/kqlqueryset/items/delete-kql-queryset>`_.
 
+    Service Principal Authentication is supported (see `here <https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Service%20Principal.ipynb>`_ for examples).
+
     Parameters
     ----------
     kql_queryset: str | uuid.UUID

sempy_labs/_kusto.py

@@ -5,8 +5,8 @@ from sempy._utils._log import log
 import sempy_labs._icons as icons
 from typing import Optional
 from uuid import UUID
-from ._kql_databases import _resolve_cluster_uri
-from ._helper_functions import resolve_item_id
+from sempy_labs._kql_databases import _resolve_cluster_uri
+from sempy_labs._helper_functions import resolve_item_id
 
 
 @log