semantic-link-labs 0.8.8__py3-none-any.whl → 0.8.10__py3-none-any.whl

sempy_labs/_git.py

@@ -277,43 +277,48 @@ def commit_to_git(
     workspace, workspace_id = resolve_workspace_name_and_id(workspace)
 
     gs = get_git_status(workspace=workspace)
-    workspace_head = gs["Workspace Head"].iloc[0]
+    if not gs.empty:
+        workspace_head = gs["Workspace Head"].iloc[0]
 
-    if item_ids is None:
-        commit_mode = "All"
-    else:
-        commit_mode = "Selective"
+        if item_ids is None:
+            commit_mode = "All"
+        else:
+            commit_mode = "Selective"
 
-    if isinstance(item_ids, str):
-        item_ids = [item_ids]
+        if isinstance(item_ids, str):
+            item_ids = [item_ids]
 
-    request_body = {
-        "mode": commit_mode,
-        "workspaceHead": workspace_head,
-        "comment": comment,
-    }
+        request_body = {
+            "mode": commit_mode,
+            "workspaceHead": workspace_head,
+            "comment": comment,
+        }
 
-    if item_ids is not None:
-        request_body["items"] = [{"objectId": item_id} for item_id in item_ids]
+        if item_ids is not None:
+            request_body["items"] = [{"objectId": item_id} for item_id in item_ids]
 
-    client = fabric.FabricRestClient()
-    response = client.post(
-        f"/v1/workspaces/{workspace_id}/git/commitToGit",
-        json=request_body,
-    )
+        client = fabric.FabricRestClient()
+        response = client.post(
+            f"/v1/workspaces/{workspace_id}/git/commitToGit",
+            json=request_body,
+        )
 
-    if response.status_code not in [200, 202]:
-        raise FabricHTTPException(response)
+        if response.status_code not in [200, 202]:
+            raise FabricHTTPException(response)
 
-    lro(client, response)
+        lro(client=client, response=response, return_status_code=True)
 
-    if commit_mode == "All":
-        print(
-            f"{icons.green_dot} All items within the '{workspace}' workspace have been committed to Git."
-        )
+        if commit_mode == "All":
+            print(
+                f"{icons.green_dot} All items within the '{workspace}' workspace have been committed to Git."
+            )
+        else:
+            print(
+                f"{icons.green_dot} The {item_ids} items within the '{workspace}' workspace have been committed to Git."
+            )
     else:
         print(
-            f"{icons.green_dot} The {item_ids} items ithin the '{workspace}' workspace have been committed to Git."
+            f"{icons.info} Git already up to date: no modified items found within the '{workspace}' workspace."
         )
 
 

sempy_labs/_helper_functions.py

@@ -160,14 +160,34 @@ def resolve_report_name(report_id: UUID, workspace: Optional[str] = None) -> str
     return obj
 
 
-def resolve_dataset_id(dataset: str, workspace: Optional[str] = None) -> UUID:
+def resolve_dataset_name_and_id(
+    dataset: str | UUID, workspace: Optional[str] = None
+) -> Tuple[str, UUID]:
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    if _is_valid_uuid(dataset):
+        dataset_id = dataset
+        dataset_name = fabric.resolve_item_name(
+            item_id=dataset_id, type="SemanticModel", workspace=workspace_id
+        )
+    else:
+        dataset_name = dataset
+        dataset_id = fabric.resolve_item_id(
+            item_name=dataset, type="SemanticModel", workspace=workspace_id
+        )
+
+    return dataset_name, dataset_id
+
+
+def resolve_dataset_id(dataset: str | UUID, workspace: Optional[str] = None) -> UUID:
     """
     Obtains the ID of the semantic model.
 
     Parameters
     ----------
-    dataset : str
-        The name of the semantic model.
+    dataset : str | UUID
+        The name or ID of the semantic model.
     workspace : str, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -179,15 +199,14 @@ def resolve_dataset_id(dataset: str, workspace: Optional[str] = None) -> UUID:
         The ID of the semantic model.
     """
 
-    if workspace is None:
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resolve_workspace_name(workspace_id)
-
-    obj = fabric.resolve_item_id(
-        item_name=dataset, type="SemanticModel", workspace=workspace
-    )
+    if _is_valid_uuid(dataset):
+        dataset_id = dataset
+    else:
+        dataset_id = fabric.resolve_item_id(
+            item_name=dataset, type="SemanticModel", workspace=workspace
+        )
 
-    return obj
+    return dataset_id
 
 
 def resolve_dataset_name(dataset_id: UUID, workspace: Optional[str] = None) -> str:
@@ -761,13 +780,19 @@ def get_capacity_id(workspace: Optional[str] = None) -> UUID:
         The capacity Id.
     """
 
-    workspace = fabric.resolve_workspace_name(workspace)
-    filter_condition = urllib.parse.quote(workspace)
-    dfW = fabric.list_workspaces(filter=f"name eq '{filter_condition}'")
-    if len(dfW) == 0:
-        raise ValueError(f"{icons.red_dot} The '{workspace}' does not exist'.")
+    if workspace is None:
+        capacity_id = _get_x_id(name="trident.capacity.id")
+    else:
+
+        workspace = fabric.resolve_workspace_name(workspace)
+        filter_condition = urllib.parse.quote(workspace)
+        dfW = fabric.list_workspaces(filter=f"name eq '{filter_condition}'")
+        if len(dfW) == 0:
+            raise ValueError(f"{icons.red_dot} The '{workspace}' does not exist'.")
+
+        capacity_id = dfW["Capacity Id"].iloc[0]
 
-    return dfW["Capacity Id"].iloc[0]
+    return capacity_id
 
 
 def get_capacity_name(workspace: Optional[str] = None) -> str:
@@ -1167,20 +1192,20 @@ def _make_list_unique(my_list):
 
 def _get_partition_map(dataset: str, workspace: Optional[str] = None) -> pd.DataFrame:
 
-    if workspace is None:
-        workspace = fabric.resolve_workspace_name()
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
 
     partitions = fabric.evaluate_dax(
-        dataset=dataset,
-        workspace=workspace,
+        dataset=dataset_id,
+        workspace=workspace_id,
         dax_string="""
     select [ID] AS [PartitionID], [TableID], [Name] AS [PartitionName] from $system.tmschema_partitions
     """,
     )
 
     tables = fabric.evaluate_dax(
-        dataset=dataset,
-        workspace=workspace,
+        dataset=dataset_id,
+        workspace=workspace_id,
         dax_string="""
     select [ID] AS [TableID], [Name] AS [TableName] from $system.tmschema_tables
     """,
@@ -1352,3 +1377,15 @@ def _is_valid_uuid(
         return True
     except ValueError:
         return False
+
+
+def _get_fabric_context_setting(name: str):
+
+    from synapse.ml.internal_utils.session_utils import get_fabric_context
+
+    return get_fabric_context().get(name)
+
+
+def get_tenant_id():
+
+    _get_fabric_context_setting(name="trident.tenant.id")

sempy_labs/_list_functions.py

@@ -7,23 +7,25 @@ from sempy_labs._helper_functions import (
     pagination,
     resolve_item_type,
     format_dax_object_name,
+    resolve_dataset_name_and_id,
 )
 import pandas as pd
 from typing import Optional
 import sempy_labs._icons as icons
 from sempy.fabric.exceptions import FabricHTTPException
+from uuid import UUID
 
 
 def get_object_level_security(
-    dataset: str, workspace: Optional[str] = None
+    dataset: str | UUID, workspace: Optional[str] = None
 ) -> pd.DataFrame:
     """
     Shows the object level security for the semantic model.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | UUID
+        Name or ID of the semantic model.
     workspace : str, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -37,12 +39,13 @@ def get_object_level_security(
 
     from sempy_labs.tom import connect_semantic_model
 
-    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)
 
     df = pd.DataFrame(columns=["Role Name", "Object Type", "Table Name", "Object Name"])
 
     with connect_semantic_model(
-        dataset=dataset, readonly=True, workspace=workspace
+        dataset=dataset_id, readonly=True, workspace=workspace_id
     ) as tom:
 
         for r in tom.model.Roles:
@@ -82,15 +85,15 @@ def get_object_level_security(
 
 
 def list_tables(
-    dataset: str, workspace: Optional[str] = None, extended: bool = False
+    dataset: str | UUID, workspace: Optional[str] = None, extended: bool = False
 ) -> pd.DataFrame:
     """
     Shows a semantic model's tables and their properties.
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | UUID
+        Name or ID of the semantic model.
     workspace : str, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -106,7 +109,8 @@ def list_tables(
 
     from sempy_labs.tom import connect_semantic_model
 
-    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)
 
     df = pd.DataFrame(
         columns=[
@@ -121,20 +125,20 @@ def list_tables(
     )
 
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=True
+        dataset=dataset_id, workspace=workspace_id, readonly=True
     ) as tom:
         if extended:
             dict_df = fabric.evaluate_dax(
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
                 dax_string="""
                 EVALUATE SELECTCOLUMNS(FILTER(INFO.STORAGETABLECOLUMNS(), [COLUMN_TYPE] = "BASIC_DATA"),[DIMENSION_NAME],[DICTIONARY_SIZE])
                 """,
             )
             dict_sum = dict_df.groupby("[DIMENSION_NAME]")["[DICTIONARY_SIZE]"].sum()
             data = fabric.evaluate_dax(
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
                 dax_string="""EVALUATE SELECTCOLUMNS(INFO.STORAGETABLECOLUMNSEGMENTS(),[TABLE_ID],[DIMENSION_NAME],[USED_SIZE])""",
             )
             data_sum = (
@@ -162,8 +166,8 @@ def list_tables(
                 .sum()
             )
             rc = fabric.evaluate_dax(
-                dataset=dataset,
-                workspace=workspace,
+                dataset=dataset_id,
+                workspace=workspace_id,
                 dax_string="""
                 SELECT [DIMENSION_NAME],[ROWS_COUNT] FROM $SYSTEM.DISCOVER_STORAGE_TABLES
                 WHERE RIGHT ( LEFT ( TABLE_ID, 2 ), 1 ) <> '$'
@@ -616,11 +620,7 @@ def list_dashboards(workspace: Optional[str] = None) -> pd.DataFrame:
         ]
     )
 
