dsp-tools 9.1.0.post11__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/excel2json/{new_lists → lists}/models/serialise.py

@@ -23,9 +23,11 @@ class ListNode:
         return [nd.to_dict() for nd in self.sub_nodes]
 
     def _make_own_node(self) -> dict[str, Any]:
-        d = {"name": self.id_, "labels": self.labels}
+        sorted_labels = {k: self.labels[k] for k in sorted(self.labels.keys())}
+        d = {"name": self.id_, "labels": sorted_labels}
         if self.comments:
-            d.update({"comments": self.comments})
+            sorted_comments = {k: self.comments[k] for k in sorted(self.comments.keys())}
+            d["comments"] = sorted_comments
         return d
 
 
@@ -45,9 +47,11 @@ class ListRoot:
         return [nd.to_dict() for nd in self.nodes]
 
     def _make_list_root(self) -> dict[str, Any]:
-        lst = {"name": self.id_, "labels": self.labels}
+        sorted_labels = {k: self.labels[k] for k in sorted(self.labels.keys())}
+        lst = {"name": self.id_, "labels": sorted_labels}
         if self.comments:
-            lst.update({"comments": self.comments})
+            sorted_comments = {k: self.comments[k] for k in sorted(self.comments.keys())}
+            lst["comments"] = sorted_comments
         else:
-            lst.update({"comments": self.labels})
+            lst["comments"] = sorted_labels
         return lst

dsp_tools/commands/excel2json/{new_lists → lists}/utils.py

@@ -5,9 +5,9 @@ from typing import Any
 import pandas as pd
 import regex
 
