dsp-tools 0.9.13__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/excel2json/lists/models/input_error.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Protocol
+
+from dsp_tools.commands.excel2json.models.input_error import ExcelFileProblem
+from dsp_tools.commands.excel2json.models.input_error import PositionInExcel
+from dsp_tools.commands.excel2json.models.input_error import grand_separator
+from dsp_tools.commands.excel2json.models.input_error import list_separator
+from dsp_tools.commands.excel2json.models.input_error import medium_separator
+from dsp_tools.error.problems import Problem
+
+
+@dataclass(frozen=True)
+class ListCreationProblem:
+    excel_problems: list[Problem]
+
+    def execute_error_protocol(self) -> str:
+        title = "\nThe excel file(s) used to create the list section have the following problem(s):\n\n"
+        msg = [problem.execute_error_protocol() for problem in self.excel_problems]
+        return title + grand_separator.join(msg)
+
+
+@dataclass
+class SheetProblem(Protocol):
+    excel_name: str
+
+    def execute_error_protocol(self) -> str:
+        raise NotImplementedError
+
+
+@dataclass
+class CollectedSheetProblems:
+    sheet_problems: list[SheetProblem]
+
+    def execute_error_protocol(self) -> str:
+        file_problems = self._group_and_sort_by_excel_name()
+        return grand_separator.join([x.execute_error_protocol() for x in file_problems])
+
+    def _group_and_sort_by_excel_name(self) -> list[ExcelFileProblem]:
+        file_dict: dict[str, list[Problem]] = defaultdict(list)
+        for problem in self.sheet_problems:
+            file_dict[problem.excel_name].append(problem)
+        file_list = [ExcelFileProblem(k, v) for k, v in file_dict.items()]
+        return sorted(file_list, key=lambda x: x.filename)
+
+
+@dataclass
+class DuplicatesInSheetProblem(SheetProblem):
+    excel_name: str
+    sheet_name: str
+    rows: list[int]
+
+    def execute_error_protocol(self) -> str:
+        msg = [
+            f"The excel sheet '{self.sheet_name}' contains rows that are completely identical "
+            f"(excluding the column 'ID (optional)'). The following rows are duplicates:"
+        ]
+        msg.extend([f"{x + 2}" for x in self.rows])
+        return list_separator.join(msg)
+
+
+@dataclass
+class MultipleListPerSheetProblem(SheetProblem):
+    excel_name: str
+    sheet_name: str
+    list_names: list[str]
+
+    def execute_error_protocol(self) -> str:
+        return (
+            f"Per Excel sheet only one list is allowed.\n"
+            f"The sheet '{self.sheet_name}' has more than one list, namely the following: {', '.join(self.list_names)}"
+        )
+
+
+@dataclass
+class ListSheetComplianceProblem(SheetProblem):
+    excel_name: str
+    sheet_name: str
+    problems: list[Problem]
+
+    def execute_error_protocol(self) -> str:
+        msg = [f"The excel sheet '{self.sheet_name}' has the following problem(s):"]
+        msg.extend([x.execute_error_protocol() for x in self.problems])
+        return list_separator.join(msg)
+
+
+@dataclass
+class ListSheetContentProblem(SheetProblem):
+    excel_name: str
+    sheet_name: str
+    problems: list[Problem]
+
+    def execute_error_protocol(self) -> str:
+        msg = [f"The Excel sheet '{self.sheet_name}' has the following problem(s):"]
+        msg.extend([problem.execute_error_protocol() for problem in self.problems])
+        return list_separator.join(msg)
+
+
+@dataclass
+class MissingTranslationsSheetProblem(SheetProblem):
+    excel_name: str
+    sheet: str
+    node_problems: list[MissingNodeTranslationProblem]
+
+    def execute_error_protocol(self) -> str:
+        msg = [
+            f"The excel sheet '{self.sheet}' has the following problem(s):\n"
+            "In one list, all the nodes must be translated into all the languages used. "
+            "For the following nodes, the translations are missing:"
+        ]
+        nodes_sorted = sorted(self.node_problems, key=lambda x: x.index_num)
+        msg.extend([x.execute_error_protocol() for x in nodes_sorted])
+        return list_separator.join(msg)
+
+
+@dataclass(frozen=True)
+class DuplicatesListNameProblem:
+    all_duplicate_names: list[ListInformation]
+
+    def execute_error_protocol(self) -> str:
+        msg = [
+            "The name of the list must be unique across all the excel sheets.\n"
+            "The following sheets have lists with the same name:"
+        ]
+        sorted_list = sorted(self.all_duplicate_names, key=lambda x: x.excel_name)
+        msg.extend([x.execute_error_protocol() for x in sorted_list])
+        return list_separator.join(msg)
+
+
+@dataclass(frozen=True)
+class ListInformation:
+    excel_name: str
+    excel_sheet: str
+    list_name: str
+
+    def execute_error_protocol(self) -> str:
+        return f"Excel file: '{self.excel_name}', Sheet: '{self.excel_sheet}', List: '{self.list_name}'"
+
+
+@dataclass(frozen=True)
+class DuplicatesCustomIDInProblem:
+    duplicate_ids: list[DuplicateIDProblem]
+
+    def execute_error_protocol(self) -> str:
+        msg = [
+            "No duplicates are allowed in the 'ID (optional)' column. At the following locations, IDs are duplicated:"
+        ]
+        sorted_ids = sorted(self.duplicate_ids, key=lambda x: x.custom_id)
+        msg.extend([x.execute_error_protocol() for x in sorted_ids])
+        return medium_separator.join(msg)
+
+
+@dataclass
+class DuplicateIDProblem:
+    custom_id: str | int | float = field(default="")
+    excel_locations: list[PositionInExcel] = field(default_factory=list)
+
+    def execute_error_protocol(self) -> str:
+        msg = [f"ID: '{self.custom_id}'"]
+        msg.extend([str(x) for x in sorted(self.excel_locations, key=lambda x: str(x.excel_filename))])
+        return list_separator.join(msg)
+
+
+@dataclass(frozen=True)
+class MissingNodeTranslationProblem:
+    empty_columns: list[str]
+    index_num: int
+
+    def execute_error_protocol(self) -> str:
+        return f"Row Number: {self.index_num + 2} | Column(s): {', '.join(sorted(self.empty_columns))}"
+
+
+@dataclass(frozen=True)
+class NodesPerRowProblem:
+    column_names: list[str]
+    index_num: int
+    should_be_empty: bool
+
+    def execute_error_protocol(self) -> str:
+        if self.should_be_empty:
+            description = "Column(s) that must be empty"
+        else:
+            description = "Column(s) that must be filled"
+        return f"Row Number: {self.index_num + 2}, {description}: {', '.join(self.column_names)}"
+
+
+@dataclass(frozen=True)
+class MinimumRowsProblem:
+    def execute_error_protocol(self) -> str:
+        return (
+            "The Excel sheet must contain at least two rows, "
+            "one for the list name and one row for a minimum of one node."
+        )
+
+
+@dataclass(frozen=True)
+class MissingNodeColumn:
+    def execute_error_protocol(self) -> str:
+        return (
+            "At least one column for the node names in the format '[lang]_[column_number]' is required. "
+            "The allowed language tags are: en, de, fr, it, rm."
+        )
+
+
+@dataclass
+class MissingExpectedColumn:
+    missing_cols: set[str]
+
+    def execute_error_protocol(self) -> str:
+        return (
+            f"All nodes and lists must be translated into the same languages. "
+            f"Based on the languages used, the following column(s) are missing: {', '.join(self.missing_cols)}"
+        )