-    if workspace == "None":
-        workspace_id = fabric.get_workspace_id()
-        workspace = fabric.resovle_workspace_name(workspace_id)
-    else:
-        workspace_id = fabric.resolve_workspace_id(workspace)
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
     client = fabric.PowerBIRestClient()
     response = client.get(f"/v1.0/myorg/groups/{workspace_id}/dashboards")
@@ -635,8 +635,8 @@ def list_dashboards(workspace: Optional[str] = None) -> pd.DataFrame:
             "Web URL": v.get("webUrl"),
             "Embed URL": v.get("embedUrl"),
             "Data Classification": v.get("dataClassification"),
-            "Users": [v.get("users")],
-            "Subscriptions": [v.get("subscriptions")],
+            "Users": v.get("users"),
+            "Subscriptions": v.get("subscriptions"),
         }
         df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
@@ -854,15 +854,15 @@ def update_item(
 
 
 def list_relationships(
-    dataset: str, workspace: Optional[str] = None, extended: bool = False
+    dataset: str | UUID, workspace: Optional[str] = None, extended: bool = False
 ) -> pd.DataFrame:
     """
     Shows a semantic model's relationships and their properties.
 
     Parameters
     ----------
-    dataset: str
-        Name of the semantic model.
+    dataset: str | UUID
+        Name or UUID of the semantic model.
     workspace : str, default=None
         The Fabric workspace name.
         Defaults to None which resolves to the workspace of the attached lakehouse
@@ -876,17 +876,18 @@ def list_relationships(
         A pandas dataframe showing the object level security for the semantic model.
     """
 
-    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)
 
