semantic-link-labs 0.8.9__py3-none-any.whl → 0.8.11__py3-none-any.whl

sempy_labs/_generate_semantic_model.py

@@ -6,7 +6,7 @@ from typing import Optional, List
 from sempy_labs._helper_functions import (
     resolve_lakehouse_name,
     resolve_workspace_name_and_id,
-    resolve_dataset_id,
+    resolve_dataset_name_and_id,
     _conv_b64,
     _decode_b64,
     lro,
@@ -14,12 +14,13 @@ from sempy_labs._helper_functions import (
 from sempy_labs.lakehouse._lakehouse import lakehouse_attached
 import sempy_labs._icons as icons
 from sempy_labs._refresh_semantic_model import refresh_semantic_model
+from uuid import UUID
 
 
 def create_blank_semantic_model(
     dataset: str,
     compatibility_level: int = 1605,
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     overwrite: bool = True,
 ):
     """
@@ -31,21 +32,21 @@ def create_blank_semantic_model(
         Name of the semantic model.
     compatibility_level : int, default=1605
         The compatibility level of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name.
+    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.
     overwrite : bool, default=False
         If set to True, overwrites the existing semantic model in the workspace if it exists.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    dfD = fabric.list_datasets(workspace=workspace, mode="rest")
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    dfD = fabric.list_datasets(workspace=workspace_id, mode="rest")
     dfD_filt = dfD[dfD["Dataset Name"] == dataset]
 
     if len(dfD_filt) > 0 and not overwrite:
         raise ValueError(
-            f"{icons.warning} The '{dataset}' semantic model already exists within the '{workspace}' workspace. The 'overwrite' parameter is set to False so the blank new semantic model was not created."
+            f"{icons.warning} The '{dataset}' semantic model already exists within the '{workspace_name}' workspace. The 'overwrite' parameter is set to False so the blank new semantic model was not created."
         )
 
     min_compat = 1500
@@ -109,15 +110,15 @@ def create_blank_semantic_model(
         }}
         """
 
-    fabric.execute_tmsl(script=tmsl, workspace=workspace)
+    fabric.execute_tmsl(script=tmsl, workspace=workspace_id)
 
     return print(
-        f"{icons.green_dot} The '{dataset}' semantic model was created within the '{workspace}' workspace."
+        f"{icons.green_dot} The '{dataset}' semantic model was created within the '{workspace_name}' workspace."
     )
 
 
 def create_semantic_model_from_bim(
-    dataset: str, bim_file: dict, workspace: Optional[str] = None
+    dataset: str, bim_file: dict, workspace: Optional[str | UUID] = None
 ):
     """
     Creates a new semantic model based on a Model.bim file.
@@ -130,20 +131,20 @@ def create_semantic_model_from_bim(
         Name of the semantic model.
     bim_file : dict
         The model.bim file.
-    workspace : str, default=None
-        The Fabric workspace name.
+    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, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
-    dfI = fabric.list_datasets(workspace=workspace, mode="rest")
+    dfI = fabric.list_datasets(workspace=workspace_id, mode="rest")
     dfI_filt = dfI[(dfI["Dataset Name"] == dataset)]
 
     if len(dfI_filt) > 0:
         raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model already exists as a semantic model in the '{workspace}' workspace."
+            f"{icons.red_dot} The '{dataset}' semantic model already exists as a semantic model in the '{workspace_name}' workspace."
         )
 
     client = fabric.FabricRestClient()
@@ -178,12 +179,12 @@ def create_semantic_model_from_bim(
     lro(client, response, status_codes=[201, 202])
 
     print(
-        f"{icons.green_dot} The '{dataset}' semantic model has been created within the '{workspace}' workspace."
+        f"{icons.green_dot} The '{dataset}' semantic model has been created within the '{workspace_name}' workspace."
     )
 
 
 def update_semantic_model_from_bim(
-    dataset: str, bim_file: dict, workspace: Optional[str] = None
+    dataset: str | UUID, bim_file: dict, workspace: Optional[str | UUID] = None
 ):
     """
     Updates a semantic model definition based on a Model.bim file.
@@ -192,25 +193,18 @@ def update_semantic_model_from_bim(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
     bim_file : dict
         The model.bim file.
-    workspace : str, default=None
-        The Fabric workspace name.
+    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, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    dfD = fabric.list_datasets(workspace=workspace, mode="rest")
-    dfD_filt = dfD[dfD["Dataset Name"] == dataset]
-    if len(dfD_filt) == 0:
-        raise ValueError(
-            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace}' workspace does not exist."
-        )
-    dataset_id = dfD_filt["Dataset Id"].iloc[0]
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     client = fabric.FabricRestClient()
     defPBIDataset = {"version": "1.0", "settings": {}}
@@ -219,7 +213,7 @@ def update_semantic_model_from_bim(
     payloadBim = _conv_b64(bim_file)
 
     request_body = {
-        "displayName": dataset,
+        "displayName": dataset_name,
         "definition": {
             "parts": [
                 {
@@ -244,15 +238,15 @@ def update_semantic_model_from_bim(
     lro(client, response, status_codes=[200, 202], return_status_code=True)
 
     print(
-        f"{icons.green_dot} The '{dataset}' semantic model has been updated within the '{workspace}' workspace."
+        f"{icons.green_dot} The '{dataset_name}' semantic model has been updated within the '{workspace_name}' workspace."
     )
 
 
 def deploy_semantic_model(
     source_dataset: str,
-    source_workspace: Optional[str] = None,
+    source_workspace: Optional[str | UUID] = None,
     target_dataset: Optional[str] = None,
-    target_workspace: Optional[str] = None,
+    target_workspace: Optional[str | UUID] = None,
     refresh_target_dataset: bool = True,
     overwrite: bool = False,
 ):
@@ -263,14 +257,14 @@ def deploy_semantic_model(
     ----------
     source_dataset : str
         Name of the semantic model to deploy.
-    source_workspace : str, default=None
-        The Fabric workspace name.
+    source_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.
     target_dataset: str
         Name of the new semantic model to be created.
-    target_workspace : str, default=None
-        The Fabric workspace name in which the new semantic model will be deployed.
+    target_workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the new semantic model will be deployed.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     refresh_target_dataset : bool, default=True
@@ -279,50 +273,59 @@ def deploy_semantic_model(
         If set to True, overwrites the existing semantic model in the workspace if it exists.
     """
 
-    source_workspace = fabric.resolve_workspace_name(source_workspace)
+    (source_workspace_name, source_workspace_id) = resolve_workspace_name_and_id(
+        source_workspace
+    )
 
     if target_workspace is None:
-        target_workspace = source_workspace
+        target_workspace_name = source_workspace_name
+        target_workspace_id = fabric.resolve_workspace_id(target_workspace_name)
+    else:
+        (target_workspace_name, target_workspace_id) = resolve_workspace_name_and_id(
+            target_workspace
+        )
 
     if target_dataset is None:
         target_dataset = source_dataset
 
-    if target_dataset == source_dataset and target_workspace == source_workspace:
+    if (
+        target_dataset == source_dataset
+        and target_workspace_name == source_workspace_name
+    ):
         raise ValueError(
             f"{icons.red_dot} The 'dataset' and 'new_dataset' parameters have the same value. And, the 'workspace' and 'new_dataset_workspace' "
             f"parameters have the same value. At least one of these must be different. Please update the parameters."
         )
 
-    dfD = fabric.list_datasets(workspace=target_workspace, mode="rest")
+    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:
         raise ValueError(
-            f"{icons.warning} The '{target_dataset}' semantic model already exists within the '{target_workspace}' workspace. The 'overwrite' parameter is set to False so the source semantic model was not deployed to the target destination."
+            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."
         )
 
-    bim = get_semantic_model_bim(dataset=source_dataset, workspace=source_workspace)
+    bim = get_semantic_model_bim(dataset=source_dataset, workspace=source_workspace_id)
 
     # Create the semantic model if the model does not exist
-    if len(dfD_filt) == 0:
+    if dfD_filt.empty:
         create_semantic_model_from_bim(
             dataset=target_dataset,
             bim_file=bim,
-            workspace=target_workspace,
-            overwrite=overwrite,
+            workspace=target_workspace_id,
         )
     # Update the semantic model if the model exists
     else:
         update_semantic_model_from_bim(
-            dataset=target_dataset, bim_file=bim, workspace=target_workspace
+            dataset=target_dataset, bim_file=bim, workspace=target_workspace_id
         )
 
     if refresh_target_dataset:
-        refresh_semantic_model(dataset=target_dataset, workspace=target_workspace)
+        refresh_semantic_model(dataset=target_dataset, workspace=target_workspace_id)
 
 
 def get_semantic_model_bim(
-    dataset: str,
-    workspace: Optional[str] = None,
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
     save_to_file_name: Optional[str] = None,
     lakehouse_workspace: Optional[str] = None,
 ) -> dict:
@@ -331,10 +334,10 @@ def get_semantic_model_bim(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
-    workspace : str, default=None
-        The Fabric workspace name in which the semantic model resides.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model resides.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.
     save_to_file_name : str, default=None
@@ -350,8 +353,14 @@ def get_semantic_model_bim(
         The Model.bim file for the semantic model.
     """
 
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
+
     bimJson = get_semantic_model_definition(
-        dataset=dataset, workspace=workspace, format="TMSL", return_dataframe=False
+        dataset=dataset_id,
+        workspace=workspace_id,
+        format="TMSL",
+        return_dataframe=False,
     )
 
     if save_to_file_name is not None:
@@ -371,16 +380,16 @@ def get_semantic_model_bim(
         with open(filePath, "w") as json_file:
             json.dump(bimJson, json_file, indent=4)
         print(
-            f"{icons.green_dot} The {fileExt} file for the '{dataset}' semantic model has been saved to the '{lakehouse}' in this location: '{filePath}'.\n\n"
+            f"{icons.green_dot} The {fileExt} file for the '{dataset_name}' semantic model has been saved to the '{lakehouse}' in this location: '{filePath}'.\n\n"
         )
 
     return bimJson
 
 
 def get_semantic_model_definition(
-    dataset: str,
+    dataset: str | UUID,
     format: str = "TMSL",
-    workspace: Optional[str] = None,
+    workspace: Optional[str | UUID] = None,
     return_dataframe: bool = True,
 ) -> pd.DataFrame | dict | List:
     """
@@ -390,12 +399,12 @@ def get_semantic_model_definition(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
     format : str, default="TMSL"
         The output format. Valid options are "TMSL" or "TMDL". "TMSL" returns the .bim file whereas "TMDL" returns the collection of TMDL files. Can also enter 'bim' for the TMSL version.
-    workspace : str, default=None
-        The Fabric workspace name in which the semantic model resides.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model resides.
         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=True
@@ -418,10 +427,10 @@ def get_semantic_model_definition(
             f"{icons.red_dot} Invalid format. Valid options: {valid_formats}."
         )
 
-    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     client = fabric.FabricRestClient()
-    dataset_id = resolve_dataset_id(dataset=dataset, workspace=workspace)
     response = client.post(
         f"/v1/workspaces/{workspace_id}/semanticModels/{dataset_id}/getDefinition?format={format}",
     )
@@ -445,21 +454,41 @@ def get_semantic_model_definition(
         return decoded_parts
 
 
-def get_semantic_model_size(dataset: str, workspace: Optional[str] = None):
+def get_semantic_model_size(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+):
+    """
+    Gets size of the semantic model in bytes.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model resides.
+        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
+    -------
+    int
+        The size of the semantic model in
+    """
 
-    workspace = fabric.resolve_workspace_name(workspace)
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     dict = fabric.evaluate_dax(
-        dataset=dataset,
-        workspace=workspace,
+        dataset=dataset_id,
+        workspace=workspace_id,
         dax_string="""
         EVALUATE SELECTCOLUMNS(FILTER(INFO.STORAGETABLECOLUMNS(), [COLUMN_TYPE] = "BASIC_DATA"),[DICTIONARY_SIZE])
         """,
     )
 
     used_size = fabric.evaluate_dax(
-        dataset=dataset,
-        workspace=workspace,
+        dataset=dataset_id,
+        workspace=workspace_id,
         dax_string="""
         EVALUATE SELECTCOLUMNS(INFO.STORAGETABLECOLUMNSEGMENTS(),[USED_SIZE])
         """,