dsp_tools/commands/excel2json/lists/models/serialise.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Any
+
+
+@dataclass
+class ListNode:
+    id_: str
+    labels: dict[str, str]
+    comments: dict[str, str]
+    parent_id: str
+    sub_nodes: list[ListNode] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        node = self._make_own_node()
+        if self.sub_nodes:
+            node["nodes"] = self._make_subnodes()
+        return node
+
+    def _make_subnodes(self) -> list[dict[str, Any]]:
+        return [nd.to_dict() for nd in self.sub_nodes]
+
+    def _make_own_node(self) -> dict[str, Any]:
+        sorted_labels = {k: self.labels[k] for k in sorted(self.labels.keys())}
+        d = {"name": self.id_, "labels": sorted_labels}
+        if self.comments:
+            sorted_comments = {k: self.comments[k] for k in sorted(self.comments.keys())}
+            d["comments"] = sorted_comments
+        return d
+
+
+@dataclass
+class ListRoot:
+    id_: str
+    labels: dict[str, str]
+    nodes: list[ListNode]
+    comments: dict[str, str]
+
+    def to_dict(self) -> dict[str, Any]:
+        lst_root = self._make_list_root()
+        lst_root["nodes"] = self._make_nodes()
+        return lst_root
+
+    def _make_nodes(self) -> list[dict[str, Any]]:
+        return [nd.to_dict() for nd in self.nodes]
+
+    def _make_list_root(self) -> dict[str, Any]:
+        sorted_labels = {k: self.labels[k] for k in sorted(self.labels.keys())}
+        lst = {"name": self.id_, "labels": sorted_labels}
+        if self.comments:
+            sorted_comments = {k: self.comments[k] for k in sorted(self.comments.keys())}
+            lst["comments"] = sorted_comments
+        else:
+            lst["comments"] = sorted_labels
+        return lst

