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

sempy_labs/_connections.py

@@ -0,0 +1,234 @@
+import sempy
+import sempy.fabric as fabric
+import pandas as pd
+from typing import List, Optional, Union
+
+
+def create_connection_cloud(
+    name: str,
+    server_name: str,
+    database_name: str,
+    user_name: str,
+    password: str,
+    privacy_level: str,
+):
+
+    # https://review.learn.microsoft.com/en-us/rest/api/fabric/core/connections/create-connection?branch=features%2Fdmts&tabs=HTTP
+
+    df = pd.DataFrame(
+        columns=[
+            "Connection ID",
+            "Connection Name",
+            "Connectivity Type",
+            "Connection Type",
+            "Connection Path",
+            "Privacy Level",
+            "Credential Type",
+            "Single Sign On Type",
+            "Connection Encryption",
+            "Skip Test Connection",
+        ]
+    )
+
+    client = fabric.FabricRestClient()
+
+    request_body = {
+        "connectivityType": "ShareableCloud",
+        "name": name,
+        "connectionDetails": {
+            "type": "SQL",
+            "parameters": [
+                {"name": "server", "value": server_name},
+                {"name": "database", "value": database_name},
+            ],
+        },
+        "privacyLevel": privacy_level,
+        "credentialDetails": {
+            "singleSignOnType": "None",
+            "connectionEncryption": "NotEncrypted",
+            "skipTestConnection": False,
+            "credentials": {
+                "credentialType": "Basic",
+                "username": user_name,
+                "password": password,
+            },
+        },
+    }
+
+    response = client.post(f"/v1/connections", json=request_body)
+
+    if response.status_code == 200:
+        o = response.json()
+        new_data = {
+            "Connection Id": o["id"],
+            "Connection Name": o["name"],
+            "Connectivity Type": o["connectivityType"],
+            "Connection Type": o["connectionDetails"]["type"],
+            "Connection Path": o["connectionDetails"]["path"],
+            "Privacy Level": o["privacyLevel"],
+            "Credential Type": o["credentialDetails"]["credentialType"],
+            "Single Sign On Type": o["credentialDetails"]["singleSignOnType"],
+            "Connection Encryption": o["credentialDetails"]["connectionEncryption"],
+            "Skip Test Connection": o["credentialDetails"]["skipTestConnection"],
+        }
+        df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+        df["Skip Test Connection"] = df["Skip Test Connection"].astype(bool)
+
+        return df
+    else:
+        print(response.status_code)
+
+
+def create_connection_on_prem(
+    name: str,
+    gateway_id: str,
+    server_name: str,
+    database_name: str,
+    credentials: str,
+    privacy_level: str,
+):
+
+    df = pd.DataFrame(
+        columns=[
+            "Connection ID",
+            "Connection Name",
+            "Gateway ID",
+            "Connectivity Type",
+            "Connection Type",
+            "Connection Path",
+            "Privacy Level",
+            "Credential Type",
+            "Single Sign On Type",
+            "Connection Encryption",
+            "Skip Test Connection",
+        ]
+    )
+
+    client = fabric.FabricRestClient()
+
+    request_body = {
+        "connectivityType": "OnPremisesDataGateway",
+        "gatewayId": gateway_id,
+        "name": name,
+        "connectionDetails": {
+            "type": "SQL",
+            "parameters": [
+                {"name": "server", "value": server_name},
+                {"name": "database", "value": database_name},
+            ],
+        },
+        "privacyLevel": privacy_level,
+        "credentialDetails": {
+            "singleSignOnType": "None",
+            "connectionEncryption": "NotEncrypted",
+            "skipTestConnection": False,
+            "credentials": {
+                "credentialType": "Windows",
+                "values": [{"gatewayId": gateway_id, "credentials": credentials}],
+            },
+        },
+    }
+
+    response = client.post(f"/v1/connections", json=request_body)
+
+    if response.status_code == 200:
+        o = response.json()
+        new_data = {
+            "Connection Id": o["id"],
+            "Connection Name": o["name"],
+            "Gateway ID": o["gatewayId"],
+            "Connectivity Type": o["connectivityType"],
+            "Connection Type": o["connectionDetails"]["type"],
+            "Connection Path": o["connectionDetails"]["path"],
+            "Privacy Level": o["privacyLevel"],
+            "Credential Type": o["credentialDetails"]["credentialType"],
+            "Single Sign On Type": o["credentialDetails"]["singleSignOnType"],
+            "Connection Encryption": o["credentialDetails"]["connectionEncryption"],
+            "Skip Test Connection": o["credentialDetails"]["skipTestConnection"],
+        }
+        df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+        df["Skip Test Connection"] = df["Skip Test Connection"].astype(bool)
+
+        return df
+    else:
+        print(response.status_code)
+
+
+def create_connection_vnet(
+    name: str,
+    gateway_id: str,
+    server_name: str,
+    database_name: str,
+    user_name: str,
+    password: str,
+    privacy_level: str,
+):
+
+    df = pd.DataFrame(
+        columns=[
+            "Connection ID",
+            "Connection Name",
+            "Gateway ID",
+            "Connectivity Type",
+            "Connection Type",
+            "Connection Path",
+            "Privacy Level",
+            "Credential Type",
+            "Single Sign On Type",
+            "Connection Encryption",
+            "Skip Test Connection",
+        ]
+    )
+
+    client = fabric.FabricRestClient()
+
+    request_body = {
+        "connectivityType": "VirtualNetworkDataGateway",
+        "gatewayId": gateway_id,
+        "name": name,
+        "connectionDetails": {
+            "type": "SQL",
+            "parameters": [
+                {"name": "server", "value": server_name},
+                {"name": "database", "value": database_name},
+            ],
+        },
+        "privacyLevel": privacy_level,
+        "credentialDetails": {
+            "singleSignOnType": "None",
+            "connectionEncryption": "Encrypted",
+            "skipTestConnection": False,
+            "credentials": {
+                "credentialType": "Basic",
+                "username": user_name,
+                "password": password,
+            },
+        },
+    }
+
+    response = client.post(f"/v1/connections", json=request_body)
+
+    if response.status_code == 200:
+        o = response.json()
+        new_data = {
+            "Connection Id": o["id"],
+            "Connection Name": o["name"],
+            "Gateway ID": o["gatewayId"],
+            "Connectivity Type": o["connectivityType"],
+            "Connection Type": o["connectionDetails"]["type"],
+            "Connection Path": o["connectionDetails"]["path"],
+            "Privacy Level": o["privacyLevel"],
+            "Credential Type": o["credentialDetails"]["credentialType"],
+            "Single Sign On Type": o["credentialDetails"]["singleSignOnType"],
+            "Connection Encryption": o["credentialDetails"]["connectionEncryption"],
+            "Skip Test Connection": o["credentialDetails"]["skipTestConnection"],
+        }
+        df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+        df["Skip Test Connection"] = df["Skip Test Connection"].astype(bool)
+
+        return df
+    else:
+        print(response.status_code)

