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

sempy_labs/_list_functions.py

@@ -1,11 +1,15 @@
+import sempy
 import sempy.fabric as fabric
-from sempy_labs._helper_functions import resolve_workspace_name_and_id
+from sempy_labs._helper_functions import (
+    resolve_workspace_name_and_id, 
+    resolve_lakehouse_name, 
+    create_relationship_name, 
+    resolve_lakehouse_id)
 import pandas as pd
 import json, time
 from pyspark.sql import SparkSession
 from typing import Optional
 
-
 def get_object_level_security(dataset: str, workspace: Optional[str] = None):
     """
     Shows the object level security for the semantic model.
@@ -25,7 +29,7 @@ def get_object_level_security(dataset: str, workspace: Optional[str] = None):
         A pandas dataframe showing the object level security for the semantic model.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -84,7 +88,7 @@ def list_tables(dataset: str, workspace: Optional[str] = None):
         A pandas dataframe showing the semantic model's tables and their properties.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -150,7 +154,7 @@ def list_annotations(dataset: str, workspace: Optional[str] = None):
         A pandas dataframe showing the semantic model's annotations and their properties.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -380,7 +384,7 @@ def list_columns(
         get_direct_lake_lakehouse,
     )
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -1028,10 +1032,10 @@ def create_warehouse(
 
     (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
 
-    if description == None:
-        request_body = {"displayName": warehouse}
-    else:
-        request_body = {"displayName": warehouse, "description": description}
+    request_body = {"displayName": warehouse}
+
+    if description:
+        request_body["description"] = description
 
     client = fabric.FabricRestClient()
     response = client.post(
@@ -1119,10 +1123,9 @@ def update_item(
 
     itemId = dfI_filt["Id"].iloc[0]
 
-    if description == None:
-        request_body = {"displayName": new_name}
-    else:
-        request_body = {"displayName": new_name, "description": description}
+    request_body = {"displayName": new_name}
+    if description:
+        request_body["description"] = description
 
     client = fabric.FabricRestClient()
     response = client.patch(
@@ -1130,7 +1133,7 @@ def update_item(
     )
 
     if response.status_code == 200:
-        if description == None:
+        if description is None:
             print(
                 f"The '{current_name}' {item_type} within the '{workspace}' workspace has been updated to be named '{new_name}'"
             )
@@ -1167,7 +1170,7 @@ def list_relationships(
         A pandas dataframe showing the object level security for the semantic model.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -1286,7 +1289,7 @@ def list_kpis(dataset: str, workspace: Optional[str] = None):
         A pandas dataframe showing the KPIs for the semantic model.
     """
 