-    dfR = fabric.list_relationships(dataset=dataset, workspace=workspace)
+    dfR = fabric.list_relationships(dataset=dataset_id, workspace=workspace_id)
     dfR["From Object"] = format_dax_object_name(dfR["From Table"], dfR["From Column"])
     dfR["To Object"] = format_dax_object_name(dfR["To Table"], dfR["To Column"])
 
     if extended:
         # Used to map the Relationship IDs
         rel = fabric.evaluate_dax(
-            dataset=dataset,
-            workspace=workspace,
+            dataset=dataset_id,
+            workspace=workspace_id,
             dax_string="""
                 SELECT
                 [ID] AS [RelationshipID]
@@ -897,8 +898,8 @@ def list_relationships(
 
         # USED_SIZE shows the Relationship Size where TABLE_ID starts with R$
         cs = fabric.evaluate_dax(
-            dataset=dataset,
-            workspace=workspace,
+            dataset=dataset_id,
+            workspace=workspace_id,
             dax_string="""
                 SELECT
                 [TABLE_ID]
@@ -1574,3 +1575,148 @@ def list_semantic_model_object_report_usage(
     final_df.reset_index(drop=True, inplace=True)
 
     return final_df
+
+
+def list_server_properties(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Lists the `properties <https://learn.microsoft.com/dotnet/api/microsoft.analysisservices.serverproperty?view=analysisservices-dotnet>`_ of the Analysis Services instance.
+
+    Parameters
+    ----------
+    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 showing a list of the server properties.
+    """
+
+    tom_server = fabric.create_tom_server(readonly=True, workspace=workspace)
+
+    rows = [
+        {
+            "Name": sp.Name,
+            "Value": sp.Value,
+            "Default Value": sp.DefaultValue,
+            "Is Read Only": sp.IsReadOnly,
+            "Requires Restart": sp.RequiresRestart,
+            "Units": sp.Units,
+            "Category": sp.Category,
+        }
+        for sp in tom_server.ServerProperties
+    ]
+
+    tom_server.Dispose()
+    df = pd.DataFrame(rows)
+
+    bool_cols = ["Is Read Only", "Requires Restart"]
+    df[bool_cols] = df[bool_cols].astype(bool)
+
+    return df
+
+
+def list_semantic_model_errors(
+    dataset: str | UUID, workspace: Optional[str | UUID]
+) -> pd.DataFrame:
+    """
+    Shows a list of a semantic model's errors and their error messages (if they exist).
+
+    Parameters
+    ----------
+    dataset : str | UUID
+        Name or ID of the semantic model.
+    workspace : str | 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 errors and error messages for a given semantic model.
+    """
+
+    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
+    )
+
+    error_rows = []
+
+    with connect_semantic_model(
+        dataset=dataset_id, workspace=workspace_id, readonly=True
+    ) as tom:
+        # Define mappings of TOM objects to object types and attributes
+        error_checks = [
+            ("Column", tom.all_columns, lambda o: o.ErrorMessage),
+            ("Partition", tom.all_partitions, lambda o: o.ErrorMessage),
+            (
+                "Partition - Data Coverage Expression",
+                tom.all_partitions,
+                lambda o: (
+                    o.DataCoverageDefinition.ErrorMessage
+                    if o.DataCoverageDefinition
+                    else ""
+                ),
+            ),
+            ("Row Level Security", tom.all_rls, lambda o: o.ErrorMessage),
+            ("Calculation Item", tom.all_calculation_items, lambda o: o.ErrorMessage),
+            ("Measure", tom.all_measures, lambda o: o.ErrorMessage),
+            (
+                "Measure - Detail Rows Expression",
+                tom.all_measures,
+                lambda o: (
+                    o.DetailRowsDefinition.ErrorMessage
+                    if o.DetailRowsDefinition
+                    else ""
+                ),
+            ),
+            (
+                "Measure - Format String Expression",
+                tom.all_measures,
+                lambda o: (
+                    o.FormatStringDefinition.ErrorMessage
+                    if o.FormatStringDefinition
+                    else ""
+                ),
+            ),
+            (
+                "Calculation Group - Multiple or Empty Selection Expression",
+                tom.all_calculation_groups,
+                lambda o: (
+                    o.CalculationGroup.MultipleOrEmptySelectionExpression.ErrorMessage
+                    if o.CalculationGroup.MultipleOrEmptySelectionExpression
+                    else ""
+                ),
+            ),
+            (
+                "Calculation Group - No Selection Expression",
+                tom.all_calculation_groups,
+                lambda o: (
+                    o.CalculationGroup.NoSelectionExpression.ErrorMessage
+                    if o.CalculationGroup.NoSelectionExpression
+                    else ""
+                ),
+            ),
+        ]
+
+        # Iterate over all error checks
+        for object_type, getter, error_extractor in error_checks:
+            for obj in getter():
+                error_message = error_extractor(obj)
+                if error_message:  # Only add rows if there's an error message
+                    error_rows.append(
+                        {
+                            "Object Type": object_type,
+                            "Table Name": obj.Parent.Name,
+                            "Object Name": obj.Name,
+                            "Error Message": error_message,
+                        }
+                    )
+
+    return pd.DataFrame(error_rows)

sempy_labs/_model_bpa.py

@@ -10,9 +10,10 @@ from sempy_labs._helper_functions import (
     create_relationship_name,
     save_as_delta_table,
     resolve_workspace_capacity,
-    resolve_dataset_id,
+    resolve_dataset_name_and_id,
     get_language_codes,
     _get_max_run_id,
+    resolve_workspace_name_and_id,
 )
 from sempy_labs.lakehouse import get_lakehouse_tables, lakehouse_attached
 from sempy_labs.tom import connect_semantic_model
@@ -23,11 +24,12 @@ import sempy_labs._icons as icons
 from pyspark.sql.functions import col, flatten
 from pyspark.sql.types import StructType, StructField, StringType
 import os
+from uuid import UUID
 
 
 @log
 def run_model_bpa(
-    dataset: str,
+    dataset: str | UUID,
     rules: Optional[pd.DataFrame] = None,
     workspace: Optional[str] = None,
     export: bool = False,
@@ -41,8 +43,8 @@ def run_model_bpa(
 
     Parameters
     ----------
-    dataset : str
-        Name of the semantic model.
+    dataset : str | UUID
+        Name or ID of the semantic model.
     rules : pandas.DataFrame, default=None
         A pandas dataframe containing rules to be evaluated.
     workspace : str, default=None
@@ -105,28 +107,27 @@ def run_model_bpa(
         if language is not None:
             language = map_language(language, language_list)
 
-    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=workspace_id
+    )
 
     if language is not None and language not in language_list:
         print(
             f"{icons.yellow_dot} The '{language}' language code is not in our predefined language list. Please file an issue and let us know which language code you are using: https://github.com/microsoft/semantic-link-labs/issues/new?assignees=&labels=&projects=&template=bug_report.md&title=."
         )
 
-    if extended:
-        icons.sll_tags.append("ModelBPAExtended")
-        with connect_semantic_model(
-            dataset=dataset, workspace=workspace, readonly=False
-        ) as tom:
-            tom.set_vertipaq_annotations()
-
     with connect_semantic_model(
-        dataset=dataset, workspace=workspace, readonly=True
+        dataset=dataset_id, workspace=workspace_id, readonly=True
     ) as tom:
 
+        if extended:
+            tom.set_vertipaq_annotations()
+
         # Do not run BPA for models with no tables
         if tom.model.Tables.Count == 0:
             print(
-                f"{icons.warning} The '{dataset}' semantic model within the '{workspace}' workspace has no tables and therefore there are no valid BPA results."
+                f"{icons.warning} The '{dataset_name}' semantic model within the '{workspace_name}' workspace has no tables and therefore there are no valid BPA results."
             )
             finalDF = pd.DataFrame(
                 columns=[
@@ -140,7 +141,9 @@ def run_model_bpa(
                 ]
             )
         else:
-            dep = get_model_calc_dependencies(dataset=dataset, workspace=workspace)
+            dep = get_model_calc_dependencies(
+                dataset=dataset_id, workspace=workspace_id
+            )
 
             def translate_using_po(rule_file):
                 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -386,20 +389,19 @@ def run_model_bpa(
             runId = max_run_id + 1
 
         now = datetime.datetime.now()
-        dfD = fabric.list_datasets(workspace=workspace, mode="rest")
-        dfD_filt = dfD[dfD["Dataset Name"] == dataset]
+        dfD = fabric.list_datasets(workspace=workspace_id, mode="rest")
+        dfD_filt = dfD[dfD["Dataset Id"] == dataset_id]
         configured_by = dfD_filt["Configured By"].iloc[0]
-        capacity_id, capacity_name = resolve_workspace_capacity(workspace=workspace)
+        capacity_id, capacity_name = resolve_workspace_capacity(workspace=workspace_id)
         dfExport["Capacity Name"] = capacity_name
         dfExport["Capacity Id"] = capacity_id
-        dfExport["Workspace Name"] = workspace
-        dfExport["Workspace Id"] = fabric.resolve_workspace_id(workspace)
-        dfExport["Dataset Name"] = dataset
-        dfExport["Dataset Id"] = resolve_dataset_id(dataset, workspace)
+        dfExport["Workspace Name"] = workspace_name
+        dfExport["Workspace Id"] = workspace_id
+        dfExport["Dataset Name"] = dataset_name
+        dfExport["Dataset Id"] = dataset_id
         dfExport["Configured By"] = configured_by
         dfExport["Timestamp"] = now
         dfExport["RunId"] = runId
-        dfExport["Configured By"] = configured_by
         dfExport["RunId"] = dfExport["RunId"].astype("int")
 
         dfExport = dfExport[list(icons.bpa_schema.keys())]