sempy_labs/_dax.py

@@ -0,0 +1,70 @@
+import sempy
+import sempy.fabric as fabric
+import pandas as pd
+from sempy_labs._helper_functions import resolve_dataset_id
+from typing import List, Optional, Union
+from sempy._utils._log import log
+
+
+@log
+def run_dax(
+    dataset: str,
+    dax_query: str,
+    user_name: Optional[str] = None,
+    workspace: Optional[str] = None,
+):
+    """
+    Runs a DAX query against a semantic model using the `REST API <https://learn.microsoft.com/en-us/rest/api/power-bi/datasets/execute-queries-in-group>`_.
+
+    Compared to evaluate_dax this allows passing the user name for impersonation.
+    Note that the REST API has significant limitations compared to the XMLA endpoint.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    dax_query : str
+        The DAX query.
+    user_name : str
+        The user name (i.e. hello@goodbye.com).
+        Defaults to None which resolves to no user impersonation.
+    workspace : str, default=None
+        The Fabric workspace name.
+        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 holding the result of the DAX query.
+    """
+
+    # https://learn.microsoft.com/en-us/rest/api/power-bi/datasets/execute-queries-in-group
+
+    if workspace is None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+    else:
+        workspace_id = fabric.resolve_workspace_id(workspace)
+
+    dataset_id = resolve_dataset_id(dataset=dataset, workspace=workspace)
+
+    if user_name is None:
+        request_body = {"queries": [{"query": dax_query}]}
+    else:
+        request_body = {
+            "queries": [{"query": dax_query}],
+            "impersonatedUserName": user_name,
+        }
+
+    client = fabric.PowerBIRestClient()
+    response = client.post(
+        f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}/executeQueries",
+        json=request_body,
+    )
+    data = response.json()["results"][0]["tables"]
+    column_names = data[0]["rows"][0].keys()
+    data_rows = [row.values() for item in data for row in item["rows"]]
+    df = pd.DataFrame(data_rows, columns=column_names)
+
+    return df

