semantic-link-labs 0.10.0__py3-none-any.whl → 0.10.1__py3-none-any.whl

{semantic_link_labs-0.10.0.dist-info → semantic_link_labs-0.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: semantic-link-labs
-Version: 0.10.0
+Version: 0.10.1
 Summary: Semantic Link Labs for Microsoft Fabric
 Author: Microsoft Corporation
 License: MIT License
@@ -15,7 +15,7 @@ Classifier: Framework :: Jupyter
 Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: semantic-link-sempy>=0.10.2
+Requires-Dist: semantic-link-sempy>=0.11.0
 Requires-Dist: anytree
 Requires-Dist: powerbiclient
 Requires-Dist: polib
@@ -27,7 +27,7 @@ Dynamic: license-file
 # Semantic Link Labs
 
 [![PyPI version](https://badge.fury.io/py/semantic-link-labs.svg)](https://badge.fury.io/py/semantic-link-labs)
-[![Read The Docs](https://readthedocs.org/projects/semantic-link-labs/badge/?version=0.10.0&style=flat)](https://readthedocs.org/projects/semantic-link-labs/)
+[![Read The Docs](https://readthedocs.org/projects/semantic-link-labs/badge/?version=0.10.1&style=flat)](https://readthedocs.org/projects/semantic-link-labs/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![Downloads](https://static.pepy.tech/badge/semantic-link-labs)](https://pepy.tech/project/semantic-link-labs)
 
@@ -56,6 +56,7 @@ Check out the video below for an introduction to Semantic Link, Semantic Link La
     * [Migrating an import/DirectQuery semantic model to Direct Lake](https://github.com/microsoft/semantic-link-labs?tab=readme-ov-file#direct-lake-migration)
     * [Model Best Practice Analyzer (BPA)](https://github.com/microsoft/semantic-link-labs/wiki/Code-Examples#model-best-practice-analyzer)
     * [Vertipaq Analyzer](https://github.com/microsoft/semantic-link-labs/wiki/Code-Examples#vertipaq-analyzer)
+    * [Create a .vpax file](https://github.com/microsoft/semantic-link-labs/wiki/Code-Examples#create-a-vpax-file)
     * [Tabular Object Model](https://github.com/microsoft/semantic-link-labs/blob/main/notebooks/Tabular%20Object%20Model.ipynb) [(TOM)](https://semantic-link-labs.readthedocs.io/en/stable/sempy_labs.tom.html)
     * [Translate a semantic model's metadata](https://github.com/microsoft/semantic-link-labs/wiki/Code-Examples#translate-a-semantic-model)
     * [Check Direct Lake Guardrails](https://semantic-link-labs.readthedocs.io/en/stable/sempy_labs.lakehouse.html#sempy_labs.lakehouse.get_lakehouse_tables)
@@ -154,6 +155,7 @@ An even better way to ensure the semantic-link-labs library is available in your
 2. Select your newly created environment within the 'Environment' drop down in the navigation bar at the top of the notebook
 
 ## Version History
+* [0.10.1](https://github.com/microsoft/semantic-link-labs/releases/tag/0.10.1) (June 10, 2025)
 * [0.10.0](https://github.com/microsoft/semantic-link-labs/releases/tag/0.10.0) (May 30, 2025)
 * [0.9.11](https://github.com/microsoft/semantic-link-labs/releases/tag/0.9.11) (May 22, 2025)
 * [0.9.10](https://github.com/microsoft/semantic-link-labs/releases/tag/0.9.10) (April 24, 2025)

{semantic_link_labs-0.10.0.dist-info → semantic_link_labs-0.10.1.dist-info}/RECORD

@@ -1,5 +1,6 @@
-semantic_link_labs-0.10.0.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
-sempy_labs/__init__.py,sha256=RzY_bcDROFRZHTNuEUXpmYOUDZzTSZT7DpT4k_cJbHw,16363
+semantic_link_labs-0.10.1.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+sempy_labs/__init__.py,sha256=leWvgWaSALeu0s8hVUEIJs0K34L6lmk_fUtIvx4hfSQ,16553
+sempy_labs/_a_lib_info.py,sha256=cYmuBB-6Ns9Ar3M5zdEBeM-NU3UOZn3DZDBpYSxLGog,53
 sempy_labs/_ai.py,sha256=BD1TdGOJ7T4m3x426OP-FLb7bevn-9gKY8BTEDAJDQU,16205
 sempy_labs/_authentication.py,sha256=GjtN5XqIyWXbR5Ni4hfYiUNwgFa-ySX8e-BrqE1vgGc,6903
 sempy_labs/_capacities.py,sha256=n48NYTY03zygRzcfyK1UOkSwTqKSyQefQ10IKQh-dfA,40426
@@ -11,6 +12,7 @@ sempy_labs/_data_pipelines.py,sha256=cW_WGmuWD4V9IgLprKL4TqFXgid4eTBXvEL3-IArS0w
 sempy_labs/_dataflows.py,sha256=xv-wRDUq4Bzz-BOs1Jdb4bgS9HbPLpa1GqexfA6H0mg,8053
 sempy_labs/_dax.py,sha256=Q_GylKeuHFnRB_sztZS1ON5v5tr6ua6lc9elyJYKbV8,17219
 sempy_labs/_dax_query_view.py,sha256=_zSvgystZzBj5euNTLKTg7-G77XVk0vqyqrDT72VvoM,1892
+sempy_labs/_daxformatter.py,sha256=RenhoLcdGygESAQ0hk8gu9hEt7XCy_Dj6Fx6fnIjXgY,2998
 sempy_labs/_delta_analyzer.py,sha256=d6qxZrEhn3Hfg5qMQODt7dDG5mYSY18xeXUkW_NyMgw,17281
 sempy_labs/_delta_analyzer_history.py,sha256=A50dlBd2d3ILKV7Fwj4pfIRtXKmCFslhk1gpeEw4inc,10765
 sempy_labs/_deployment_pipelines.py,sha256=SDQYkCAhOAlxBr58jYxtLFOVySiRXO0_WhfOKGDeYZQ,6254
@@ -30,7 +32,7 @@ sempy_labs/_job_scheduler.py,sha256=_-Pifkttk1oPNxewxwWcQ4QC_Hr24GSi6nmrEXwc0pc,
 sempy_labs/_kql_databases.py,sha256=UtpYVBsxwWQDnqwdjq186bZzw5IlkD2S9KHA6Kw75U0,4738
 sempy_labs/_kql_querysets.py,sha256=Jjcs4SkjeirnDkG6zfsl0KRUXVzMyWii0Yn0JMWwln8,3502
 sempy_labs/_kusto.py,sha256=g3Up4j1KNdIGC2DDbvoduCdX1Pp8fAPGAlBAqOtaBeg,4544
-sempy_labs/_list_functions.py,sha256=wqaeCpsYPG3SW52ipB-uTCrjWQ1xcVkcazakWtPAsHo,61035
+sempy_labs/_list_functions.py,sha256=L09erDM43XcFt_k3t66fbmrtiqjbwlVg_Z_cP89hDLc,59752
 sempy_labs/_managed_private_endpoints.py,sha256=Vqicp_EiGg_m8aA2F__gaJiB9cwjbxQOSOi7hkS6FvQ,6907
 sempy_labs/_mirrored_databases.py,sha256=-9ZV2PdPeIc4lvFNkpPMm_9wkGIY1QLZXspYdSev5oQ,13147
 sempy_labs/_mirrored_warehouses.py,sha256=Q3WlRjUwCLz8KW1eN8MiTPeY0P52Vkuz5kgnv4GvQ3k,1739
@@ -42,13 +44,14 @@ sempy_labs/_model_bpa_bulk.py,sha256=hRY3dRBUtecrbscCZsEGv6TpCVqg_zAi8NmRq6dVMiE
 sempy_labs/_model_bpa_rules.py,sha256=ZK16VqWcITiTKdd9T5Xnu-AMgodLVx0ZpanZjsC88-U,46260
 sempy_labs/_model_dependencies.py,sha256=0xGgubrq76zIvBdEqmEX_Pd6WdizXFVECBW6BPl2DZo,13162
 sempy_labs/_mounted_data_factories.py,sha256=-IBxE5XurYyeeQg7BvpXSSR1MW3rRGmue6UGpqlo96U,3906
-sempy_labs/_notebooks.py,sha256=QbDmvxvYZEFE90lQ3Rqi70yjc5Xxg7D3ySemPPVGflY,9102
+sempy_labs/_notebooks.py,sha256=bWE9VtzPj6BNdV2QQgkT_aINptImdlvKxdSgOb7ZZIg,9101
 sempy_labs/_one_lake_integration.py,sha256=9ub75-ueEFqn1iRgRd5y97SYujalsWW6ufs1du4PbDs,6303
 sempy_labs/_query_scale_out.py,sha256=nra1q8s-PKpZTlI_L0lMGO1GmdBk6sqETsBQShF1yPY,15352
 sempy_labs/_refresh_semantic_model.py,sha256=4w_uaYLbaZptmEFY7QHWzOgXcgc2ctGx8HQvt2aguxk,17360
-sempy_labs/_semantic_models.py,sha256=F9v964IiXqx2qNPtNBzYrWPtXIoQH5-FI5csWJGofoQ,7934
+sempy_labs/_semantic_models.py,sha256=tdjifeziLA1Sx8fs7nnUsbR9NRv4EEBIYtmQEflXH4o,11567
 sempy_labs/_spark.py,sha256=SuSTjjmtzj7suDgN8Njk_pNBaStDLgIJB_1yk_e2H1Y,19340
 sempy_labs/_sql.py,sha256=BnL7Syd9vJZFysSiILYhqwTFS4y30nvkhDLQXGjtveE,8281
+sempy_labs/_sql_endpoints.py,sha256=hb-eD5R8xgPuXYIciTpPLOsvC6VKUOfTsubb4Tr2Bxw,5930
 sempy_labs/_sqldatabase.py,sha256=8HV3UtsLiwexmPSjYnhnYnD6xEvgFpTG13jcOuGheuI,6470
 sempy_labs/_tags.py,sha256=7DvSc3wah26DxHwUhr-yr_JhZiplrePkFaDaVIAQfV4,5666
 sempy_labs/_translations.py,sha256=i4K2PFk6-TcmAnUpqz-z_GuDv9XEp1cBs0KY-x6ja1w,16168
@@ -128,7 +131,7 @@ sempy_labs/directlake/_get_shared_expression.py,sha256=qc85kXggkx_7Sz_rAAli_yPnL
 sempy_labs/directlake/_guardrails.py,sha256=wNVXpeiZckgLTly4cS5DU5DoV9x1S4DMxN5S08qAavE,2749
 sempy_labs/directlake/_list_directlake_model_calc_tables.py,sha256=EYT4ELmOZ3Uklzy6uMQMidc4WtBXm21NQqZu1Q5HTsg,2509
 sempy_labs/directlake/_show_unsupported_directlake_objects.py,sha256=nmrZrtDez7U8Ji76i9fxnnTx1zxMu2LCOZTMz4sFUEc,3504
-sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py,sha256=W3LDXDD2pLH5B43NI9ixSIW2MJIORAWu5ANHQRFKMBY,9215
+sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py,sha256=o2oW5Wf0LpNVBRh2l2IxifDEZani7YU4V7J8kueIidQ,9230
 sempy_labs/directlake/_update_directlake_partition_entity.py,sha256=8YxrReJObtc7_Huq0qQrLKTVMhPO84guv8bQKtp__4c,9032
 sempy_labs/directlake/_warm_cache.py,sha256=xc7gG_OJY1rJYg79ztgcLATpnXHNqFaw-6CU1HgdlXk,9258
 sempy_labs/dotnet_lib/dotnet.runtime.config.json,sha256=syhDFQv6cEmZnE1WtFjNe3NwhsIsnd-CFULv-vEWOFI,167
@@ -153,6 +156,9 @@ sempy_labs/migration/_migrate_model_objects_to_semantic_model.py,sha256=RD0ttWcB
 sempy_labs/migration/_migrate_tables_columns_to_semantic_model.py,sha256=HYi2vn7yYDsBCTAXFTi6UiB86kdSlhQKPdwAt1nTKEE,7169
 sempy_labs/migration/_migration_validation.py,sha256=AHURrWofb-U-L2Bdu36mcisVXOuZXi6Smgrrs2kjYBM,2650
 sempy_labs/migration/_refresh_calc_tables.py,sha256=qUBPZ5HAHyE5ev6STKDcmtEpRuLDX5RzYTKre4ZElj4,5443
+sempy_labs/mirrored_azure_databricks_catalog/__init__.py,sha256=oQfKUOcDnssZ3m0fuyrugYhkFLVqaoHTkj2lDtIAlRo,373
+sempy_labs/mirrored_azure_databricks_catalog/_discover.py,sha256=HK_2eja5YbVrwCHcsX6CIA_qeYVKa-nkVTB-R9z-a9o,6976
+sempy_labs/mirrored_azure_databricks_catalog/_refresh_catalog_metadata.py,sha256=dNV7z0DnE3zAIsdyhWwpT5sWoPy3pIbrvWyPk8TFLI8,1604
 sempy_labs/report/_BPAReportTemplate.json,sha256=9Uh-7E6d2ooxQ7j5JRayv_ayEULc7Gzg42kZGKdOqH8,63920
 sempy_labs/report/__init__.py,sha256=yuMGbP7rd_50M-CRfIYR7BK8mPzpXXYzOPh9sBV-aqw,1434
 sempy_labs/report/_download_report.py,sha256=01hI26UV_jb5RLPheXRQsIDNNf4i72xICm14slKqEFA,2704
@@ -165,7 +171,7 @@ sempy_labs/report/_report_functions.py,sha256=pSrsUfMJqmsn9CYb5AM0iYdPR-EmuUSprV
 sempy_labs/report/_report_helper.py,sha256=L9wU0N0rvTUMglZHTxcowywrBDuZvZTv3DA4JrX84Os,7207
 sempy_labs/report/_report_list_functions.py,sha256=K9tMDQKhIZhelHvfMMW0lsxbVHekJ-5dAQveoD7PUDA,3980
 sempy_labs/report/_report_rebind.py,sha256=svyxUSdqgXJW1UDNcb-urJxU9erO3JM72uzmuJUWIT0,5090
-sempy_labs/report/_reportwrapper.py,sha256=YxGfhAXDkDyXuyyGYu5YpQf9S31L64Rpr3hHRE44fsk,108736
+sempy_labs/report/_reportwrapper.py,sha256=SlotekdZ_VUL2uNlxV324ftYKh5Y_XQbXr8R4aOkTUc,108916
 sempy_labs/report/_save_report.py,sha256=FAzScMQIXl89TgVSRvaJofzKT0TfZh_hhPNNvDiktaI,6033
 sempy_labs/report/_bpareporttemplate/definition.pbir,sha256=bttyHZYKqjA8OBb_cezGlX4H82cDvGZVCl1QB3fij4E,343
 sempy_labs/report/_bpareporttemplate/StaticResources/SharedResources/BaseThemes/CY24SU06.json,sha256=4N6sT5nLlYBobGmZ1Xb68uOMVVCBEyheR535js_et28,13467
@@ -195,8 +201,8 @@ sempy_labs/report/_bpareporttemplate/definition/pages/c597da16dc7e63222a82/visua
 sempy_labs/report/_bpareporttemplate/definition/pages/d37dce724a0ccc30044b/page.json,sha256=wBVuNc8S2NaUA0FC708w6stmR2djNZp8nAsHMqesgsc,293
 sempy_labs/report/_bpareporttemplate/definition/pages/d37dce724a0ccc30044b/visuals/ce8532a7e25020271077/visual.json,sha256=mlY6t9OlSe-Y6_QmXJpS1vggU6Y3FjISUKECL8FVSg8,931
 sempy_labs/tom/__init__.py,sha256=Qbs8leW0fjzvWwOjyWK3Hjeehu7IvpB1beASGsi28bk,121
-sempy_labs/tom/_model.py,sha256=64IJf2Pdag5ECWxJcf4Cg2paoMD0Pr6BHvdjgvW6pwo,197537
-semantic_link_labs-0.10.0.dist-info/METADATA,sha256=vw-G81gYnj_kJXcwm752EAY2d6TpwQ3QzDnjGYMkC3I,26831
-semantic_link_labs-0.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-semantic_link_labs-0.10.0.dist-info/top_level.txt,sha256=kiQX1y42Dbein1l3Q8jMUYyRulDjdlc2tMepvtrvixQ,11
-semantic_link_labs-0.10.0.dist-info/RECORD,,
+sempy_labs/tom/_model.py,sha256=g0XCzjLVVIe-Qa2K0gqKjxAykjjxLXuer4A9OvmSjeE,205123
+semantic_link_labs-0.10.1.dist-info/METADATA,sha256=F4eW_Wqf4FFnc5CFOXjJZqn7N3Qzlw9e9fGHy0ZbAsY,27042
+semantic_link_labs-0.10.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+semantic_link_labs-0.10.1.dist-info/top_level.txt,sha256=kiQX1y42Dbein1l3Q8jMUYyRulDjdlc2tMepvtrvixQ,11
+semantic_link_labs-0.10.1.dist-info/RECORD,,

sempy_labs/__init__.py

@@ -1,3 +1,7 @@
+from sempy_labs._sql_endpoints import (
+    list_sql_endpoints,
+    refresh_sql_endpoint_metadata,
+)
 from sempy_labs._variable_libraries import (
     list_variable_libraries,
     delete_variable_library,
@@ -30,6 +34,7 @@ from sempy_labs._semantic_models import (
     enable_semantic_model_scheduled_refresh,
     delete_semantic_model,
     update_semantic_model_refresh_schedule,
+    list_semantic_model_datasources,
 )
 from sempy_labs._graphQL import (
     list_graphql_apis,
@@ -275,7 +280,6 @@ from sempy_labs._list_functions import (
     get_object_level_security,
     list_datamarts,
     list_lakehouses,
-    list_sql_endpoints,
     update_item,
     list_server_properties,
     list_semantic_model_errors,
@@ -589,4 +593,6 @@ __all__ = [
     "apply_tags",
     "unapply_tags",
     "get_user_delegation_key",
+    "refresh_sql_endpoint_metadata",
+    "list_semantic_model_datasources",
 ]

sempy_labs/_a_lib_info.py

@@ -0,0 +1,2 @@
+lib_name = "semanticlinklabs"
+lib_version = "0.10.1"

sempy_labs/_daxformatter.py

@@ -0,0 +1,78 @@
+import requests
+from typing import List, Optional
+from sempy_labs._a_lib_info import lib_name, lib_version
+
+
+def _format_dax(
+    expressions: str | List[str],
+    skip_space_after_function_name: bool = False,
+    metadata: Optional[List[dict]] = None,
+) -> List[str]:
+
+    if isinstance(expressions, str):
+        expressions = [expressions]
+        metadata = [metadata] if metadata else [{}]
+
+    # Add variable assignment to each expression
+    expressions = [f"x :={item}" for item in expressions]
+
+    url = "https://daxformatter.azurewebsites.net/api/daxformatter/daxtextformatmulti"
+
+    payload = {
+        "Dax": expressions,
+        "MaxLineLength": 0,
+        "SkipSpaceAfterFunctionName": skip_space_after_function_name,
+        "ListSeparator": ",",
+        "DecimalSeparator": ".",
+    }
+
+    headers = {
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "Accept-Encoding": "gzip,deflate",
+        "Accept-Language": "en-US,en;q=0.8",
+        "Content-Type": "application/json; charset=UTF-8",
+        "Host": "daxformatter.azurewebsites.net",
+        "Expect": "100-continue",
+        "Connection": "Keep-Alive",
+        "CallerApp": lib_name,
+        "CallerVersion": lib_version,
+    }
+
+    response = requests.post(url, json=payload, headers=headers)
+    result = []
+    for idx, dax in enumerate(response.json()):
+        formatted_dax = dax.get("formatted")
+        errors = dax.get("errors")
+        if errors:
+            meta = metadata[idx] if metadata and idx < len(metadata) else {}
+            obj_name = meta.get("name", "Unknown")
+            table_name = meta.get("table", "Unknown")
+            obj_type = meta.get("type", "Unknown")
+            if obj_type == "calculated_tables":
+                raise ValueError(
+                    f"DAX formatting failed for the '{obj_name}' calculated table: {errors}"
+                )
+            elif obj_type == "calculated_columns":
+                raise ValueError(
+                    f"DAX formatting failed for the '{table_name}'[{obj_name}] calculated column: {errors}"
+                )
+            elif obj_type == "calculation_items":
+                raise ValueError(
+                    f"DAX formatting failed for the '{table_name}'[{obj_name}] calculation item: {errors}"
+                )
+            elif obj_type == "measures":
+                raise ValueError(
+                    f"DAX formatting failed for the '{obj_name}' measure: {errors}"
+                )
+            elif obj_type == "rls":
+                raise ValueError(
+                    f"DAX formatting failed for the row level security expression on the '{table_name}' table within the '{obj_name}' role: {errors}"
+                )
+            else:
+                NotImplementedError()
+        else:
+            if formatted_dax.startswith("x :="):
+                formatted_dax = formatted_dax[4:]
+            formatted_dax = formatted_dax.strip()
+            result.append(formatted_dax)
+    return result

sempy_labs/_list_functions.py

@@ -642,49 +642,6 @@ def list_lakehouses(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
     return df
 
 
-def list_sql_endpoints(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
-    """
-    Shows the SQL endpoints within a workspace.
-
-    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 the SQL endpoints within a workspace.
-    """
-
-    columns = {
-        "SQL Endpoint Id": "string",
-        "SQL Endpoint Name": "string",
-        "Description": "string",
-    }
-    df = _create_dataframe(columns=columns)
-
-    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
-
-    responses = _base_api(
-        request=f"/v1/workspaces/{workspace_id}/sqlEndpoints", uses_pagination=True
-    )
-
-    for r in responses:
-        for v in r.get("value", []):
-
-            new_data = {
-                "SQL Endpoint Id": v.get("id"),
-                "SQL Endpoint Name": v.get("displayName"),
-                "Description": v.get("description"),
-            }
-            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
-
-    return df
-
-
 def list_datamarts(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
     """
     Shows the datamarts within a workspace.

sempy_labs/_notebooks.py

@@ -159,6 +159,7 @@ def import_notebook_from_web(
             notebook_content=response.content,
             workspace=workspace_id,
             description=description,
+            format="ipynb",
         )
     elif len(dfI_filt) > 0 and overwrite:
         print(f"{icons.info} Overwrite of notebooks is currently not supported.")
@@ -202,9 +203,8 @@ def create_notebook(
         otherwise notebook_content should be GIT friendly format
     """
 
-    notebook_payload = base64.b64encode(notebook_content.encode("utf-8")).decode(
-        "utf-8"
-    )
+    notebook_payload = base64.b64encode(notebook_content).decode("utf-8")
+
     definition_payload = {
         "parts": [
             {

sempy_labs/_semantic_models.py

@@ -8,6 +8,8 @@ from sempy_labs._helper_functions import (
     resolve_workspace_name_and_id,
     resolve_dataset_name_and_id,
     delete_item,
+    resolve_dataset_id,
+    resolve_workspace_id,
 )
 import sempy_labs._icons as icons
 import re
@@ -227,3 +229,102 @@ def update_semantic_model_refresh_schedule(
     print(
         f"{icons.green_dot} Refresh schedule for the '{dataset_name}' within the '{workspace_name}' workspace has been updated."
     )
+
+
+def list_semantic_model_datasources(
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    expand_details: bool = True,
+) -> pd.DataFrame:
+    """
+    Lists the data sources for the specified semantic model.
+
+    This is a wrapper function for the following API: `Datasets - Get Datasources In Group <https://learn.microsoft.com/rest/api/power-bi/datasets/get-datasources-in-group>`_.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    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.
+    expand_details : bool, default=True
+        If True, expands the connection details for each data source.
+
+    Returns
+    -------
+    pandas.DataFrame
+        DataFrame containing the data sources for the specified semantic model.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+    dataset_id = resolve_dataset_id(dataset, workspace_id)
+
+    if expand_details:
+        columns = {
+            "Datasource Type": "str",
+            "Connection Server": "str",
+            "Connection Database": "str",
+            "Connection Path": "str",
+            "Connection Account": "str",
+            "Connection Domain": "str",
+            "Connection Kind": "str",
+            "Connection Email Address": "str",
+            "Connection URL": "str",
+            "Connection Class Info": "str",
+            "Connection Login Server": "str",
+            "Datasource Id": "str",
+            "Gateway Id": "str",
+        }
+    else:
+        columns = {
+            "Datasource Type": "str",
+            "Connection Details": "str",
+            "Datasource Id": "str",
+            "Gateway Id": "str",
+        }
+
+    df = _create_dataframe(columns)
+
+    response = _base_api(
+        request=f"/v1.0/myorg/groups/{workspace_id}/datasets/{dataset_id}/datasources",
+        client="fabric_sp",
+    )
+
+    dfs = []
+    for item in response.json().get("value", []):
+        ds_type = item.get("datasourceType")
+        conn_details = item.get("connectionDetails", {})
+        ds_id = item.get("datasourceId")
+        gateway_id = item.get("gatewayId")
+        if expand_details:
+            new_data = {
+                "Datasource Type": ds_type,
+                "Connection Server": conn_details.get("server"),
+                "Connection Database": conn_details.get("database"),
+                "Connection Path": conn_details.get("path"),
+                "Connection Account": conn_details.get("account"),
+                "Connection Domain": conn_details.get("domain"),
+                "Connection Kind": conn_details.get("kind"),
+                "Connection Email Address": conn_details.get("emailAddress"),
+                "Connection URL": conn_details.get("url"),
+                "Connection Class Info": conn_details.get("classInfo"),
+                "Connection Login Server": conn_details.get("loginServer"),
+                "Datasource Id": ds_id,
+                "Gateway Id": gateway_id,
+            }
+            dfs.append(pd.DataFrame(new_data, index=[0]))
+        else:
+            new_data = {
+                "Datasource Type": ds_type,
+                "Connection Details": conn_details,
+                "Datasource Id": ds_id,
+                "Gateway Id": gateway_id,
+            }
+            dfs.append(pd.DataFrame([new_data]))
+
+    if dfs:
+        df = pd.concat(dfs, ignore_index=True)
+
+    return df

sempy_labs/_sql_endpoints.py

@@ -0,0 +1,185 @@
+from typing import Optional, Literal
+from uuid import UUID
+import pandas as pd
+from sempy_labs._helper_functions import (
+    _base_api,
+    _create_dataframe,
+    resolve_workspace_name_and_id,
+    resolve_item_name_and_id,
+    _update_dataframe_datatypes,
+)
+import sempy_labs._icons as icons
+
+
+def list_sql_endpoints(workspace: Optional[str | UUID] = None) -> pd.DataFrame:
+    """
+    Shows the SQL endpoints within a workspace.
+
+    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 the SQL endpoints within a workspace.
+    """
+
+    columns = {
+        "SQL Endpoint Id": "string",
+        "SQL Endpoint Name": "string",
+        "Description": "string",
+    }
+    df = _create_dataframe(columns=columns)
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    responses = _base_api(
+        request=f"/v1/workspaces/{workspace_id}/sqlEndpoints", uses_pagination=True
+    )
+
+    for r in responses:
+        for v in r.get("value", []):
+
+            new_data = {
+                "SQL Endpoint Id": v.get("id"),
+                "SQL Endpoint Name": v.get("displayName"),
+                "Description": v.get("description"),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    return df
+
+
+def refresh_sql_endpoint_metadata(
+    item: str | UUID,
+    type: Literal["Lakehouse", "MirroredDatabase"],
+    workspace: Optional[str | UUID] = None,
+    tables: dict[str, list[str]] = None,
+) -> pd.DataFrame:
+    """
+    Refreshes the metadata of a SQL endpoint.
+
+    This is a wrapper function for the following API: `Items - Refresh Sql Endpoint Metadata <https://learn.microsoft.com/rest/api/fabric/sqlendpoint/items/refresh-sql-endpoint-metadata>`_.
+
+    Parameters
+    ----------
+    item : str | uuid.UUID
+        The name or ID of the item (Lakehouse or MirroredDatabase).
+    type : Literal['Lakehouse', 'MirroredDatabase']
+        The type of the item. Must be 'Lakehouse' or 'MirroredDatabase'.
+    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.
+    tables : dict[str, list[str]], default=None
+        A dictionary where the keys are schema names and the values are lists of table names.
+        If empty, all table metadata will be refreshed.
+
+        Example:
+        {
+            "dbo": ["DimDate", "DimGeography"],
+            "sls": ["FactSales", "FactBudget"],
+        }
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing the status of the metadata refresh operation.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    (item_name, item_id) = resolve_item_name_and_id(
+        item=item, type=type, workspace=workspace
+    )
+
+    if type == "Lakehouse":
+        response = _base_api(
+            request=f"/v1/workspaces/{workspace_id}/lakehouses/{item_id}",
+            client="fabric_sp",
+        )
+        sql_endpoint_id = (
+            response.json()
+            .get("properties", {})
+            .get("sqlEndpointProperties", {})
+            .get("id")
+        )
+    elif type == "MirroredDatabase":
+        response = _base_api(
+            request=f"/v1/workspaces/{workspace_id}/mirroredDatabases/{item_id}",
+            client="fabric_sp",
+        )
+        sql_endpoint_id = (
+            response.json()
+            .get("properties", {})
+            .get("sqlEndpointProperties", {})
+            .get("id")
+        )
+    else:
+        raise ValueError("Invalid type. Must be 'Lakehouse' or 'MirroredDatabase'.")
+
+    payload = {}
+    if tables:
+        payload = {
+            "tableDefinitions": [
+                {"schema": schema, "tableNames": tables}
+                for schema, tables in tables.items()
+            ]
+        }
+
+    result = _base_api(
+        request=f"v1/workspaces/{workspace_id}/sqlEndpoints/{sql_endpoint_id}/refreshMetadata?preview=true",
+        method="post",
+        status_codes=[200, 202],
+        lro_return_json=True,
+        payload=payload,
+    )
+
+    columns = {
+        "Table Name": "string",
+        "Status": "string",
+        "Start Time": "datetime",
+        "End Time": "datetime",
+        "Last Successful Sync Time": "datetime",
+        "Error Code": "string",
+        "Error Message": "string",
+    }
+
+    df = pd.json_normalize(result)
+
+    # Extract error code and message, set to None if no error
+    df['Error Code'] = df.get('error.errorCode', None)
+    df['Error Message'] = df.get('error.message', None)
+
+    # Friendly column renaming
+    df.rename(columns={
+        'tableName': 'Table Name',
+        'startDateTime': 'Start Time',
+        'endDateTime': 'End Time',
+        'status': 'Status',
+        'lastSuccessfulSyncDateTime': 'Last Successful Sync Time'
+    }, inplace=True)
+
+    # Drop the original 'error' column if present
+    df.drop(columns=[col for col in ['error'] if col in df.columns], inplace=True)
+
+    # Optional: Reorder columns
+    column_order = [
+        'Table Name', 'Status', 'Start Time', 'End Time',
+        'Last Successful Sync Time', 'Error Code', 'Error Message'
+    ]
+    df = df[column_order]
+
+    _update_dataframe_datatypes(df, columns)
+
+    printout = f"{icons.green_dot} The metadata of the SQL endpoint for the '{item_name}' {type.lower()} within the '{workspace_name}' workspace has been refreshed"
+    if tables:
+        print(f"{printout} for the following tables: {tables}.")
+    else:
+        print(f"{printout} for all tables.")
+
+    return df

sempy_labs/directlake/_update_directlake_model_lakehouse_connection.py

@@ -111,9 +111,9 @@ def update_direct_lake_model_connection(
 
     Parameters
     ----------
-    dataset : str | UUID
+    dataset : str | uuid.UUID
         Name or ID of the semantic model.
-    workspace : str | UUID, default=None
+    workspace : str | uuid.UUID, default=None
         The Fabric workspace name or ID in which the semantic model 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.
@@ -122,7 +122,7 @@ def update_direct_lake_model_connection(
         Defaults to None which resolves to the lakehouse attached to the notebook.
     source_type : str, default="Lakehouse"
         The type of source for the Direct Lake semantic model. Valid options: "Lakehouse", "Warehouse".
-    source_workspace : str | UUID, default=None
+    source_workspace : str | uuid.UUID, default=None
         The Fabric workspace name or ID used by the lakehouse/warehouse.
         Defaults to None which resolves to the workspace of the attached lakehouse
         or if no lakehouse attached, resolves to the workspace of the notebook.

sempy_labs/mirrored_azure_databricks_catalog/__init__.py

@@ -0,0 +1,15 @@
+from sempy_labs.mirrored_azure_databricks_catalog._refresh_catalog_metadata import (
+    refresh_catalog_metadata,
+)
+from sempy_labs.mirrored_azure_databricks_catalog._discover import (
+    discover_catalogs,
+    discover_schemas,
+    discover_tables,
+)
+
+__all__ = [
+    "refresh_catalog_metadata",
+    "discover_catalogs",
+    "discover_schemas",
+    "discover_tables",
+]

sempy_labs/mirrored_azure_databricks_catalog/_discover.py

@@ -0,0 +1,209 @@
+from uuid import UUID
+from typing import Optional
+from sempy_labs._helper_functions import (
+    resolve_workspace_id,
+    _base_api,
+    _create_dataframe,
+)
+import pandas as pd
+
+
+def discover_catalogs(
+    databricks_workspace_connection_id: UUID,
+    workspace: Optional[str | UUID] = None,
+    max_results: Optional[int] = None,
+) -> pd.DataFrame:
+    """
+    Returns a list of catalogs from Unity Catalog.
+
+    This is a wrapper function for the following API: `Databricks Metadata Discovery - Discover Catalogs <https://learn.microsoft.comrest/api/fabric/mirroredazuredatabrickscatalog/databricks-metadata-discovery/discover-catalogs>`_.
+
+    Parameters
+    ----------
+    databricks_workspace_connection_id : uuid.UUID
+        The ID of the Databricks workspace connection.
+    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.
+    max_results : int, default=None
+        The maximum number of results to return. If not specified, all results are returned.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of catalogs from Unity Catalog.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+
+    url = f"/v1/workspaces/{workspace_id}/azuredatabricks/catalogs?databricksWorkspaceConnectionId={databricks_workspace_connection_id}"
+    if max_results:
+        url += f"&maxResults={max_results}"
+
+    responses = _base_api(request=url, uses_pagination=True)
+
+    columns = {
+        "Catalog Name": "str",
+        "Catalog Full Name": "str",
+        "Catalog Type": "str",
+        "Storage Location": "str",
+    }
+
+    df = _create_dataframe(columns=columns)
+
+    dfs = []
+    for r in responses:
+        for i in r.get("value", []):
+            new_data = {
+                "Catalog Name": i.get("name"),
+                "Catalog Full Name": i.get("fullName"),
+                "Catalog Type": i.get("catalogType"),
+                "Storage Location": i.get("storageLocation"),
+            }
+
+            dfs.append(pd.DataFrame(new_data, index=[0]))
+
+    if dfs:
+        df = pd.concat(dfs, ignore_index=True)
+
+    return df
+
+
+def discover_schemas(
+    catalog: str,
+    databricks_workspace_connection_id: UUID,
+    workspace: Optional[str | UUID] = None,
+    max_results: Optional[int] = None,
+) -> pd.DataFrame:
+    """
+    Returns a list of schemas in the given catalog from Unity Catalog.
+
+    This is a wrapper function for the following API: `Databricks Metadata Discovery - Discover Schemas <https://learn.microsoft.comrest/api/fabric/mirroredazuredatabrickscatalog/databricks-metadata-discovery/discover-schemas>`_.
+
+    Parameters
+    ----------
+    catalog : str
+        The name of the catalog.
+    databricks_workspace_connection_id : uuid.UUID
+        The ID of the Databricks workspace connection.
+    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.
+    max_results : int, default=None
+        The maximum number of results to return. If not specified, all results are returned.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of schemas in the given catalog from Unity Catalog.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+
+    url = f"/v1/workspaces/{workspace_id}/azuredatabricks/catalogs/{catalog}/schemas?databricksWorkspaceConnectionId={databricks_workspace_connection_id}"
+    if max_results:
+        url += f"&maxResults={max_results}"
+
+    responses = _base_api(request=url, uses_pagination=True)
+
+    columns = {
+        "Catalog Name": "str",
+        "Schema Name": "str",
+        "Schema Full Name": "str",
+        "Storage Location": "str",
+    }
+
+    df = _create_dataframe(columns=columns)
+
+    dfs = []
+    for r in responses:
+        for i in r.get("value", []):
+            new_data = {
+                "Catalog Name": catalog,
+                "Schema Name": i.get("name"),
+                "Schema Full Name": i.get("fullName"),
+                "Storage Location": i.get("storageLocation"),
+            }
+
+            dfs.append(pd.DataFrame(new_data, index=[0]))
+
+    if dfs:
+        df = pd.concat(dfs, ignore_index=True)
+
+    return df
+
+
+def discover_tables(
+    catalog: str,
+    schema: str,
+    databricks_workspace_connection_id: UUID,
+    workspace: Optional[str | UUID] = None,
+    max_results: Optional[int] = None,
+) -> pd.DataFrame:
+    """
+    Returns a list of schemas in the given catalog from Unity Catalog.
+
+    This is a wrapper function for the following API: `Databricks Metadata Discovery - Discover Tables <https://learn.microsoft.comrest/api/fabric/mirroredazuredatabrickscatalog/databricks-metadata-discovery/discover-tables>`_.
+
+    Parameters
+    ----------
+    catalog : str
+        The name of the catalog.
+    schema : str
+        The name of the schema.
+    databricks_workspace_connection_id : uuid.UUID
+        The ID of the Databricks workspace connection.
+    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.
+    max_results : int, default=None
+        The maximum number of results to return. If not specified, all results are returned.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of schemas in the given catalog from Unity Catalog.
+    """
+
+    workspace_id = resolve_workspace_id(workspace)
+
+    url = f"/v1/workspaces/{workspace_id}/azuredatabricks/catalogs/{catalog}/schemas/{schema}/tables?databricksWorkspaceConnectionId={databricks_workspace_connection_id}"
+    if max_results:
+        url += f"&maxResults={max_results}"
+
+    responses = _base_api(request=url, uses_pagination=True)
+
+    columns = {
+        "Catalog Name": "str",
+        "Schema Name": "str",
+        "Table Name": "str",
+        "Table Full Name": "str",
+        "Storage Location": "str",
+        "Table Type": "str",
+        "Data Source Format": "str",
+    }
+
+    df = _create_dataframe(columns=columns)
+
+    dfs = []
+    for r in responses:
+        for i in r.get("value", []):
+            new_data = {
+                "Catalog Name": catalog,
+                "Schema Name": schema,
+                "Table Name": i.get("name"),
+                "Table Full Name": i.get("fullName"),
+                "Storage Location": i.get("storageLocation"),
+                "Table Type": i.get("tableType"),
+                "Data Source Format": i.get("dataSourceFormat"),
+            }
+
+            dfs.append(pd.DataFrame(new_data, index=[0]))
+
+    if dfs:
+        df = pd.concat(dfs, ignore_index=True)
+
+    return df

sempy_labs/mirrored_azure_databricks_catalog/_refresh_catalog_metadata.py

@@ -0,0 +1,43 @@
+from uuid import UUID
+from typing import Optional
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id,
+    resolve_item_name_and_id,
+    _base_api,
+)
+import sempy_labs._icons as icons
+
+
+def refresh_catalog_metadata(
+    mirrored_azure_databricks_catalog: str | UUID,
+    workspace: Optional[str | UUID] = None,
+):
+    """
+    Refresh Databricks catalog metadata in mirroredAzureDatabricksCatalogs Item.
+
+    This is a wrapper function for the following API: `Refresh Metadata - Items RefreshCatalogMetadata <https://learn.microsoft.com/rest/api/fabric/mirroredazuredatabrickscatalog/refresh-metadata/items-refresh-catalog-metadata>`_.
+
+    Parameters
+    ----------
+    mirrored_azure_databricks_catalog : str | uuid.UUID
+        The name or ID of the mirrored Azure Databricks catalog.
+    workspace : str | uuie.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
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (catalog_name, catalog_id) = resolve_item_name_and_id(
+        mirrored_azure_databricks_catalog
+    )
+
+    _base_api(
+        request=f"/v1/workspaces/{workspace_id}/mirroredAzureDatabricksCatalogs/{catalog_id}/refreshCatalogMetadata",
+        method="post",
+        lro_return_status_code=True,
+    )
+
+    print(
+        f"{icons.green_dot} The '{catalog_name}' Databricks Catalog metadata within the '{workspace_name}' workspace has been refreshed."
+    )

sempy_labs/report/_reportwrapper.py

@@ -1712,31 +1712,36 @@ class ReportWrapper:
             "Expression": "str",
             "Data Type": "str",
             "Format String": "str",
+            "Data Category": "str",
         }
 
         df = _create_dataframe(columns=columns)
 
+        # If no report extensions path, return empty DataFrame
+        if self._report_extensions_path not in self.list_paths()["Path"].values:
+            return df
+
         report_file = self.get(file_path=self._report_extensions_path)
 
         dfs = []
-        if report_file:
-            payload = report_file.get("payload")
-            for e in payload.get("entities", []):
-                table_name = e.get("name")
-                for m in e.get("measures", []):
-                    measure_name = m.get("name")
-                    expr = m.get("expression")
-                    data_type = m.get("dataType")
-                    format_string = m.get("formatString")
+        for e in report_file.get("entities", []):
+            table_name = e.get("name")
+            for m in e.get("measures", []):
+                measure_name = m.get("name")
+                expr = m.get("expression")
+                data_type = m.get("dataType")
+                format_string = m.get("formatString")
+                data_category = m.get("dataCategory")
 
-                    new_data = {
-                        "Measure Name": measure_name,
-                        "Table Name": table_name,
-                        "Expression": expr,
-                        "Data Type": data_type,
-                        "Format String": format_string,
-                    }
-                    dfs.append(pd.DataFrame(new_data, index=[0]))
+                new_data = {
+                    "Measure Name": measure_name,
+                    "Table Name": table_name,
+                    "Expression": expr,
+                    "Data Type": data_type,
+                    "Format String": format_string,
+                    "Data Category": data_category,
+                }
+                dfs.append(pd.DataFrame(new_data, index=[0]))
 
         if dfs:
             df = pd.concat(dfs, ignore_index=True)

sempy_labs/tom/_model.py

@@ -47,6 +47,13 @@ class TOMWrapper:
     _tables_added: List[str]
     _table_map = dict
     _column_map = dict
+    _dax_formatting = {
+        "measures": [],
+        "calculated_columns": [],
+        "calculated_tables": [],
+        "calculation_items": [],
+        "rls": [],
+    }
 
     def __init__(self, dataset, workspace, readonly):
 
@@ -4716,7 +4723,12 @@ class TOMWrapper:
             TOM.ValueFilterBehaviorType, value_filter_behavior
         )
 
-    def add_role_member(self, role_name: str, member: str | List[str]):
+    def add_role_member(
+        self,
+        role_name: str,
+        member: str | List[str],
+        role_member_type: Optional[str] = "User",
+    ):
         """
         Adds an external model role member (AzureAD) to a role.
 
@@ -4726,13 +4738,23 @@ class TOMWrapper:
             The role name.
         member : str | List[str]
             The email address(es) of the member(s) to add.
+        role_member_type : str, default="User"
+            The type of the role member. Default is "User". Other options include "Group" for Azure AD groups.
+            All members must be of the same role_member_type.
         """
 
         import Microsoft.AnalysisServices.Tabular as TOM
+        import System
 
         if isinstance(member, str):
             member = [member]
 
+        role_member_type = role_member_type.capitalize()
+        if role_member_type not in ["User", "Group"]:
+            raise ValueError(
+                f"{icons.red_dot} The '{role_member_type}' is not a valid role member type. Valid options: 'User', 'Group'."
+            )
+
         role = self.model.Roles[role_name]
         current_members = [m.MemberName for m in role.Members]
 
@@ -4741,6 +4763,7 @@ class TOMWrapper:
                 rm = TOM.ExternalModelRoleMember()
                 rm.IdentityProvider = "AzureAD"
                 rm.MemberName = m
+                rm.MemberType = System.Enum.Parse(TOM.RoleMemberType, role_member_type)
                 role.Members.Add(rm)
                 print(
                     f"{icons.green_dot} '{m}' has been added as a member of the '{role_name}' role."
@@ -5138,8 +5161,177 @@ class TOMWrapper:
                 f"{icons.green_dot} The '{object.Name}' {str(object.ObjectType).lower()} has been copied to the '{target_dataset}' semantic model within the '{target_workspace}' workspace."
             )
 
+    def format_dax(
+        self,
+        object: Optional[
+            Union[
+                "TOM.Measure",
+                "TOM.CalcultedColumn",
+                "TOM.CalculationItem",
+                "TOM.CalculatedTable",
+                "TOM.TablePermission",
+            ]
+        ] = None,
+    ):
+        """
+        Formats the DAX expressions of measures, calculated columns, calculation items, calculated tables and row level security expressions in the semantic model.
+
+        This function uses the `DAX Formatter API <https://www.daxformatter.com/>`_.
+
+        Parameters
+        ----------
+        object : TOM Object, default=None
+            The TOM object to format. If None, formats all measures, calculated columns, calculation items, calculated tables and row level security expressions in the semantic model.
+            If a specific object is provided, only that object will be formatted.
+        """
+
+        import Microsoft.AnalysisServices.Tabular as TOM
+
+        if object is None:
+            object_map = {
+                "measures": self.all_measures,
+                "calculated_columns": self.all_calculated_columns,
+                "calculation_items": self.all_calculation_items,
+                "calculated_tables": self.all_calculated_tables,
+                "rls": self.all_rls,
+            }
+
+            for key, func in object_map.items():
+                for obj in func():
+                    if key == "calculated_tables":
+                        p = next(p for p in obj.Partitions)
+                        name = obj.Name
+                        expr = p.Source.Expression
+                        table = obj.Name
+                    elif key == "calculation_items":
+                        name = obj.Name
+                        expr = obj.Expression
+                        table = obj.Parent.Table.Name
+                    elif key == "rls":
+                        name = obj.Role.Name
+                        expr = obj.FilterExpression
+                        table = obj.Table.Name
+                    else:
+                        name = obj.Name
+                        expr = obj.Expression
+                        table = obj.Table.Name
+                    self._dax_formatting[key].append(
+                        {
+                            "name": name,
+                            "expression": expr,
+                            "table": table,
+                        }
+                    )
+            return
+
+        if object.ObjectType == TOM.ObjectType.Measure:
+            self._dax_formatting["measures"].append(
+                {
+                    "name": object.Name,
+                    "expression": object.Expression,
+                    "table": object.Parent.Name,
+                }
+            )
+        elif object.ObjectType == TOM.ObjectType.CalculatedColumn:
+            self._dax_formatting["measures"].append(
+                {
+                    "name": object.Name,
+                    "expression": object.Expression,
+                    "table": object.Parent.Name,
+                }
+            )
+        elif object.ObjectType == TOM.ObjectType.CalculationItem:
+            self._dax_formatting["measures"].append(
+                {
+                    "name": object.Name,
+                    "expression": object.Expression,
+                    "table": object.Parent.Name,
+                }
+            )
+        elif object.ObjectType == TOM.ObjectType.CalculatedTable:
+            self._dax_formatting["measures"].append(
+                {
+                    "name": object.Name,
+                    "expression": object.Expression,
+                    "table": object.Name,
+                }
+            )
+        else:
+            raise ValueError(
+                f"{icons.red_dot} The '{str(object.ObjectType)}' object type is not supported for DAX formatting."
+            )
+
     def close(self):
 
+        # DAX Formatting
+        from sempy_labs._daxformatter import _format_dax
+
+        def _process_dax_objects(object_type, model_accessor=None):
+            items = self._dax_formatting.get(object_type, [])
+            if not items:
+                return False
+
+            # Extract and format expressions
+            expressions = [item["expression"] for item in items]
+            metadata = [
+                {"name": item["name"], "table": item["table"], "type": object_type}
+                for item in items
+            ]
+
+            formatted_expressions = _format_dax(expressions, metadata=metadata)
+
+            # Update the expressions in the original structure
+            for item, formatted in zip(items, formatted_expressions):
+                item["expression"] = formatted
+
+            # Apply updated expressions to the model
+            for item in items:
+                table_name = (
+                    item["table"]
+                    if object_type != "calculated_tables"
+                    else item["name"]
+                )
+                name = item["name"]
+                expression = item["expression"]
+
+                if object_type == "calculated_tables":
+                    t = self.model.Tables[table_name]
+                    p = next(p for p in t.Partitions)
+                    p.Source.Expression = expression
+                elif object_type == "rls":
+                    self.model.Roles[name].TablePermissions[
+                        table_name
+                    ].FilterExpression = expression
+                elif object_type == "calculation_items":
+                    self.model.Tables[table_name].CalculationGroup.CalculationItems[
+                        name
+                    ].Expression = expression
+                else:
+                    getattr(self.model.Tables[table_name], model_accessor)[
+                        name
+                    ].Expression = expression
+            return True
+
+        # Use the helper for each object type
+        a = _process_dax_objects("measures", "Measures")
+        b = _process_dax_objects("calculated_columns", "Columns")
+        c = _process_dax_objects("calculation_items")
+        d = _process_dax_objects("calculated_tables")
+        e = _process_dax_objects("rls")
+        if any([a, b, c, d, e]) and not self._readonly:
+            from IPython.display import display, HTML
+
+            html = """
+            <span style="font-family: Segoe UI, Arial, sans-serif; color: #cccccc;">
+                CODE BEAUTIFIED WITH 
+            </span>
+            <a href="https://www.daxformatter.com" target="_blank" style="font-family: Segoe UI, Arial, sans-serif; color: #ff5a5a; font-weight: bold; text-decoration: none;">
+                DAX FORMATTER
+            </a>
+            """
+
+            display(HTML(html))
+
         if not self._readonly and self.model is not None:
 
             import Microsoft.AnalysisServices.Tabular as TOM