-from dsp_tools.commands.excel2json.new_lists.models.deserialise import ColumnNodes
-from dsp_tools.commands.excel2json.new_lists.models.deserialise import Columns
-from dsp_tools.models.exceptions import InputError
+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:
@@ -76,6 +76,6 @@ def get_preferred_language_from_columns(columns: pd.Index[str], ending: str = r"
         return "rm"
     msg = (
         f"The columns may only contain the languages: 'en', 'de', 'fr', 'it', 'rm'.\n"
-        f"The columns are: {" ".join(columns)}"
+        f"The columns are: {' '.join(columns)}"
     )
     raise InputError(msg)

dsp_tools/commands/excel2json/models/input_error.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from typing import Any
-from typing import Protocol
+
+from dsp_tools.error.problems import Problem
 
 separator = "\n    "
 list_separator = "\n    - "
@@ -11,15 +12,6 @@ medium_separator = "\n----------------------------\n"
 grand_separator = "\n\n---------------------------------------\n\n"
 
 
-class Problem(Protocol):
-    """Information about input errors."""
-
-    def execute_error_protocol(self) -> str:
-        """
-        This function initiates all the steps for successful problem communication with the user.
-        """
-
-
 @dataclass(frozen=True)
 class PositionInExcel:
     """This class contains the information about the position of a value in the excel."""
@@ -391,6 +383,34 @@ class PropertyProblem:
             message for the error
         """
         all_problems = [x.execute_error_protocol() for x in self.problems]
+        return f"The property '{self.prop_name}' has the following problem(s):\n{medium_separator.join(all_problems)}"
+
+
+@dataclass(frozen=True)
+class InvalidPermissionsOverrule:
+    entity_name: str
+    actual_val: str
+    allowed_vals: list[str]
+
+
+@dataclass(frozen=True)
+class InvalidPermissionsOverruleProblem:
+    """This class contains information if a "default_permissions_overrule" is invalid."""
+
+    wrong_vals: list[InvalidPermissionsOverrule]
+
+    def execute_error_protocol(self) -> str:
+        """
+        This function initiates all the steps for successful problem communication with the user.
+
+        Returns:
+            message for the error
+        """
+        report_lines = [
+            f"Entity: '{x.entity_name}'. Actual value: '{x.actual_val}'. Allowed values: {', '.join(x.allowed_vals)}."
+            for x in self.wrong_vals
+        ]
         return (
-            f"The property '{self.prop_name}' has the following problem(s):\n" f"{medium_separator.join(all_problems)}"
+            f"The following entities have an invalid 'default_permissions_overrule': "
+            f"{list_separator}{list_separator.join(report_lines)}"
         )

dsp_tools/commands/excel2json/models/json_header.py

@@ -25,6 +25,7 @@ class EmptyJsonHeader(JsonHeader):
                 "longname": "",
                 "descriptions": {"en": ""},
                 "keywords": [""],
+                "enabled_licenses": [""],
             },
         }
 
@@ -57,7 +58,9 @@ class Project:
     longname: str
     descriptions: Descriptions
     keywords: Keywords
+    licenses: Licenses
     users: Users | None
+    default_permissions: str
 
     def to_dict(self) -> dict[str, Any]:
         proj_dict: dict[str, Any] = {
@@ -66,6 +69,8 @@ class Project:
             "longname": self.longname,
             "descriptions": self.descriptions.to_dict(),
             "keywords": self.keywords.to_dict(),
+            "enabled_licenses": self.licenses.to_dict(),
+            "default_permissions": self.default_permissions,
         }
         if self.users:
             proj_dict["users"] = self.users.to_dict()
@@ -92,6 +97,14 @@ class Keywords:
         return sorted(self.keywords)
 
 
+@dataclass
+class Licenses:
+    licenses: list[str]
+
+    def to_dict(self) -> list[str]:
+        return sorted(self.licenses)
+
+
 @dataclass
 class Users:
     users: list[User]
@@ -106,12 +119,12 @@ class User:
     email: str
     givenName: str
     familyName: str
-    password: str
+    password: str | None
     lang: str
-    role: UserRole
+    isProjectAdmin: bool
 
     def to_dict(self) -> dict[str, Any]:
-        usr_dict = {
+        usr_dict: dict[str, Any] = {
             "username": self.username,
             "email": self.email,
             "givenName": self.givenName,
@@ -119,19 +132,44 @@ class User:
             "password": self.password,
             "lang": self.lang,
             "status": True,
-        } | self.role.to_dict()
+        }
+        if self.isProjectAdmin:
+            usr_dict["projects"] = [":admin", ":member"]
+        else:
+            usr_dict["projects"] = [":member"]
         return usr_dict
 
 
 @dataclass
-class UserRole:
-    project_admin: bool = False
-    sys_admin: bool = False
-
-    def to_dict(self) -> dict[str, list[str]]:
-        if self.sys_admin:
-            return {"groups": ["SystemAdmin"], "projects": [":admin", ":member"]}
-        elif self.project_admin:
-            return {"projects": [":admin", ":member"]}
-        else:
-            return {"projects": [":member"]}
+class PermissionsOverrulesUnprefixed:
+    """
+    Data gathered from the column 'default_permissions_overrule' from 1 resources.xlsx / 1 properties.xlsx,
+    not yet enriched with ontology prefixes
+    """
+
+    private: list[str]
+    limited_view: list[str]
+
+
+@dataclass
+class PermissionsOverrulesPrefixed:
+    """
+    Object to gather 'default_permissions_overrule' infos from several resources.xlsx/properties.xlsx,
+    with ontology prefixes.
+    """
+
+    private: list[str]
+    limited_view: list[str]
+
+    def add_overrules(self, new_overrules: PermissionsOverrulesUnprefixed, onto_prefix: str) -> None:
+        self.private.extend([f"{onto_prefix}:{p}" for p in new_overrules.private])
+        self.limited_view.extend([f"{onto_prefix}:{p}" for p in new_overrules.limited_view])
+
+    def non_empty(self) -> bool:
+        return bool(self.private or self.limited_view)
+
+    def serialize(self) -> dict[str, list[str]]:
+        return {
+            "private": self.private,
+            "limited_view": self.limited_view,
+        }

dsp_tools/commands/excel2json/models/ontology.py

@@ -64,12 +64,13 @@ class LanguageDict:
     lang_dict: dict[str, str]
 
     def serialise(self) -> dict[str, str]:
-        return self.lang_dict
+        sorted_dict = {k: self.lang_dict[k] for k in sorted(self.lang_dict.keys())}
+        return sorted_dict
 
 
 @dataclass
 class GuiAttributes:
-    gui_attributes: dict[str, int | str | float]
+    gui_attributes: dict[str, str]
 
-    def serialise(self) -> dict[str, int | str | float]:
+    def serialise(self) -> dict[str, str]:
         return self.gui_attributes

dsp_tools/commands/excel2json/{lists.py → old_lists.py}

@@ -2,11 +2,9 @@
 
 import importlib.resources
 import json
-from copy import deepcopy
 from pathlib import Path
 from typing import Any
 from typing import Optional
-from typing import Union
 from typing import cast
 
 import jsonschema
@@ -17,69 +15,12 @@ from openpyxl.worksheet.worksheet import Worksheet
 
 from dsp_tools.commands.excel2json.models.input_error import MoreThanOneSheetProblem
 from dsp_tools.commands.excel2json.models.list_node_name import ListNodeNames
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.models.exceptions import InputError
-from dsp_tools.models.exceptions import UserError
-from dsp_tools.utils.shared import simplify_name
+from dsp_tools.error.exceptions import InputError
+from dsp_tools.utils.data_formats.shared import simplify_name
+from dsp_tools.utils.json_parsing import parse_json_file
 
 
-def expand_lists_from_excel(
-    lists_section: list[dict[str, Union[str, dict[str, Any]]]],
-) -> list[dict[str, Any]]:
-    """
-    Checks if the "lists" section of a JSON project file contains references to Excel files.
-    Expands all Excel files to JSON,
-    and returns the expanded "lists" section.
-    If there are no references to Excel files,
-    the "lists" section is returned as is.
-
-    Args:
-        lists_section: the "lists" section of a parsed JSON project file.
-            If this is an empty list, an empty list will be returned.
-
-    Raises:
-        UserError: if a problem occurred while trying to expand the Excel files
-
-    Returns:
-        the same "lists" section, but without references to Excel files
-    """
-    new_lists: list[dict[str, Any]] = []
-    for _list in lists_section:
-        # case 1: this list is a JSON list: return it as it is
-        if "folder" not in _list["nodes"]:
-            new_lists.append(_list)
-            continue
-
-        # case 2: this is a reference to a folder with Excel files
-        new_lists.append(_read_excel_make_lists(_list))
-
-    return new_lists
-
-
-def _read_excel_make_lists(_list: dict[str, Union[str, dict[str, Any]]]) -> dict[str, Any]:
-    foldername = _list["nodes"]["folder"]  # type: ignore[index]  # types are too complex to annotate them correctly
-    excel_file_paths = _extract_excel_file_paths(foldername)
-    new_list = deepcopy(_list)
-    try:
-        returned_lists_section = _make_json_lists_from_excel(excel_file_paths, verbose=False)
-        # we only need the "nodes" section of the first element of the returned "lists" section. This "nodes"
-        # section needs to replace the Excel folder reference. But the rest of the user-defined list element
-        # needs to stay intact, e.g. the labels and comments.
-        new_list["nodes"] = returned_lists_section[0]["nodes"]
-        print(
-            f"    The list '{_list['name']}' contains a reference to the folder '{foldername}'. The Excel "
-            f"files therein have been temporarily expanded into the 'lists' section of your project."
-        )
-        return new_list
-    except BaseError as err:
-        raise UserError(
-            f"    WARNING: The list '{_list['name']}' contains a reference to the folder '{foldername}', but a "
-            f"problem occurred while trying to expand the Excel files therein into the 'lists' section of "
-            f"your project: {err.message}"
-        ) from None
-
-
-def excel2lists(
+def old_excel2lists(
     excelfolder: str,
     path_to_output_file: Optional[str] = None,
     verbose: bool = False,
@@ -93,7 +34,7 @@ def excel2lists(
         verbose: verbose switch
 
     Raises:
-        UserError: if something went wrong
+        InputError: if something went wrong
         BaseError: if something went wrong
 
     Returns:
@@ -140,7 +81,7 @@ def _get_values_from_excel(
         verbose: verbose switch
 
     Raises:
-        UserError: if one of the Excel files contains invalid data
+        InputError: if one of the Excel files contains invalid data
 
     Returns:
         int: Row index for the next loop (current row index minus 1)
@@ -149,11 +90,11 @@ def _get_values_from_excel(
     nodes: list[dict[str, Any]] = []
     currentnode: dict[str, Any] = {}
     base_file_ws: Worksheet = next(iter(base_file.values()))
-    cell: Cell = base_file_ws.cell(column=col, row=row)
+    cell: Cell = cast(Cell, base_file_ws.cell(column=col, row=row))
 
     for excelfile in excelfiles.values():
         if any((not excelfile["A1"].value, excelfile["B1"].value)):
-            raise UserError(
+            raise InputError(
                 f"ERROR: Inconsistency in Excel list: The first row must consist of exactly one value, in cell A1. "
                 f"All other cells of row 1 must be empty.\nInstead, found the following:\n"
                 f" - Cell A1: '{excelfile['A1'].value}'\n"
@@ -189,7 +130,7 @@ def _get_values_from_excel(
 
         # go one row down and repeat loop if there is a value
         row += 1
-        cell = base_file_ws.cell(column=col, row=row)
+        cell = cast(Cell, base_file_ws.cell(column=col, row=row))
 
     if col > 1:
         preval.pop()
@@ -205,7 +146,7 @@ def _check_if_predecessors_in_row_are_consistent_with_preval(
 ) -> None:
     for idx, val in enumerate(preval[:-1]):
         if val != str(base_file_ws.cell(column=idx + 1, row=row).value).strip():
-            raise UserError(
+            raise InputError(
                 "ERROR: Inconsistency in Excel list: "
                 f"{val} not equal to {str(base_file_ws.cell(column=idx + 1, row=row).value).strip()}"
             )
@@ -247,7 +188,7 @@ def _check_if_duplicate_nodes_exist(cell: Cell, list_node_names: ListNodeNames,
         list_node_names.lists_with_previous_cell_values.count(x) > 1
         for x in list_node_names.lists_with_previous_cell_values
     ):
-        raise UserError(
+        raise InputError(
             f"ERROR: There is at least one duplicate node in the list. "
             f"Found duplicate in column {cell.column}, row {cell.row}:\n'{str(cell.value).strip()}'"
         )
@@ -258,7 +199,7 @@ def _get_all_languages_of_node(excelfiles: dict[str, Worksheet], col: int, row:
     for other_lang, ws_other_lang in excelfiles.items():
         cell_value = ws_other_lang.cell(column=col, row=row).value
         if not (isinstance(cell_value, str) and len(cell_value) > 0):
-            raise UserError(
+            raise InputError(
                 "ERROR: Malformed Excel file: The Excel file with the language code "
                 f"'{other_lang}' should have a value in row {row}, column {col}"
             )
@@ -280,7 +221,7 @@ def _make_json_lists_from_excel(
         verbose: verbose switch
 
     Raises:
-        UserError: if one of the Excel files contains invalid data
+        InputError: if one of the Excel files contains invalid data
 
     Returns:
         The finished "lists" section
@@ -333,57 +274,30 @@ def _read_and_check_workbook(excelpath: Path) -> Worksheet:
     return all_worksheets[0]
 
 
-def validate_lists_section_with_schema(
-    path_to_json_project_file: Optional[str] = None,
-    lists_section: Optional[list[dict[str, Any]]] = None,
-) -> bool:
-    """
-    This function checks if a "lists" section of a JSON project is valid according to the schema. The "lists" section
-    can be passed as path to the JSON project file, or as Python object. Only one of the two arguments should be passed.
-
-    Args:
-        path_to_json_project_file: path to the JSON project file that contains the "lists" section to validate
-        lists_section: the "lists" section as Python object
-
-    Raises:
-        UserError: if the validation fails
-        BaseError: if this function is called with invalid parameters
+def validate_lists_section_from_project(project_file: Path) -> bool:
+    project = parse_json_file(project_file)
+    lists_section = project["project"].get("lists")
+    if not lists_section:
+        raise InputError(
+            f"Cannot validate 'lists' section of {project_file}, because there is no 'lists' section in this file."
+        )
+    return validate_lists_section_with_schema(lists_section)
 
-    Returns:
-        True if the "lists" section passed validation
-    """
-    err_msg = "Validation of the 'lists' section works only if exactly one of the two arguments is given."
-    match path_to_json_project_file, lists_section:
-        case None, None:
-            raise BaseError(err_msg)
-        case str(), list():
-            raise BaseError(err_msg)
 
+def validate_lists_section_with_schema(lists_section: list[dict[str, Any]]) -> bool:
     with (
         importlib.resources.files("dsp_tools")
         .joinpath("resources/schema/lists-only.json")
         .open(encoding="utf-8") as schema_file
     ):
         lists_schema = json.load(schema_file)
-
-    if path_to_json_project_file:
-        with open(path_to_json_project_file, encoding="utf-8") as f:
-            project = json.load(f)
-            lists_section = project["project"].get("lists")
-            if not lists_section:
-                raise UserError(
-                    f"Cannot validate 'lists' section of {path_to_json_project_file}, "
-                    "because there is no 'lists' section in this file."
-                )
-
     try:
         jsonschema.validate(instance={"lists": lists_section}, schema=lists_schema)
     except jsonschema.ValidationError as err:
-        raise UserError(
+        raise InputError(
             f"'lists' section did not pass validation. The error message is: {err.message}\n"
             f"The error occurred at {err.json_path}"
         ) from None
-
     return True
 
 
@@ -396,19 +310,19 @@ def _extract_excel_file_paths(excelfolder: str) -> list[Path]:
         excelfolder: path to the folder containing the Excel file(s)
 
     Raises:
-        UserError: if excelfolder is not a directory, or if one of the files in it has an invalid name
+        InputError: if excelfolder is not a directory, or if one of the files in it has an invalid name
 
     Returns:
         list of the Excel file paths to process
     """
     if not Path(excelfolder).is_dir():
-        raise UserError(f"ERROR: {excelfolder} is not a directory.")
+        raise InputError(f"ERROR: {excelfolder} is not a directory.")
 
     supported_files = ["en.xlsx", "de.xlsx", "fr.xlsx", "it.xlsx", "rm.xlsx"]
     excel_file_paths = [x for x in Path(excelfolder).glob("*.xlsx") if x.is_file() and not x.name.startswith("~$")]
 
     for filepath in excel_file_paths:
         if filepath.name not in supported_files:
-            raise UserError(f"Invalid file name '{filepath}'. Expected format: 'languagecode.xlsx'")
+            raise InputError(f"Invalid file name '{filepath}'. Expected format: 'languagecode.xlsx'")
 
     return excel_file_paths