sempy_labs/_generate_semantic_model.py

@@ -0,0 +1,280 @@
+import sempy
+import sempy.fabric as fabric
+import pandas as pd
+import json, base64, time, os
+from typing import List, Optional, Union
+from sempy_labs._helper_functions import (
+    resolve_lakehouse_name,
+    resolve_workspace_name_and_id,
+)
+from sempy_labs.lakehouse._lakehouse import lakehouse_attached
+import sempy_labs._icons as icons
+
+
+def create_blank_semantic_model(
+    dataset: str,
+    compatibility_level: int = 1605,
+    workspace: Optional[str] = None,
+):
+    """
+    Creates a new blank semantic model (no tables/columns etc.).
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    compatibility_level : int
+        The compatibility level of the semantic model.
+        Defaults to 1605.
+    workspace : str, default=None
+        The Fabric workspace name.
+        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 workspace == None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+
+    if compatibility_level < 1500:
+        print(f"{icons.red_dot} Compatiblity level must be at least 1500.")
+        return
+
+    tmsl = f"""
+  {{
+    "createOrReplace": {{
+      "object": {{
+        "database": '{dataset}'
+      }},
+      "database": {{
+        "name": '{dataset}',
+        "compatibilityLevel": {compatibility_level},
+        "model": {{
+          "culture": "en-US",
+          "defaultPowerBIDataSourceVersion": "powerBI_V3"
+        }}
+      }}
+    }}
+  }}
+  """
+
+    fabric.execute_tmsl(script=tmsl, workspace=workspace)
+
+    return print(
+        f"{icons.green_dot} The '{dataset}' semantic model was created within the '{workspace}' workspace."
+    )
+
+
+def create_semantic_model_from_bim(
+    dataset: str, bim_file: str, workspace: Optional[str] = None
+):
+    """
+    Creates a new semantic model based on a Model.bim file.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    bim_file : str
+        The model.bim file.
+    workspace : str, default=None
+        The Fabric workspace name.
+        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)
+
+    objectType = "SemanticModel"
+
+    dfI = fabric.list_items(workspace=workspace, type=objectType)
+    dfI_filt = dfI[(dfI["Display Name"] == dataset)]
+
+    if len(dfI_filt) > 0:
+        print(
+            f"WARNING: '{dataset}' already exists as a semantic model in the '{workspace}' workspace."
+        )
+        return
+
+    client = fabric.FabricRestClient()
+    defPBIDataset = {"version": "1.0", "settings": {}}
+
+    def conv_b64(file):
+
+        loadJson = json.dumps(file)
+        f = base64.b64encode(loadJson.encode("utf-8")).decode("utf-8")
+
+        return f
+
+    payloadPBIDefinition = conv_b64(defPBIDataset)
+    payloadBim = conv_b64(bim_file)
+
+    request_body = {
+        "displayName": dataset,
+        "type": objectType,
+        "definition": {
+            "parts": [
+                {
+                    "path": "model.bim",
+                    "payload": payloadBim,
+                    "payloadType": "InlineBase64",
+                },
+                {
+                    "path": "definition.pbidataset",
+                    "payload": payloadPBIDefinition,
+                    "payloadType": "InlineBase64",
+                },
+            ]
+        },
+    }
+
+    response = client.post(f"/v1/workspaces/{workspace_id}/items", json=request_body)
+
+    if response.status_code == 201:
+        print(
+            f"The '{dataset}' semantic model has been created within the '{workspace}' workspace."
+        )
+        print(response.json())
+    elif response.status_code == 202:
+        operationId = response.headers["x-ms-operation-id"]
+        response = client.get(f"/v1/operations/{operationId}")
+        response_body = json.loads(response.content)
+        while response_body["status"] != "Succeeded":
+            time.sleep(3)
+            response = client.get(f"/v1/operations/{operationId}")
+            response_body = json.loads(response.content)
+        response = client.get(f"/v1/operations/{operationId}/result")
+        print(
+            f"The '{dataset}' semantic model has been created within the '{workspace}' workspace."
+        )
+        print(response.json())
+
+
+def deploy_semantic_model(
+    dataset: str,
+    new_dataset: Optional[str] = None,
+    workspace: Optional[str] = None,
+    new_dataset_workspace: Optional[str] = None,
+):
+    """
+    Deploys a semantic model based on an existing semantic model.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model to deploy.
+    new_dataset: str
+        Name of the new semantic model to be created.
+    workspace : str, default=None
+        The Fabric workspace name.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    new_dataset_workspace : str, default=None
+        The Fabric workspace name 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.
+
+    Returns
+    -------
+
+    """
+
+    if workspace == None:
+        workspace_id = fabric.get_workspace_id()
+        workspace = fabric.resolve_workspace_name(workspace_id)
+
+    if new_dataset_workspace == None:
+        new_dataset_workspace = workspace
+
+    if new_dataset is None:
+        new_dataset = dataset
+
+    if new_dataset == dataset and new_dataset_workspace == workspace:
+        print(
+            f"The 'dataset' and 'new_dataset' parameters have the same value. And, the 'workspace' and 'new_dataset_workspace' parameters have the same value. At least one of these must be different. Please update the parameters."
+        )
+        return
+
+    bim = get_semantic_model_bim(dataset=dataset, workspace=workspace)
+
+    create_semantic_model_from_bim(
+        dataset=new_dataset, bim_file=bim, workspace=new_dataset_workspace
+    )
+
+
+def get_semantic_model_bim(
+    dataset: str,
+    workspace: Optional[str] = None,
+    save_to_file_name: Optional[str] = None,
+):
+    """
+    Extracts the Model.bim file for a given semantic model.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    workspace : str, default=None
+        The Fabric workspace name.
+        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
+        If specified, saves the Model.bim as a file in the lakehouse attached to the notebook.
+
+    Returns
+    -------
+    str
+        The Model.bim file for the semantic model.
+    """
+
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    objType = "SemanticModel"
+    client = fabric.FabricRestClient()
+    itemList = fabric.list_items(workspace=workspace, type=objType)
+    itemListFilt = itemList[(itemList["Display Name"] == dataset)]
+    itemId = itemListFilt["Id"].iloc[0]
+    response = client.post(
+        f"/v1/workspaces/{workspace_id}/items/{itemId}/getDefinition"
+    )
+
+    if response.status_code == 200:
+        res = response.json()
+    elif response.status_code == 202:
+        operationId = response.headers["x-ms-operation-id"]
+        response = client.get(f"/v1/operations/{operationId}")
+        response_body = json.loads(response.content)
+        while response_body["status"] != "Succeeded":
+            time.sleep(3)
+            response = client.get(f"/v1/operations/{operationId}")
+            response_body = json.loads(response.content)
+        response = client.get(f"/v1/operations/{operationId}/result")
+        res = response.json()
+    df_items = pd.json_normalize(res["definition"]["parts"])
+    df_items_filt = df_items[df_items["path"] == "model.bim"]
+    payload = df_items_filt["payload"].iloc[0]
+    bimFile = base64.b64decode(payload).decode("utf-8")
+    bimJson = json.loads(bimFile)
+
+    if save_to_file_name is not None:
+        lakeAttach = lakehouse_attached()
+        if lakeAttach == False:
+            print(
+                f"In order to save the model.bim file, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
+            )
+            return
+
+        lakehouse_id = fabric.get_lakehouse_id()
+        lakehouse = resolve_lakehouse_name(lakehouse_id, workspace)
+        folderPath = "/lakehouse/default/Files"
+        fileExt = ".bim"
+        if not save_to_file_name.endswith(fileExt):
+            save_to_file_name = save_to_file_name + fileExt
+        filePath = os.path.join(folderPath, save_to_file_name)
+        with open(filePath, "w") as json_file:
+            json.dump(bimJson, json_file, indent=4)
+        print(
+            f"The .bim file for the '{dataset}' semantic model has been saved to the '{lakehouse}' in this location: '{filePath}'.\n\n"
+        )
+
+    return bimJson