-    from ._tom import connect_semantic_model
+    from .tom import connect_semantic_model
 
     with connect_semantic_model(
         dataset=dataset, workspace=workspace, readonly=True
@@ -1370,3 +1373,256 @@ def list_workspace_role_assignments(workspace: Optional[str] = None):
         df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
 
     return df
+
+def list_semantic_model_objects(dataset: str, workspace: Optional[str] = None):
+    """
+    Shows a list of semantic model objects.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model.
+    workspace : str, default=None
+        The Fabric workspace name.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing a list of objects in the semantic model
+    """
+    from .tom import connect_semantic_model
+
+    df = pd.DataFrame(columns=["Parent Name", "Object Name", "Object Type"])
+    with connect_semantic_model(
+        dataset=dataset, workspace=workspace, readonly=True
+    ) as tom:
+        for t in tom.model.Tables:
+            if t.CalculationGroup is not None:
+                new_data = {
+                    "Parent Name": t.Parent.Name,
+                    "Object Name": t.Name,
+                    "Object Type": "Calculation Group",
+                }
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
+                for ci in t.CalculationGroup.CalculationItems:
+                    new_data = {
+                        "Parent Name": t.Name,
+                        "Object Name": ci.Name,
+                        "Object Type": str(ci.ObjectType),
+                    }
+                    df = pd.concat(
+                        [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+            elif any(str(p.SourceType) == "Calculated" for p in t.Partitions):
+                new_data = {
+                    "Parent Name": t.Parent.Name,
+                    "Object Name": t.Name,
+                    "Object Type": "Calculated Table",
+                }
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
+            else:
+                new_data = {
+                    "Parent Name": t.Parent.Name,
+                    "Object Name": t.Name,
+                    "Object Type": str(t.ObjectType),
+                }
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
+            for c in t.Columns:
+                if str(c.Type) != "RowNumber":
+                    if str(c.Type) == "Calculated":
+                        new_data = {
+                            "Parent Name": c.Parent.Name,
+                            "Object Name": c.Name,
+                            "Object Type": "Calculated Column",
+                        }
+                        df = pd.concat(
+                            [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                        )
+                    else:
+                        new_data = {
+                            "Parent Name": c.Parent.Name,
+                            "Object Name": c.Name,
+                            "Object Type": str(c.ObjectType),
+                        }
+                        df = pd.concat(
+                            [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                        )
+            for m in t.Measures:
+                new_data = {
+                    "Parent Name": m.Parent.Name,
+                    "Object Name": m.Name,
+                    "Object Type": str(m.ObjectType),
+                }
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
+            for h in t.Hierarchies:
+                new_data = {
+                    "Parent Name": h.Parent.Name,
+                    "Object Name": h.Name,
+                    "Object Type": str(h.ObjectType),
+                }
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
+                for l in h.Levels:
+                    new_data = {
+                        "Parent Name": l.Parent.Name,
+                        "Object Name": l.Name,
+                        "Object Type": str(l.ObjectType),
+                    }
+                    df = pd.concat(
+                        [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+            for p in t.Partitions:
+                new_data = {
+                    "Parent Name": p.Parent.Name,
+                    "Object Name": p.Name,
+                    "Object Type": str(p.ObjectType),
+                }
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
+        for r in tom.model.Relationships:
+            rName = create_relationship_name(
+                r.FromTable.Name, r.FromColumn.Name, r.ToTable.Name, r.ToColumn.Name
+            )
+            new_data = {
+                "Parent Name": r.Parent.Name,
+                "Object Name": rName,
+                "Object Type": str(r.ObjectType),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+        for role in tom.model.Roles:
+            new_data = {
+                "Parent Name": role.Parent.Name,
+                "Object Name": role.Name,
+                "Object Type": str(role.ObjectType),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+            for rls in role.TablePermissions:
+                new_data = {
+                    "Parent Name": role.Name,
+                    "Object Name": rls.Name,
+                    "Object Type": str(rls.ObjectType),
+                }
+                df = pd.concat(
+                    [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                )
+        for tr in tom.model.Cultures:
+            new_data = {
+                "Parent Name": tr.Parent.Name,
+                "Object Name": tr.Name,
+                "Object Type": str(tr.ObjectType),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+        for per in tom.model.Perspectives:
+            new_data = {
+                "Parent Name": per.Parent.Name,
+                "Object Name": per.Name,
+                "Object Type": str(per.ObjectType),
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    return df
+
+def list_shortcuts(
+    lakehouse: Optional[str] = None, workspace: Optional[str] = None
+) -> pd.DataFrame:
+    """
+    Shows all shortcuts which exist in a Fabric lakehouse.
+
+    Parameters
+    ----------
+    lakehouse : str, default=None
+        The Fabric lakehouse name.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    workspace : str, default=None
+        The name of the Fabric workspace in which 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.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing all the shortcuts which exist in the specified lakehouse.
+    """
+
+    (workspace, workspace_id) = resolve_workspace_name_and_id(workspace)
+
+    if lakehouse is None:
+        lakehouse_id = fabric.get_lakehouse_id()
+        lakehouse = resolve_lakehouse_name(lakehouse_id, workspace)
+    else:
+        lakehouse_id = resolve_lakehouse_id(lakehouse, workspace)
+
+    df = pd.DataFrame(
+        columns=[
+            "Shortcut Name",
+            "Shortcut Path",
+            "Source",
+            "Source Lakehouse Name",
+            "Source Workspace Name",
+            "Source Path",
+            "Source Connection ID",
+            "Source Location",
+            "Source SubPath",
+        ]
+    )
+
+    client = fabric.FabricRestClient()
+    response = client.get(
+        f"/v1/workspaces/{workspace_id}/items/{lakehouse_id}/shortcuts"
+    )
+    if response.status_code == 200:
+        for s in response.json()["value"]:
+            shortcutName = s["name"]
+            shortcutPath = s["path"]
+            source = list(s["target"].keys())[0]
+            (
+                sourceLakehouseName,
+                sourceWorkspaceName,
+                sourcePath,
+                connectionId,
+                location,
+                subpath,
+            ) = (None, None, None, None, None, None)
+            if source == "oneLake":
+                sourceLakehouseId = s["target"][source]["itemId"]
+                sourcePath = s["target"][source]["path"]
+                sourceWorkspaceId = s["target"][source]["workspaceId"]
+                sourceWorkspaceName = fabric.resolve_workspace_name(sourceWorkspaceId)
+                sourceLakehouseName = resolve_lakehouse_name(
+                    sourceLakehouseId, sourceWorkspaceName
+                )
+            else:
+                connectionId = s["target"][source]["connectionId"]
+                location = s["target"][source]["location"]
+                subpath = s["target"][source]["subpath"]
+
+            new_data = {
+                "Shortcut Name": shortcutName,
+                "Shortcut Path": shortcutPath,
+                "Source": source,
+                "Source Lakehouse Name": sourceLakehouseName,
+                "Source Workspace Name": sourceWorkspaceName,
+                "Source Path": sourcePath,
+                "Source Connection ID": connectionId,
+                "Source Location": location,
+                "Source SubPath": subpath,
+            }
+            df = pd.concat([df, pd.DataFrame(new_data, index=[0])], ignore_index=True)
+
+    print(
+        f"This function relies on an API which is not yet official as of May 21, 2024. Once the API becomes official this function will work as expected."
+    )
+    return df

sempy_labs/_model_auto_build.py

@@ -1,7 +1,7 @@
 import sempy
 import sempy.fabric as fabric
 import pandas as pd
-from sempy_labs._tom import connect_semantic_model
+from sempy_labs.tom import connect_semantic_model
 from sempy_labs._generate_semantic_model import create_blank_semantic_model
 from sempy_labs.directlake._get_shared_expression import get_shared_expression
 from typing import List, Optional, Union

sempy_labs/_model_bpa.py

@@ -70,8 +70,8 @@ def model_bpa_rules():
                 "Table",
                 "Warning",
                 "Avoid using many-to-many relationships on tables used for dynamic row level security",
-                lambda df: (df["Used in M2M Relationship"] == True)
-                & (df["Used in Dynamic RLS"] == True),
+                lambda df: (df["Used in M2M Relationship"] is True)
+                & (df["Used in Dynamic RLS"] is True),
                 "Using many-to-many relationships on tables which use dynamic row level security can cause serious query performance degradation. This pattern's performance problems compound when snowflaking multiple many-to-many relationships against a table which contains row level security. Instead, use one of the patterns shown in the article below where a single dimension table relates many-to-one to a security table.",
                 "https://www.elegantbi.com/post/dynamicrlspatterns",
             ),
@@ -88,12 +88,12 @@ def model_bpa_rules():
                 "Column",
                 "Warning",
                 "Set IsAvailableInMdx to false on non-attribute columns",
-                lambda df: (df["Is Direct Lake"] == False)
-                & (df["Is Available in MDX"] == True)
-                & ((df["Hidden"] == True) | (df["Parent Is Hidden"] == True))
-                & (df["Used in Sort By"] == False)
-                & (df["Used in Hierarchy"] == False)
-                & (df["Sort By Column"] == None),
+                lambda df: (df["Is Direct Lake"] is False)
+                & (df["Is Available in MDX"] is True)
+                & ((df["Hidden"] is True) | (df["Parent Is Hidden"] is True))
+                & (df["Used in Sort By"] is False)
+                & (df["Used in Hierarchy"] is False)
+                & (df["Sort By Column"] is None),
                 "To speed up processing time and conserve memory after processing, attribute hierarchies should not be built for columns that are never used for slicing by MDX clients. In other words, all hidden columns that are not used as a Sort By Column or referenced in user hierarchies should have their IsAvailableInMdx property set to false. The IsAvailableInMdx property is not relevant for Direct Lake models.",
                 "https://blog.crossjoin.co.uk/2018/07/02/isavailableinmdx-ssas-tabular",
             ),
@@ -219,7 +219,7 @@ def model_bpa_rules():
                 "Table",
                 "Warning",
                 "Large tables should be partitioned",
-                lambda df: (df["Is Direct Lake"] == False)
+                lambda df: (df["Is Direct Lake"] is False)
                 & (df["Partition Count"] == 1)
                 & (df["Row Count"] > 25000000),
                 "Large tables should be partitioned in order to optimize processing. This is not relevant for semantic models in Direct Lake mode as they can only have one partition per table.",
@@ -306,11 +306,11 @@ def model_bpa_rules():
                 "Column",
                 "Warning",
                 "Set IsAvailableInMdx to true on necessary columns",
-                lambda df: (df["Is Direct Lake"] == False)
-                & (df["Is Available in MDX"] == False)
+                lambda df: (df["Is Direct Lake"] is False)
+                & (df["Is Available in MDX"] is False)
                 & (
-                    (df["Used in Sort By"] == True)
-                    | (df["Used in Hierarchy"] == True)
+                    (df["Used in Sort By"] is True)
+                    | (df["Used in Hierarchy"] is True)
                     | (df["Sort By Column"] != None)
                 ),
                 "In order to avoid errors, ensure that attribute hierarchies are enabled if a column is used for sorting another column, used in a hierarchy, used in variations, or is sorted by another column. The IsAvailableInMdx property is not relevant for Direct Lake models.",
@@ -320,8 +320,8 @@ def model_bpa_rules():
                 "Table",
                 "Error",
                 "Avoid the USERELATIONSHIP function and RLS against the same table",
-                lambda df: (df["USERELATIONSHIP Used"] == True)
-                & (df["Used in RLS"] == True),
+                lambda df: (df["USERELATIONSHIP Used"] is True)
+                & (df["Used in RLS"] is True),
                 "The USERELATIONSHIP function may not be used against a table which also leverages row-level security (RLS). This will generate an error when using the particular measure in a visual. This rule will highlight the table which is used in a measure's USERELATIONSHIP function as well as RLS.",
                 "https://blog.crossjoin.co.uk/2013/05/10/userelationship-and-tabular-row-security",
             ),
@@ -494,7 +494,7 @@ def model_bpa_rules():
                 "Table",
                 "Warning",
                 "Ensure tables have relationships",
-                lambda df: (df["Used in Relationship"] == False)
+                lambda df: (df["Used in Relationship"] is False)
                 & (df["Type"] != "Calculation Group"),
                 "This rule highlights tables which are not connected to any other table in the model with a relationship.",
             ),
@@ -511,7 +511,7 @@ def model_bpa_rules():
                 "Column",
                 "Info",
                 "Visible objects with no description",
-                lambda df: (df["Hidden"] == False) & (df["Description"].str.len() == 0),
+                lambda df: (df["Hidden"] is False) & (df["Description"].str.len() == 0),
                 "Calculation groups have no function unless they have calculation items.",
             ),
             (
@@ -595,7 +595,7 @@ def model_bpa_rules():
                 "Column",
                 "Info",
                 "Hide foreign keys",
-                lambda df: (df["Foreign Key"]) & (df["Hidden"] == False),
+                lambda df: (df["Foreign Key"]) & (df["Hidden"] is False),
                 "Foreign keys should always be hidden.",
             ),
             (
@@ -603,7 +603,7 @@ def model_bpa_rules():
                 "Column",
                 "Info",
                 "Mark primary keys",
-                lambda df: (df["Primary Key"]) & (df["Key"] == False),
+                lambda df: (df["Primary Key"]) & (df["Key"] is False),
                 "Set the 'Key' property to 'True' for primary key columns within the column properties.",
             ),
             (
@@ -744,7 +744,7 @@ def run_model_bpa(
         message="This pattern is interpreted as a regular expression, and has match groups.",
     )
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -798,13 +798,13 @@ def run_model_bpa(
     cols = ["From Cardinality", "To Cardinality"]
 
     for col in cols:
-        if not col in dfR:
+        if col not in dfR:
             dfR[col] = None
 
     cols = ["Parent Is Hidden"]
 
     for col in cols:
-        if not col in dfM:
+        if col not in dfM:
             dfM[col] = None
 
     # Data Coverage Definition rule
@@ -842,9 +842,9 @@ def run_model_bpa(
         dataset=dataset,
         workspace=workspace,
         dax_string="""
-        SELECT [FUNCTION_NAME] 
+        SELECT [FUNCTION_NAME]
         FROM $SYSTEM.MDSCHEMA_FUNCTIONS
-        WHERE [INTERFACE_NAME] = 'DATETIME'        
+        WHERE [INTERFACE_NAME] = 'DATETIME'
         """,
     )
 
@@ -951,7 +951,7 @@ def run_model_bpa(
     dfD["Has Date Table"] = any(
         (r["Parent Data Category"] == "Time")
         & (r["Data Type"] == "DateTime")
-        & (r["Key"] == True)
+        & (r["Key"] is True)
         for i, r in dfC.iterrows()
     )
     # dfC['In Date Table'] = dfC['Table Name'].isin(dfT.loc[dfT['Data Category'] == "Time", 'Name'])
@@ -1008,7 +1008,7 @@ def run_model_bpa(
     dfM["Referenced By"].fillna(0, inplace=True)
     dfM["Referenced By"] = dfM["Referenced By"].fillna(0).astype(int)
 
-    pattern = "[^\( ][a-zA-Z0-9_()-]+\[[^\[]+\]|'[^']+'\[[^\[]+\]|\[[^\[]+\]"
+    pattern = r"[^\( ][a-zA-Z0-9_()-]+\[[^\[]+\]|'[^']+'\[[^\[]+\]|\[[^\[]+\]"
 
     dfM["Has Fully Qualified Measure Reference"] = False
     dfM["Has Unqualified Column Reference"] = False
@@ -1033,7 +1033,7 @@ def run_model_bpa(
                     dfM.at[i, "Has Fully Qualified Measure Reference"] = True
 
     dfR["Inactive without USERELATIONSHIP"] = False
-    for i, r in dfR[dfR["Active"] == False].iterrows():
+    for i, r in dfR[dfR["Active"] is False].iterrows():
         fromTable = r["From Table"]
         fromColumn = r["From Column"]
         toTable = r["To Table"]
@@ -1041,15 +1041,15 @@ def run_model_bpa(
 
         dfM_filt = dfM[
             dfM["Measure Expression"].str.contains(
-                "(?i)USERELATIONSHIP\s*\(\s*'*"
-                + fromTable
-                + "'*\["
-                + fromColumn
-                + "\]\s*,\s*'*"
-                + toTable
-                + "'*\["
-                + toColumn
-                + "\]",
+                r"(?i)USERELATIONSHIP\s*\(\s*'*"
+                + re.escape(fromTable)
+                + r"'*\["
+                + re.escape(fromColumn)
+                + r"\]\s*,\s*'*"
+                + re.escape(toTable)
+                + r"'*\["
+                + re.escape(toColumn)
+                + r"\]",
                 regex=True,
             )
         ]
@@ -1183,7 +1183,7 @@ def run_model_bpa(
 
     if export:
         lakeAttach = lakehouse_attached()
-        if lakeAttach == False:
+        if lakeAttach is False:
             print(
                 f"In order to save the Best Practice Analyzer results, a lakehouse must be attached to the notebook. Please attach a lakehouse to this notebook."
             )

sempy_labs/_model_dependencies.py

@@ -1,12 +1,11 @@
-import sempy
 import sempy.fabric as fabric
 import pandas as pd
 from sempy_labs._helper_functions import format_dax_object_name
-from typing import List, Optional, Union
+from typing import Any, Dict, Optional
 from anytree import Node, RenderTree
 from sempy._utils._log import log
 
-
+@log
 def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
     """
     Shows all dependencies for all measures in a semantic model.
@@ -26,7 +25,7 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
         Shows all dependencies for all measures in the semantic model.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -64,11 +63,11 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
         axis=1,
     )
 
-    while any(df["Done"] == False):
+    while any(df["Done"] is False):
         for i, r in df.iterrows():
             rObjFull = r["Referenced Full Object Name"]
             rObj = r["Referenced Object"]
-            if r["Done"] == False:
+            if r["Done"] is False:
                 dep_filt = dep[dep["Full Object Name"] == rObjFull]
 
                 for index, dependency in dep_filt.iterrows():
@@ -131,7 +130,7 @@ def get_measure_dependencies(dataset: str, workspace: Optional[str] = None):
 
     return df
 
-
+@log
 def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
     """
     Shows all dependencies for all objects in a semantic model.
@@ -151,7 +150,7 @@ def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
         Shows all dependencies for all objects in the semantic model.
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -192,11 +191,11 @@ def get_model_calc_dependencies(dataset: str, workspace: Optional[str] = None):
         lambda row: False if row["Referenced Object Type"] in objs else True, axis=1
     )
 
-    while any(df["Done"] == False):
+    while any(df["Done"] is False):
         for i, r in df.iterrows():
             rObjFull = r["Referenced Full Object Name"]
             rObj = r["Referenced Object"]
-            if r["Done"] == False:
+            if r["Done"] is False:
                 dep_filt = dep[dep["Full Object Name"] == rObjFull]
 
                 for index, dependency in dep_filt.iterrows():
@@ -283,7 +282,7 @@ def measure_dependency_tree(
 
     """
 
-    if workspace == None:
+    if workspace is None:
         workspace_id = fabric.get_workspace_id()
         workspace = fabric.resolve_workspace_name(workspace_id)
 
@@ -300,7 +299,7 @@ def measure_dependency_tree(
     df_filt = md[md["Object Name"] == measure_name]
 
     # Create a dictionary to hold references to nodes
-    node_dict = {}
+    node_dict: Dict[str, Any] = {}
     measureIcon = "\u2211"
     tableIcon = "\u229E"
     columnIcon = "\u229F"