semantic-link-labs 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

sempy_labs/_ml_experiments.py

@@ -1,12 +1,11 @@
-import sempy.fabric as fabric
 import pandas as pd
 from typing import Optional
 from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     _base_api,
-    _print_success,
-    resolve_item_id,
+    delete_item,
     _create_dataframe,
+    create_item,
 )
 from uuid import UUID
 
@@ -74,32 +73,15 @@ def create_ml_experiment(
     name: str
         Name of the ML experiment.
     description : str, default=None
-        A description of the environment.
+        A description of the ML experiment.
     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 = {"displayName": name}
-
-    if description:
-        payload["description"] = description
-
-    _base_api(
-        request=f"/v1/workspaces/{workspace_id}/mlExperiments",
-        method="post",
-        payload=payload,
-        status_codes=[201, 202],
-        lro_return_status_code=True,
-    )
-    _print_success(
-        item_name=name,
-        item_type="ML experiment",
-        workspace_name=workspace_name,
-        action="created",
+    create_item(
+        name=name, description=description, type="MLExperiment", workspace=workspace
     )
 
 
@@ -119,11 +101,4 @@ def delete_ml_experiment(name: str, workspace: Optional[str | UUID] = None):
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    item_id = resolve_item_id(item=name, type="MLExperiment", workspace=workspace)
-    fabric.delete_item(item_id=item_id, workspace=workspace)
-    _print_success(
-        item_name=name,
-        item_type="ML Experiment",
-        workspace_name=workspace,
-        action="deleted",
-    )
+    delete_item(item=name, type="MLExperiment", workspace=workspace)

sempy_labs/_ml_models.py

@@ -1,12 +1,11 @@
-import sempy.fabric as fabric
 import pandas as pd
 from typing import Optional
 from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     _base_api,
-    resolve_item_id,
-    _print_success,
+    delete_item,
     _create_dataframe,
+    create_item,
 )
 from uuid import UUID
 
@@ -81,26 +80,7 @@ def create_ml_model(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    payload = {"displayName": name}
-
-    if description:
-        payload["description"] = description
-
-    _base_api(
-        request=f"/v1/workspaces/{workspace_id}/mlModels",
-        method="post",
-        status_codes=[201, 202],
-        payload=payload,
-        lro_return_status_code=True,
-    )
-    _print_success(
-        item_name=name,
-        item_type="ML Model",
-        workspace_name=workspace_name,
-        action="created",
-    )
+    create_item(name=name, description=description, type="MLModel", workspace=workspace)
 
 
 def delete_ml_model(name: str | UUID, workspace: Optional[str | UUID] = None):
@@ -119,8 +99,4 @@ def delete_ml_model(name: str | UUID, workspace: Optional[str | UUID] = None):
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    item_id = resolve_item_id(item=name, type="MLModel", workspace=workspace)
-    fabric.delete_item(item_id=item_id, workspace=workspace)
-    _print_success(
-        item_name=name, item_type="ML Model", workspace_name=workspace, action="deleted"
-    )
+    delete_item(item=name, type="MLModel", workspace=workspace)

sempy_labs/_model_bpa.py

@@ -6,7 +6,6 @@ from IPython.display import display, HTML
 from sempy_labs._model_dependencies import get_model_calc_dependencies
 from sempy_labs._helper_functions import (
     format_dax_object_name,
-    resolve_lakehouse_name,
     create_relationship_name,
     save_as_delta_table,
     resolve_workspace_capacity,
@@ -43,6 +42,8 @@ def run_model_bpa(
     """
     Displays an HTML visualization of the results of the Best Practice Analyzer scan for a semantic model.
 
+    The Best Practice Analyzer rules are based on the rules defined `here <https://github.com/microsoft/Analysis-Services/tree/master/BestPracticeRules>`_. The framework for the Best Practice Analyzer and rules are based on the foundation set by `Tabular Editor <https://github.com/TabularEditor/TabularEditor>`_.
+
     Parameters
     ----------
     dataset : str | uuid.UUID
@@ -387,13 +388,7 @@ def run_model_bpa(
         dfExport = finalDF.copy()
         delta_table_name = "modelbparesults"
 
-        lakehouse_id = fabric.get_lakehouse_id()
-        lake_workspace = fabric.get_workspace_id()
-        lakehouse = resolve_lakehouse_name(
-            lakehouse_id=lakehouse_id, workspace=lake_workspace
-        )
-
-        lakeT = get_lakehouse_tables(lakehouse=lakehouse, workspace=lake_workspace)
+        lakeT = get_lakehouse_tables()
         lakeT_filt = lakeT[lakeT["Table Name"] == delta_table_name]
 
         dfExport["Severity"].replace(icons.severity_mapping, inplace=True)
@@ -401,9 +396,7 @@ def run_model_bpa(
         if len(lakeT_filt) == 0:
             runId = 1
         else:
-            max_run_id = _get_column_aggregate(
-                lakehouse=lakehouse, table_name=delta_table_name
-            )
+            max_run_id = _get_column_aggregate(table_name=delta_table_name)
             runId = max_run_id + 1
 
         now = datetime.datetime.now()

sempy_labs/_model_bpa_bulk.py

@@ -7,6 +7,8 @@ from sempy_labs._helper_functions import (
     resolve_workspace_capacity,
     retry,
     _get_column_aggregate,
+    resolve_workspace_id,
+    resolve_lakehouse_name_and_id,
 )
 from sempy_labs.lakehouse import (
     get_lakehouse_tables,
@@ -16,6 +18,7 @@ from sempy_labs._model_bpa import run_model_bpa
 from typing import Optional, List
 from sempy._utils._log import log
 import sempy_labs._icons as icons
+from uuid import UUID
 
 
 @log
@@ -66,17 +69,12 @@ def run_model_bpa_bulk(
 
     now = datetime.datetime.now()
     output_table = "modelbparesults"
-    lakehouse_workspace = fabric.resolve_workspace_name()
-    lakehouse_id = fabric.get_lakehouse_id()
-    lakehouse = resolve_lakehouse_name(
-        lakehouse_id=lakehouse_id, workspace=lakehouse_workspace
-    )
-    lakeT = get_lakehouse_tables(lakehouse=lakehouse, workspace=lakehouse_workspace)
+    lakeT = get_lakehouse_tables()
     lakeT_filt = lakeT[lakeT["Table Name"] == output_table]
     if len(lakeT_filt) == 0:
         runId = 1
     else:
-        max_run_id = _get_column_aggregate(lakehouse=lakehouse, table_name=output_table)
+        max_run_id = _get_column_aggregate(table_name=output_table)
         runId = max_run_id + 1
 
     if isinstance(workspace, str):
@@ -170,7 +168,7 @@ def run_model_bpa_bulk(
 
                     # Append save results individually for each workspace (so as not to create a giant dataframe)
                     print(
-                        f"{icons.in_progress} Saving the Model BPA results of the '{wksp}' workspace to the '{output_table}' within the '{lakehouse}' lakehouse within the '{lakehouse_workspace}' workspace..."
+                        f"{icons.in_progress} Saving the Model BPA results of the '{wksp}' workspace to the '{output_table}' within the lakehouse attached to this notebook..."
                     )
 
                     schema = {
@@ -195,8 +193,8 @@ def run_model_bpa_bulk(
 @log
 def create_model_bpa_semantic_model(
     dataset: Optional[str] = icons.model_bpa_name,
-    lakehouse: Optional[str] = None,
-    lakehouse_workspace: Optional[str] = None,
+    lakehouse: Optional[str | UUID] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
 ):
     """
     Dynamically generates a Direct Lake semantic model based on the 'modelbparesults' delta table which contains the Best Practice Analyzer results.
@@ -209,16 +207,15 @@ def create_model_bpa_semantic_model(
     ----------
     dataset : str, default='ModelBPA'
         Name of the semantic model to be created.
-    lakehouse : str, default=None
+    lakehouse : str | uuid.UUID, default=None
         Name of the Fabric lakehouse which contains the 'modelbparesults' delta table.
         Defaults to None which resolves to the default lakehouse attached to the notebook.
-    lakehouse_workspace : str, default=None
+    lakehouse_workspace : str | uuid.UUID, default=None
         The workspace in which the lakehouse 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.
     """
 
-    from sempy_labs._helper_functions import resolve_lakehouse_name
     from sempy_labs.directlake import (
         generate_shared_expression,
         add_table_to_direct_lake_semantic_model,
@@ -226,22 +223,21 @@ def create_model_bpa_semantic_model(
     from sempy_labs import create_blank_semantic_model, refresh_semantic_model
     from sempy_labs.tom import connect_semantic_model
 
-    lakehouse_workspace = fabric.resolve_workspace_name(lakehouse_workspace)
-
-    if lakehouse is None:
-        lakehouse_id = fabric.get_lakehouse_id()
-        lakehouse = resolve_lakehouse_name(
-            lakehouse_id=lakehouse_id, workspace=lakehouse_workspace
-        )
+    lakehouse_workspace_id = resolve_workspace_id(workspace=lakehouse_workspace)
+    (lakehouse_id, lakehouse_name) = resolve_lakehouse_name_and_id(
+        lakehouse=lakehouse, workspace=lakehouse_workspace_id
+    )
 
     # Generate the shared expression based on the lakehouse and lakehouse workspace
     expr = generate_shared_expression(
-        item_name=lakehouse, item_type="Lakehouse", workspace=lakehouse_workspace
+        item_name=lakehouse_name,
+        item_type="Lakehouse",
+        workspace=lakehouse_workspace_id,
     )
 
     # Create blank model
     create_blank_semantic_model(
-        dataset=dataset, workspace=lakehouse_workspace, overwrite=True
+        dataset=dataset, workspace=lakehouse_workspace_id, overwrite=True
     )
 
     @retry(
@@ -250,7 +246,7 @@ def create_model_bpa_semantic_model(
     )
     def dyn_connect():
         with connect_semantic_model(
-            dataset=dataset, readonly=True, workspace=lakehouse_workspace
+            dataset=dataset, readonly=True, workspace=lakehouse_workspace_id
         ) as tom:
 
             tom.model
@@ -259,7 +255,7 @@ def create_model_bpa_semantic_model(
     icons.sll_tags.append("ModelBPABulk")
     table_exists = False
     with connect_semantic_model(
-        dataset=dataset, readonly=False, workspace=lakehouse_workspace
+        dataset=dataset, readonly=False, workspace=lakehouse_workspace_id
     ) as tom:
         t_name = "BPAResults"
         t_name_full = f"'{t_name}'"
@@ -274,11 +270,11 @@ def create_model_bpa_semantic_model(
             dataset=dataset,
             table_name=t_name,
             lakehouse_table_name="modelbparesults",
-            workspace=lakehouse_workspace,
+            workspace=lakehouse_workspace_id,
             refresh=False,
         )
     with connect_semantic_model(
-        dataset=dataset, readonly=False, workspace=lakehouse_workspace
+        dataset=dataset, readonly=False, workspace=lakehouse_workspace_id
     ) as tom:
         # Fix column names
         for c in tom.all_columns():
@@ -377,4 +373,4 @@ def create_model_bpa_semantic_model(
         # tom.add_measure(table_name=t_name, measure_name='Rules Followed', expression="[Rules] - [Rules Violated]")
 
     # Refresh the model
-    refresh_semantic_model(dataset=dataset, workspace=lakehouse_workspace)
+    refresh_semantic_model(dataset=dataset, workspace=lakehouse_workspace_id)

sempy_labs/_mounted_data_factories.py

@@ -0,0 +1,119 @@
+import pandas as pd
+import json
+from typing import Optional
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+    _base_api,
+    _create_dataframe,
+    _update_dataframe_datatypes,
+    resolve_item_id,
+    _decode_b64,
+    delete_item,
+    get_item_definition,
+)
+
+from uuid import UUID
+
+
+def list_mounted_data_factories(
+    workspace: Optional[str | UUID] = None,
+) -> pd.DataFrame:
+    """
+    Shows a list of mounted data factories from the specified workspace.
+
+    This is a wrapper function for the following API: `Items - List Mounted Data Factories <https://learn.microsoft.com/rest/api/fabric/mounteddatafactory/items/list-mounted-data-factories>`_.
+
+    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 a list of mounted data factories from the specified workspace.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    columns = {
+        "Mounted Data Factory Name": "str",
+        "Mounted Data Factory Id": "str",
+        "Description": "str",
+    }
+
+    df = _create_dataframe(columns=columns)
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/mountedDataFactories",
+        uses_pagination=True,
+    )
+
+    for r in responses:
+        for v in r.get("value", []):
+            new_data = {
+                "Mounted Data Factory Name": v.get("displayName"),
+                "Mounted Data Factory Id": v.get("id"),
+                "Description": v.get("description"),
+            }
+
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    _update_dataframe_datatypes(dataframe=df, column_map=columns)
+
+    return df
+
+
+def get_mounted_data_factory_definition(
+    mounted_data_factory: str | UUID, workspace: Optional[str | UUID] = None
+) -> dict:
+    """
+    Returns the specified MountedDataFactory public definition.
+
+    This is a wrapper function for the following API: `Items - Get Mounted Data Factory Definition <https://learn.microsoft.com/rest/api/fabric/mounteddatafactory/items/get-mounted-data-factory-definition>`_.
+
+    Parameters
+    ----------
+    mounted_data_factory : str | uuid.UUID
+        The name or ID of the mounted data factory.
+    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
+    -------
+    dict
+        The 'mountedDataFactory-content.json' file from the mounted data factory definition.
+    """
+
+    return get_item_definition(
+        item=mounted_data_factory,
+        type="MountedDataFactory",
+        workspace=workspace,
+        return_dataframe=False,
+    )
+
+
+def delete_mounted_data_factory(
+    mounted_data_factory: str | UUID, workspace: Optional[str | UUID]
+):
+    """
+    Deletes the specified mounted data factory.
+
+    This is a wrapper function for the following API: `Items - Delete Mounted Data Factory <https://learn.microsoft.com/rest/api/fabric/mounteddatafactory/items/delete-mounted-data-factory>`_.
+
+    Parameters
+    ----------
+    mounted_data_factory : str | uuid.UUID
+        The name or ID of the mounted data factory.
+    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.
+    """
+
+    delete_item(
+        item=mounted_data_factory, type="MountedDataFactory", workspace=workspace
+    )

sempy_labs/_notebooks.py

@@ -10,6 +10,7 @@ from sempy_labs._helper_functions import (
     _decode_b64,
     _base_api,
     resolve_item_id,
+    create_item,
 )
 from sempy.fabric.exceptions import FabricHTTPException
 import os
@@ -183,35 +184,24 @@ def create_notebook(
         or if no lakehouse attached, resolves to the workspace of the notebook.
     """
 
-    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
     notebook_payload = base64.b64encode(notebook_content).decode("utf-8")
-
-    payload = {
-        "displayName": name,
-        "definition": {
-            "format": "ipynb",
-            "parts": [
-                {
-                    "path": f"{_notebook_prefix}.{type}",
-                    "payload": notebook_payload,
-                    "payloadType": "InlineBase64",
-                }
-            ],
-        },
+    definition_payload = {
+        "format": "ipynb",
+        "parts": [
+            {
+                "path": f"{_notebook_prefix}.{type}",
+                "payload": notebook_payload,
+                "payloadType": "InlineBase64",
+            }
+        ],
     }
-    if description is not None:
-        payload["description"] = description
 
-    _base_api(
-        request=f"v1/workspaces/{workspace_id}/notebooks",
-        payload=payload,
-        method="post",
-        lro_return_status_code=True,
-        status_codes=[201, 202],
-    )
-
-    print(
-        f"{icons.green_dot} The '{name}' notebook was created within the '{workspace_name}' workspace."
+    create_item(
+        name=name,
+        type="Notebook",
+        workspace=workspace,
+        description=description,
+        definition=definition_payload,
     )
 
 

sempy_labs/_one_lake_integration.py

@@ -5,6 +5,7 @@ from sempy._utils._log import log
 from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     resolve_dataset_name_and_id,
+    resolve_workspace_id,
 )
 import sempy_labs._icons as icons
 from uuid import UUID
@@ -43,7 +44,7 @@ def export_model_to_onelake(
         destination_workspace = workspace_name
         destination_workspace_id = workspace_id
     else:
-        destination_workspace_id = fabric.resolve_workspace_id(destination_workspace)
+        destination_workspace_id = resolve_workspace_id(workspace=destination_workspace)
 
     tmsl = f"""
     {{

sempy_labs/_semantic_models.py

@@ -7,6 +7,7 @@ from sempy_labs._helper_functions import (
     _update_dataframe_datatypes,
     resolve_workspace_name_and_id,
     resolve_dataset_name_and_id,
+    delete_item,
 )
 import sempy_labs._icons as icons
 
@@ -115,3 +116,22 @@ def enable_semantic_model_scheduled_refresh(
         print(
             f"{icons.green_dot} Scheduled refresh for the '{dataset_name}' within the '{workspace_name}' workspace has been enabled."
         )
+
+
+def delete_semantic_model(dataset: str | UUID, workspace: Optional[str | UUID] = None):
+    """
+    Deletes a semantic model.
+
+    This is a wrapper function for the following API: `Items - Delete Semantic Model <https://learn.microsoft.com/rest/api/fabric/semanticmodel/items/delete-semantic-model>`_.
+
+    Parameters
+    ----------
+    dataset: str | uuid.UUID
+        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
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    delete_item(item=dataset, type="SemanticModel", workspace=workspace)

sempy_labs/_sql.py

@@ -45,28 +45,33 @@ class ConnectBase:
         (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
 
         # Resolve the appropriate ID and name (warehouse or lakehouse)
-        if endpoint_type == "warehouse":
-            (resource_name, resource_id) = resolve_item_name_and_id(
-                item=item, type=endpoint_type.capitalize(), workspace=workspace_id
-            )
         if endpoint_type == "sqldatabase":
             # SQLDatabase is has special case for resolving the name and id
             (resource_name, resource_id) = resolve_item_name_and_id(
                 item=item, type="SQLDatabase", workspace=workspace_id
             )
-        else:
+        elif endpoint_type == "lakehouse":
             (resource_name, resource_id) = resolve_lakehouse_name_and_id(
-                lakehouse=item, workspace=workspace_id
+                lakehouse=item,
+                workspace=workspace_id,
+            )
+        else:
+            (resource_name, resource_id) = resolve_item_name_and_id(
+                item=item, workspace=workspace_id, type=endpoint_type.capitalize()
             )
 
+        endpoint_for_url = (
+            "sqlDatabases" if endpoint_type == "sqldatabase" else f"{endpoint_type}s"
+        )
+
         # Get the TDS endpoint
         response = _base_api(
-            request=f"v1/workspaces/{workspace_id}/{endpoint_type}s/{resource_id}"
+            request=f"v1/workspaces/{workspace_id}/{endpoint_for_url}/{resource_id}"
         )
 
         if endpoint_type == "warehouse":
             tds_endpoint = response.json().get("properties", {}).get("connectionString")
-        if endpoint_type == "sqldatabase":
+        elif endpoint_type == "sqldatabase":
             tds_endpoint = response.json().get("properties", {}).get("serverFqdn")
         else:
             tds_endpoint = (