dsp_tools/commands/excel2json/lists/utils.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+import regex
+
+from dsp_tools.commands.excel2json.lists.models.deserialise import ColumnNodes
+from dsp_tools.commands.excel2json.lists.models.deserialise import Columns
+from dsp_tools.error.exceptions import InputError
+
+
+def get_lang_string_from_column_name(col_str: str, ending: str = r"(\d+|list|comments)") -> str | None:
+    """Gets the language tag of one string."""
+    if res := regex.search(rf"^(en|de|fr|it|rm)_{ending}$", col_str):
+        return res.group(1)
+    return None
+
+
+def get_columns_of_preferred_lang(
+    columns: pd.Index[str], preferred_language: str, ending: str = r"(\d+|list|comments)"
+) -> list[str]:
+    """Get all the columns that contain the preferred language tag."""
+    return sorted(col for col in columns if regex.search(rf"^{preferred_language}_{ending}$", col))
+
+
+def get_column_info(df_cols: pd.Index[Any]) -> Columns:
+    """
+    Constructs and returns all the columns that should be present in the df based on the languages used.
+
+    Args:
+        df_cols: columns of the df
+
+    Returns:
+        Object with column info
+    """
+    hierarchy_nums = get_hierarchy_nums(df_cols)
+    all_langs = get_all_languages_for_columns(df_cols)
+    preferred_lang = get_preferred_language_from_columns(df_cols)
+    node_cols = []
+    for n in hierarchy_nums:
+        node_cols.append(ColumnNodes(level_num=int(n), columns=[f"{lang}_{n}" for lang in all_langs]))
+    comment_cols = []
+    if get_all_languages_for_columns(df_cols, r"comments"):
+        comment_cols = [f"{lang}_comments" for lang in all_langs]
+    list_columns = [f"{lang}_list" for lang in all_langs]
+    return Columns(
+        preferred_lang=preferred_lang, list_cols=list_columns, comment_cols=comment_cols, node_cols=node_cols
+    )
+
+
+def get_hierarchy_nums(columns: pd.Index[str]) -> list[int]:
+    """Get all the numbers that are used in the column names that contain a language tag."""
+    return sorted(
+        list(set(int(res.group(2)) for x in columns if (res := regex.search(r"^(en|de|fr|it|rm)_(\d+)$", x))))
+    )
+
+
+def get_all_languages_for_columns(columns: pd.Index[str], ending: str = r"(\d+|list|comments)") -> set[str]:
+    """Get all the language tags for all the columns."""
+    return set(res for x in columns if (res := get_lang_string_from_column_name(x, ending)))
+
+
+def get_preferred_language_from_columns(columns: pd.Index[str], ending: str = r"(\d+|list|comments)") -> str:
+    """Get the language tag of the preferred language."""
+    match = {res.group(1) for x in columns if (res := regex.search(rf"^(en|de|fr|it|rm)_{ending}+$", x))}
+    if "en" in match:
+        return "en"
+    elif "de" in match:
+        return "de"
+    elif "fr" in match:
+        return "fr"
+    elif "it" in match:
+        return "it"
+    elif "rm" in match:
+        return "rm"
+    msg = (
+        f"The columns may only contain the languages: 'en', 'de', 'fr', 'it', 'rm'.\n"
+        f"The columns are: {' '.join(columns)}"
+    )
+    raise InputError(msg)