semantic-link-labs 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

sempy_labs/_model_bpa.py

@@ -12,6 +12,7 @@ from sempy_labs._helper_functions import (
     save_as_delta_table,
     resolve_workspace_capacity,
     resolve_dataset_id,
+    get_language_codes,
 )
 from sempy_labs.lakehouse import get_lakehouse_tables, lakehouse_attached
 from sempy_labs.tom import connect_semantic_model
@@ -21,7 +22,6 @@ from sempy._utils._log import log
 import sempy_labs._icons as icons
 from pyspark.sql.functions import col, flatten
 from pyspark.sql.types import StructType, StructField, StringType
-import polib
 import os
 
 
@@ -65,7 +65,7 @@ def run_model_bpa(
         A pandas dataframe in HTML format showing semantic model objects which violated the best practice analyzer rules.
     """
 
-    from synapse.ml.services import Translate
+    import polib
 
     if "extend" in kwargs:
         print(
@@ -81,34 +81,9 @@ def run_model_bpa(
         "ignore", category=UserWarning, message=".*Arrow optimization.*"
     )
 
-    language_list = [
-        "it-IT",
-        "es-ES",
-        "he-IL",
-        "pt-PT",
-        "zh-CN",
-        "fr-FR",
-        "da-DK",
-        "cs-CZ",
-        "de-DE",
-        "el-GR",
-        "fa-IR",
-        "ga-IE",
-        "hi-IN",
-        "hu-HU",
-        "is-IS",
-        "ja-JP",
-        "nl-NL",
-        "pl-PL",
-        "pt-BR",
-        "ru-RU",
-        "te-IN",
-        "ta-IN",
-        "th-TH",
-        "zu-ZA",
-        "am-ET",
-        "ar-AE",
-    ]
+    language_list = list(icons.language_map.keys())
+    if language is not None:
+        language = get_language_codes(languages=language)[0]
 
     # Map languages to the closest language (first 2 letters matching)
     def map_language(language, language_list):
@@ -152,7 +127,7 @@ def run_model_bpa(
         def translate_using_po(rule_file):
             current_dir = os.path.dirname(os.path.abspath(__file__))
             translation_file = (
-                f"{current_dir}/_bpa_translation/_translations_{language}.po"
+                f"{current_dir}/_bpa_translation/_model/_translations_{language}.po"
             )
             for c in ["Category", "Description", "Rule Name"]:
                 po = polib.pofile(translation_file)
@@ -162,86 +137,86 @@ def run_model_bpa(
                             entry.msgstr
                         )
 
-        def translate_using_spark(rule_file):
-            rules_temp = rule_file.copy()
-            rules_temp = rules_temp.drop(["Expression", "URL", "Severity"], axis=1)
-
-            schema = StructType(
-                [
-                    StructField("Category", StringType(), True),
-                    StructField("Scope", StringType(), True),
-                    StructField("Rule Name", StringType(), True),
-                    StructField("Description", StringType(), True),
-                ]
-            )
+        translated = False
+
+        # Translations
+        if language is not None and rules is None and language in language_list:
+            rules = model_bpa_rules(dependencies=dep)
+            translate_using_po(rules)
+            translated = True
+        if rules is None:
+            rules = model_bpa_rules(dependencies=dep)
+        if language is not None and not translated:
+
+            def translate_using_spark(rule_file):
+
+                from synapse.ml.services import Translate
+
+                rules_temp = rule_file.copy()
+                rules_temp = rules_temp.drop(["Expression", "URL", "Severity"], axis=1)
 
-            spark = SparkSession.builder.getOrCreate()
-            dfRules = spark.createDataFrame(rules_temp, schema)
-
-            columns = ["Category", "Rule Name", "Description"]
-            for clm in columns:
-                translate = (
-                    Translate()
-                    .setTextCol(clm)
-                    .setToLanguage(language)
-                    .setOutputCol("translation")
-                    .setConcurrency(5)
+                schema = StructType(
+                    [
+                        StructField("Category", StringType(), True),
+                        StructField("Scope", StringType(), True),
+                        StructField("Rule Name", StringType(), True),
+                        StructField("Description", StringType(), True),
+                    ]
                 )
 
-                if clm == "Rule Name":
-                    transDF = (
-                        translate.transform(dfRules)
-                        .withColumn(
-                            "translation", flatten(col("translation.translations"))
-                        )
-                        .withColumn("translation", col("translation.text"))
-                        .select(clm, "translation")
-                    )
-                else:
-                    transDF = (
-                        translate.transform(dfRules)
-                        .withColumn(
-                            "translation", flatten(col("translation.translations"))
-                        )
-                        .withColumn("translation", col("translation.text"))
-                        .select("Rule Name", clm, "translation")
+                spark = SparkSession.builder.getOrCreate()
+                dfRules = spark.createDataFrame(rules_temp, schema)
+
+                columns = ["Category", "Rule Name", "Description"]
+                for clm in columns:
+                    translate = (
+                        Translate()
+                        .setTextCol(clm)
+                        .setToLanguage(language)
+                        .setOutputCol("translation")
+                        .setConcurrency(5)
                     )
 
-                df_panda = transDF.toPandas()
-                rule_file = pd.merge(
-                    rule_file,
-                    df_panda[["Rule Name", "translation"]],
-                    on="Rule Name",
-                    how="left",
-                )
+                    if clm == "Rule Name":
+                        transDF = (
+                            translate.transform(dfRules)
+                            .withColumn(
+                                "translation", flatten(col("translation.translations"))
+                            )
+                            .withColumn("translation", col("translation.text"))
+                            .select(clm, "translation")
+                        )
+                    else:
+                        transDF = (
+                            translate.transform(dfRules)
+                            .withColumn(
+                                "translation", flatten(col("translation.translations"))
+                            )
+                            .withColumn("translation", col("translation.text"))
+                            .select("Rule Name", clm, "translation")
+                        )
 
-                rule_file = rule_file.rename(
-                    columns={"translation": f"{clm}Translated"}
-                )
-                rule_file[f"{clm}Translated"] = rule_file[f"{clm}Translated"].apply(
-                    lambda x: x[0] if x is not None else None
-                )
+                    df_panda = transDF.toPandas()
+                    rule_file = pd.merge(
+                        rule_file,
+                        df_panda[["Rule Name", "translation"]],
+                        on="Rule Name",
+                        how="left",
+                    )
 
-            for clm in columns:
-                rule_file = rule_file.drop([clm], axis=1)
-                rule_file = rule_file.rename(columns={f"{clm}Translated": clm})
+                    rule_file = rule_file.rename(
+                        columns={"translation": f"{clm}Translated"}
+                    )
+                    rule_file[f"{clm}Translated"] = rule_file[f"{clm}Translated"].apply(
+                        lambda x: x[0] if x is not None else None
+                    )
 
-            return rule_file
+                for clm in columns:
+                    rule_file = rule_file.drop([clm], axis=1)
+                    rule_file = rule_file.rename(columns={f"{clm}Translated": clm})
 
-        translated = False
+                return rule_file
 
-        # Translations
-        if language is not None and rules is None and language in language_list:
-            rules = model_bpa_rules(
-                dataset=dataset, workspace=workspace, dependencies=dep
-            )
-            translate_using_po(rules)
-            translated = True
-        if rules is None:
-            rules = model_bpa_rules(
-                dataset=dataset, workspace=workspace, dependencies=dep
-            )
-        if language is not None and not translated:
             rules = translate_using_spark(rules)
 
         rules["Severity"].replace("Warning", icons.warning, inplace=True)
@@ -302,26 +277,28 @@ def run_model_bpa(
 
                 if scope == "Model":
                     x = []
-                    if expr(func):
+                    if expr(func, tom):
                         x = ["Model"]
                 elif scope == "Measure":
-                    x = [nm(obj) for obj in tom.all_measures() if expr(obj)]
+                    x = [nm(obj) for obj in tom.all_measures() if expr(obj, tom)]
                 elif scope == "Column":
-                    x = [nm(obj) for obj in tom.all_columns() if expr(obj)]
+                    x = [nm(obj) for obj in tom.all_columns() if expr(obj, tom)]
                 elif scope == "Partition":
-                    x = [nm(obj) for obj in tom.all_partitions() if expr(obj)]
+                    x = [nm(obj) for obj in tom.all_partitions() if expr(obj, tom)]
                 elif scope == "Hierarchy":
-                    x = [nm(obj) for obj in tom.all_hierarchies() if expr(obj)]
+                    x = [nm(obj) for obj in tom.all_hierarchies() if expr(obj, tom)]
                 elif scope == "Table":
-                    x = [nm(obj) for obj in tom.model.Tables if expr(obj)]
+                    x = [nm(obj) for obj in tom.model.Tables if expr(obj, tom)]
                 elif scope == "Relationship":
-                    x = [nm(obj) for obj in tom.model.Relationships if expr(obj)]
+                    x = [nm(obj) for obj in tom.model.Relationships if expr(obj, tom)]
                 elif scope == "Role":
-                    x = [nm(obj) for obj in tom.model.Roles if expr(obj)]
+                    x = [nm(obj) for obj in tom.model.Roles if expr(obj, tom)]
                 elif scope == "Row Level Security":
-                    x = [nm(obj) for obj in tom.all_rls() if expr(obj)]
+                    x = [nm(obj) for obj in tom.all_rls() if expr(obj, tom)]
                 elif scope == "Calculation Item":
-                    x = [nm(obj) for obj in tom.all_calculation_items() if expr(obj)]
+                    x = [
+                        nm(obj) for obj in tom.all_calculation_items() if expr(obj, tom)
+                    ]
 
                 if len(x) > 0:
                     new_data = {"Object Name": x, "Scope": scope, "Rule Name": ruleName}
@@ -528,7 +505,8 @@ def run_model_bpa(
                 content_html += f'<td>{row["Rule Name"]}</td>'
             content_html += f'<td>{row["Object Type"]}</td>'
             content_html += f'<td>{row["Object Name"]}</td>'
-            content_html += f'<td>{row["Severity"]}</td>'
+            content_html += f'<td style="text-align: center;">{row["Severity"]}</td>'
+            #content_html += f'<td>{row["Severity"]}</td>'
             content_html += "</tr>"
         content_html += "</table>"
 

sempy_labs/_model_bpa_bulk.py

@@ -229,7 +229,9 @@ def create_model_bpa_semantic_model(
     expr = get_shared_expression(lakehouse=lakehouse, workspace=lakehouse_workspace)
 
     # Create blank model
-    create_blank_semantic_model(dataset=dataset, workspace=lakehouse_workspace)
+    create_blank_semantic_model(
+        dataset=dataset, workspace=lakehouse_workspace, overwrite=True
+    )
 
     @retry(
         sleep_time=1,