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

dsp_tools/commands/excel2json/project.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 from pathlib import Path
 from typing import Any
@@ -5,14 +7,16 @@ from typing import Any
 import regex
 
 from dsp_tools.commands.excel2json.json_header import get_json_header
-from dsp_tools.commands.excel2json.lists import excel2lists
-from dsp_tools.commands.excel2json.new_lists.make_new_lists import new_excel2lists
+from dsp_tools.commands.excel2json.lists.make_lists import excel2lists
+from dsp_tools.commands.excel2json.models.json_header import PermissionsOverrulesPrefixed
+from dsp_tools.commands.excel2json.old_lists import old_excel2lists
 from dsp_tools.commands.excel2json.properties import excel2properties
 from dsp_tools.commands.excel2json.resources import excel2resources
-from dsp_tools.models.exceptions import UserError
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.error.exceptions import InputError
 
 
-def excel2json(
+def old_excel2json(
     data_model_files: str,
     path_to_output_file: str,
 ) -> bool:
@@ -38,16 +42,16 @@ def excel2json(
         path_to_output_file: path to the file where the output JSON file will be saved
 
     Raises:
-        UserError: if something went wrong
+        InputError: if something went wrong
         BaseError: if something went wrong
 
     Returns:
         True if everything went well
     """
 
-    listfolder, onto_folders = _validate_folder_structure_get_filenames(data_model_files)
+    listfolder, onto_folders = _old_validate_folder_structure_and_get_filenames(data_model_files)
 
-    overall_success, project = _create_project_json(data_model_files, listfolder, onto_folders)
+    overall_success, project = _old_create_project_json(data_model_files, listfolder, onto_folders)
 
     with open(path_to_output_file, "w", encoding="utf-8") as f:
         json.dump(project, f, indent=4, ensure_ascii=False)
@@ -57,17 +61,17 @@ def excel2json(
     return overall_success
 
 
-def _validate_folder_structure_get_filenames(data_model_files: str) -> tuple[list[Path], list[Path]]:
+def _old_validate_folder_structure_and_get_filenames(data_model_files: str) -> tuple[list[Path], list[Path]]:
     if not Path(data_model_files).is_dir():
-        raise UserError(f"ERROR: {data_model_files} is not a directory.")
+        raise InputError(f"ERROR: {data_model_files} is not a directory.")
     sub_folders = [x for x in Path(data_model_files).glob("*") if _non_hidden(x) and x.is_dir()]
     files_to_process = []
     onto_folders, onto_files_to_process = _get_and_validate_onto_folder(Path(data_model_files), sub_folders)
     files_to_process.extend(onto_files_to_process)
-    listfolder, lists_to_process = _get_validate_list_folder(data_model_files, sub_folders)
+    listfolder, lists_to_process = _old_get_and_validate_list_folder(data_model_files, sub_folders)
     files_to_process.extend(lists_to_process)
     if len(onto_folders) + len(listfolder) != len(sub_folders):
-        raise UserError(
+        raise InputError(
             f"The only allowed subfolders in '{data_model_files}' are 'lists' "
             "and folders that match the pattern 'onto_name (onto_label)'"
         )
@@ -78,20 +82,20 @@ def _validate_folder_structure_get_filenames(data_model_files: str) -> tuple[lis
     return listfolder, onto_folders
 
 
-def _get_validate_list_folder(data_model_files: str, folder: list[Path]) -> tuple[list[Path], list[str]]:
+def _old_get_and_validate_list_folder(data_model_files: str, folder: list[Path]) -> tuple[list[Path], list[str]]:
     processed_files: list[str] = []
     listfolder = [x for x in folder if x.is_dir() and x.name == "lists"]
     if listfolder:
         listfolder_contents = [x for x in Path(listfolder[0]).glob("*") if _non_hidden(x)]
         if not all(regex.search(r"(de|en|fr|it|rm).xlsx", file.name) for file in listfolder_contents):
-            raise UserError(
+            raise InputError(
                 f"The only files allowed in '{data_model_files}/lists' are en.xlsx, de.xlsx, fr.xlsx, it.xlsx, rm.xlsx"
             )
         processed_files = [f"{data_model_files}/lists/{file.name}" for file in listfolder_contents]
     return listfolder, processed_files
 
 
-def new_excel2json(
+def excel2json(
     data_model_files: str,
     path_to_output_file: str,
 ) -> bool:
@@ -123,26 +127,27 @@ def new_excel2json(
         True if everything went well
     """
 
-    listfolder, onto_folders = _new_validate_folder_structure_and_get_filenames(Path(data_model_files))
+    listfolder, onto_folders = _validate_folder_structure_and_get_filenames(Path(data_model_files))
 
-    overall_success, project = _new_create_project_json(data_model_files, onto_folders, listfolder)
+    overall_success, project = _create_project_json(data_model_files, onto_folders, listfolder)
 
     with open(path_to_output_file, "w", encoding="utf-8") as f:
-        json.dump(project, f, indent=4, ensure_ascii=False)
+        dump_str = json.dumps(project, indent=4, ensure_ascii=False)
+        f.write(dump_str)
 
     print(f"JSON project file successfully saved at {path_to_output_file}")
 
     return overall_success
 
 
-def _new_validate_folder_structure_and_get_filenames(data_model_files: Path) -> tuple[Path | None, list[Path]]:
+def _validate_folder_structure_and_get_filenames(data_model_files: Path) -> tuple[Path | None, list[Path]]:
     if not data_model_files.is_dir():
-        raise UserError(f"ERROR: {data_model_files} is not a directory.")
+        raise InputError(f"ERROR: {data_model_files} is not a directory.")
     folder = [x for x in data_model_files.glob("*") if _non_hidden(x)]
     processed_files = []
     onto_folders, processed_onto = _get_and_validate_onto_folder(data_model_files, folder)
     processed_files.extend(processed_onto)
-    listfolder, processed_lists = _new_get_and_validate_list_folder(data_model_files)
+    listfolder, processed_lists = _get_and_validate_list_folder(data_model_files)
     processed_files.extend(processed_lists)
     print("The following files will be processed:")
     print(*(f" - {file}" for file in processed_files), sep="\n")
@@ -153,13 +158,13 @@ def _get_and_validate_onto_folder(data_model_files: Path, folder: list[Path]) ->
     processed_files = []
     onto_folders = [x for x in folder if x.is_dir() and regex.search(r"([\w.-]+) \(([\w.\- ]+)\)", x.name)]
     if not onto_folders:
-        raise UserError(
+        raise InputError(
             f"'{data_model_files}' must contain at least one subfolder named after the pattern 'onto_name (onto_label)'"
         )
     for onto_folder in onto_folders:
         contents = sorted([x.name for x in Path(onto_folder).glob("*") if _non_hidden(x)])
         if contents != ["properties.xlsx", "resources.xlsx"]:
-            raise UserError(
+            raise InputError(
                 f"ERROR: '{data_model_files}/{onto_folder.name}' must contain one file 'properties.xlsx' "
                 "and one file 'resources.xlsx', but nothing else."
             )
@@ -167,62 +172,99 @@ def _get_and_validate_onto_folder(data_model_files: Path, folder: list[Path]) ->
     return onto_folders, processed_files
 
 
-def _new_get_and_validate_list_folder(
+def _get_and_validate_list_folder(
     data_model_files: Path,
 ) -> tuple[Path | None, list[str]]:
     if not (list_dir := (data_model_files / "lists")).is_dir():
         return None, []
     processed_files = [str(file) for file in list_dir.glob("*list*.xlsx") if _non_hidden(file)]
-    return list_dir, processed_files
+    return list_dir, sorted(processed_files)
 
 
 def _non_hidden(path: Path) -> bool:
     return not regex.search(r"^(\.|~\$).+", path.name)
 
 
-def _create_project_json(
+def _old_create_project_json(
     data_model_files: str, listfolder: list[Path], onto_folders: list[Path]
 ) -> tuple[bool, dict[str, Any]]:
     overall_success = True
-    lists, success = excel2lists(excelfolder=f"{data_model_files}/lists") if listfolder else (None, True)
+    lists, success = old_excel2lists(excelfolder=f"{data_model_files}/lists") if listfolder else (None, True)
     if not success:
         overall_success = False
-    ontologies, success = _get_ontologies(data_model_files, onto_folders)
+    ontologies, default_permissions_overrule, success = _get_ontologies(data_model_files, onto_folders)
     if not success:
         overall_success = False
     project = get_json_header(Path(data_model_files) / "json_header.xlsx").to_dict()
+    if default_permissions_overrule.non_empty():
+        project["project"]["default_permissions_overrule"] = default_permissions_overrule.serialize()
     if lists:
         project["project"]["lists"] = lists
     project["project"]["ontologies"] = ontologies
+    project["project"] = _sort_project_dict(project["project"])
     return overall_success, project
 
 
-def _new_create_project_json(
+def _create_project_json(
     data_model_files: str, onto_folders: list[Path], list_folder: Path | None
 ) -> tuple[bool, dict[str, Any]]:
     overall_success = True
     lists = None
     if list_folder:
-        lists, success = new_excel2lists(list_folder)
+        lists, success = excel2lists(list_folder)
         if not success:
             overall_success = False
-    ontologies, success = _get_ontologies(data_model_files, onto_folders)
+    ontologies, default_permissions_overrule, success = _get_ontologies(data_model_files, onto_folders)
     if not success:
         overall_success = False
     project = get_json_header(Path(data_model_files) / "json_header.xlsx").to_dict()
+    if default_permissions_overrule.non_empty():
+        project["project"]["default_permissions_overrule"] = default_permissions_overrule.serialize()
     if lists:
         project["project"]["lists"] = lists
     project["project"]["ontologies"] = ontologies
+    project["project"] = _sort_project_dict(project["project"])
     return overall_success, project
 
 
-def _get_ontologies(data_model_files: str, onto_folders: list[Path]) -> tuple[list[dict[str, Any]], bool]:
+def _sort_project_dict(unsorted_project_dict: dict[str, Any]) -> dict[str, Any]:
+    # order how the keys should appear in the JSON file
+    ordered_keys = [
+        "shortcode",
+        "shortname",
+        "longname",
+        "descriptions",
+        "keywords",
+        "enabled_licenses",
+        "default_permissions",
+        "default_permissions_overrule",
+        "users",
+        "groups",
+        "lists",
+        "ontologies",
+    ]
+    # filter out unused keys, to prevent a KeyError
+    ordered_keys = [key for key in ordered_keys if key in unsorted_project_dict]
+    # important - if in the future, more keys are added, they must be added to the list above
+    if any(forgotten_keys := [key for key in unsorted_project_dict if key not in ordered_keys]):
+        raise BaseError(
+            "The list of keys is outdated. During sorting, the following keys would be discarded: "
+            + ", ".join(forgotten_keys)
+        )
+    # do the actual sorting
+    return {key: unsorted_project_dict[key] for key in ordered_keys}
+
+
+def _get_ontologies(
+    data_model_files: str, onto_folders: list[Path]
+) -> tuple[list[dict[str, Any]], PermissionsOverrulesPrefixed, bool]:
     success = True
     ontologies = []
+    permissions_overrules = PermissionsOverrulesPrefixed(private=[], limited_view=[])
     for onto_folder in onto_folders:
         name, label = regex.search(r"([\w.-]+) \(([\w.\- ]+)\)", onto_folder.name).groups()  # type: ignore[union-attr]
-        resources, success1 = excel2resources(f"{data_model_files}/{onto_folder.name}/resources.xlsx")
-        properties, success2 = excel2properties(f"{data_model_files}/{onto_folder.name}/properties.xlsx")
+        resources, r_overrules, success1 = excel2resources(f"{data_model_files}/{onto_folder.name}/resources.xlsx")
+        properties, p_overrules, success2 = excel2properties(f"{data_model_files}/{onto_folder.name}/properties.xlsx")
         if not success1 or not success2:
             success = False
         ontologies.append(
@@ -233,4 +275,6 @@ def _get_ontologies(data_model_files: str, onto_folders: list[Path]) -> tuple[li
                 "resources": resources,
             }
         )
-    return ontologies, success
+        permissions_overrules.add_overrules(r_overrules, name)
+        permissions_overrules.add_overrules(p_overrules, name)
+    return ontologies, permissions_overrules, success

dsp_tools/commands/excel2json/properties.py

@@ -19,13 +19,14 @@ from dsp_tools.commands.excel2json.models.input_error import JsonValidationPrope
 from dsp_tools.commands.excel2json.models.input_error import MissingValuesProblem
 from dsp_tools.commands.excel2json.models.input_error import MoreThanOneSheetProblem
 from dsp_tools.commands.excel2json.models.input_error import PositionInExcel
-from dsp_tools.commands.excel2json.models.input_error import Problem
 from dsp_tools.commands.excel2json.models.input_error import PropertyProblem
+from dsp_tools.commands.excel2json.models.json_header import PermissionsOverrulesUnprefixed
 from dsp_tools.commands.excel2json.models.ontology import GuiAttributes
 from dsp_tools.commands.excel2json.models.ontology import OntoProperty
 from dsp_tools.commands.excel2json.utils import add_optional_columns
 from dsp_tools.commands.excel2json.utils import check_column_for_duplicate
 from dsp_tools.commands.excel2json.utils import check_contains_required_columns
+from dsp_tools.commands.excel2json.utils import check_permissions
 from dsp_tools.commands.excel2json.utils import check_required_values
 from dsp_tools.commands.excel2json.utils import col_must_or_not_empty_based_on_other_col
 from dsp_tools.commands.excel2json.utils import find_one_full_cell_in_cols
@@ -33,17 +34,18 @@ from dsp_tools.commands.excel2json.utils import get_comments
 from dsp_tools.commands.excel2json.utils import get_labels
 from dsp_tools.commands.excel2json.utils import get_wrong_row_numbers
 from dsp_tools.commands.excel2json.utils import read_and_clean_all_sheets
-from dsp_tools.models.exceptions import InputError
+from dsp_tools.error.exceptions import InputError
+from dsp_tools.error.exceptions import InvalidGuiAttributeError
+from dsp_tools.error.problems import Problem
 
 languages = ["en", "de", "fr", "it", "rm"]
 language_label_col = ["label_en", "label_de", "label_fr", "label_it", "label_rm"]
-mandatory_properties = ["name", "object", "gui_element"]
 
 
 def excel2properties(
     excelfile: str,
     path_to_output_file: Optional[str] = None,
-) -> tuple[list[dict[str, Any]], bool]:
+) -> tuple[list[dict[str, Any]], PermissionsOverrulesUnprefixed, bool]:
     """
     Converts properties described in an Excel file into a "properties" section which can be inserted into a JSON
     project file.
@@ -56,8 +58,9 @@ def excel2properties(
         InputError: if something went wrong
 
     Returns:
-        a tuple consisting of the "properties" section as a Python list,
-            and the success status (True if everything went well)
+        - the "properties" section as a Python list
+        - the unprefixed "default_permissions_overrule"
+        - the success status (True if everything went well)
     """
 
     property_df = _read_check_property_df(excelfile)
@@ -77,6 +80,7 @@ def excel2properties(
         "comment_it",
         "comment_rm",
         "subject",
+        "default_permissions_overrule",
     }
     property_df = add_optional_columns(property_df, optional_col_set)
 
@@ -101,6 +105,7 @@ def excel2properties(
         raise InputError(msg)
 
     serialised_prop = [x.serialise() for x in props]
+    default_permissions_overrule = _extract_default_permissions_overrule(property_df)
 
     # write final JSON file
     _validate_properties_section_in_json(properties_list=serialised_prop)
@@ -109,7 +114,7 @@ def excel2properties(
             json.dump(serialised_prop, file, indent=4, ensure_ascii=False)
             print(f"properties section was created successfully and written to file '{path_to_output_file}'")
 
-    return serialised_prop, True
+    return serialised_prop, default_permissions_overrule, True
 
 
 def _check_for_deprecated_syntax(df: pd.DataFrame) -> None:
@@ -176,6 +181,8 @@ def _do_property_excel_compliance(df: pd.DataFrame) -> None:
         problems.append(col_prob)
     if missing_vals_check := _check_missing_values_in_row(df=df):
         problems.append(missing_vals_check)
+    if permissions_prob := check_permissions(df=df, allowed_vals=["private"]):
+        problems.append(permissions_prob)
     if any(problems):
         excel_prob = ExcelFileProblem("properties.xlsx", problems)
         msg = excel_prob.execute_error_protocol()
@@ -202,7 +209,7 @@ def _check_missing_values_in_row(df: pd.DataFrame) -> None | MissingValuesProble
 
 
 def _check_compliance_gui_attributes(df: pd.DataFrame) -> dict[str, pd.Series[bool]] | None:
-    mandatory_attributes = ["Spinbox", "List"]
+    mandatory_attributes = ["List"]
     mandatory_check = col_must_or_not_empty_based_on_other_col(
         df=df,
         substring_list=mandatory_attributes,
@@ -210,7 +217,18 @@ def _check_compliance_gui_attributes(df: pd.DataFrame) -> dict[str, pd.Series[bo
         check_empty_colname="gui_attributes",
         must_have_value=True,
     )
-    no_attributes = ["Checkbox", "Date", "Geonames", "Richtext", "TimeStamp"]
+    no_attributes = [
+        "Checkbox",
+        "Colorpicker",
+        "Date",
+        "Spinbox",
+        "Geonames",
+        "SimpleText",
+        "Textarea",
+        "Richtext",
+        "TimeStamp",
+        "Searchbox",
+    ]
     no_attribute_check = col_must_or_not_empty_based_on_other_col(
         df=df,
         substring_list=no_attributes,
@@ -230,11 +248,11 @@ def _get_final_series(
         case None, None:
             return None
         case pd.Series(), pd.Series():
-            final_series = pd.Series(np.logical_or(mandatory_check, no_attribute_check))  # type: ignore[arg-type, assignment]
+            final_series = pd.Series(np.logical_or(mandatory_check, no_attribute_check))
         case pd.Series(), None:
-            final_series = mandatory_check  # type: ignore[assignment]
+            final_series = mandatory_check
         case None, pd.Series():
-            final_series = no_attribute_check  # type: ignore[assignment]
+            final_series = no_attribute_check
     return final_series
 
 
@@ -263,39 +281,31 @@ def _get_gui_attribute(
 ) -> GuiAttributes | InvalidExcelContentProblem | None:
     if pd.isnull(df_row["gui_attributes"]):
         return None
-    # If the attribute is not in the correct format, a called function may raise an IndexError
     try:
-        return _format_gui_attribute(attribute_str=df_row["gui_attributes"])
-    except IndexError:
+        return _unpack_gui_attributes(attribute_str=df_row["gui_attributes"])
+    except InvalidGuiAttributeError:
         return InvalidExcelContentProblem(
-            expected_content="attribute: value, attribute: value",
+            expected_content="The only valid gui-attribute is 'hlist' for the gui-element 'List'.",
             actual_content=df_row["gui_attributes"],
             excel_position=PositionInExcel(column="gui_attributes", row=row_num),
         )
 
 
-def _format_gui_attribute(attribute_str: str) -> GuiAttributes:
-    attribute_dict = _unpack_gui_attributes(attribute_str=attribute_str)
-    return GuiAttributes(
-        {attrib: _search_convert_numbers_in_str(value_str=val) for attrib, val in attribute_dict.items()}
-    )
-
-
-def _unpack_gui_attributes(attribute_str: str) -> dict[str, str]:
-    gui_list = [x.strip() for x in attribute_str.split(",") if x.strip() != ""]
-    sub_gui_list = [[sub.strip() for sub in x.split(":") if sub.strip() != ""] for x in gui_list]
-    if any(len(sub) != 2 for sub in sub_gui_list):
-        raise IndexError
-    return {sub[0]: sub[1] for sub in sub_gui_list}
+def _unpack_gui_attributes(attribute_str: str) -> GuiAttributes:
+    attribute_str = attribute_str.strip()
+    if not attribute_str:
+        return GuiAttributes({})
+    attrib_key, attrib_val = _extract_information_from_single_gui_attribute(attribute_str)
+    if attrib_key != "hlist":
+        raise InvalidGuiAttributeError("The only valid gui-attribute is 'hlist' for the gui-element 'List'.")
+    return GuiAttributes({attrib_key: attrib_val})
 
 
-def _search_convert_numbers_in_str(value_str: str) -> str | int | float:
-    if regex.search(r"^\d+$", value_str):
-        return int(value_str)
-    elif regex.search(r"^\d+\.\d+$", value_str):
-        return float(value_str)
-    else:
-        return value_str
+def _extract_information_from_single_gui_attribute(attribute_str: str) -> tuple[str, str]:
+    attrib_format = r"(\S+)\s*:\s*(.+)"
+    if found := regex.search(attrib_format, attribute_str):
+        return found.group(1), found.group(2)
+    raise InvalidGuiAttributeError("Invalid gui attribute")
 
 
 def _validate_properties_section_in_json(
@@ -347,3 +357,14 @@ def _find_validation_problem(
         original_msg=validation_error.message,
         message_path=validation_error.json_path,
     )
+
+
+def _extract_default_permissions_overrule(property_df: pd.DataFrame) -> PermissionsOverrulesUnprefixed:
+    result = PermissionsOverrulesUnprefixed(private=[], limited_view=[])
+    for _, row in property_df.iterrows():
+        perm = row.get("default_permissions_overrule")
+        if pd.isna(perm):
+            continue
+        if perm.strip().lower() == "private":
+            result.private.append(row["name"])
+    return result

dsp_tools/commands/excel2json/resources.py

@@ -18,18 +18,20 @@ from dsp_tools.commands.excel2json.models.input_error import JsonValidationResou
 from dsp_tools.commands.excel2json.models.input_error import MandatorySheetsMissingProblem
 from dsp_tools.commands.excel2json.models.input_error import MissingValuesProblem
 from dsp_tools.commands.excel2json.models.input_error import PositionInExcel
-from dsp_tools.commands.excel2json.models.input_error import Problem
 from dsp_tools.commands.excel2json.models.input_error import ResourceSheetNotListedProblem
+from dsp_tools.commands.excel2json.models.json_header import PermissionsOverrulesUnprefixed
 from dsp_tools.commands.excel2json.models.ontology import OntoResource
 from dsp_tools.commands.excel2json.models.ontology import ResourceCardinality
 from dsp_tools.commands.excel2json.utils import add_optional_columns
 from dsp_tools.commands.excel2json.utils import check_column_for_duplicate
 from dsp_tools.commands.excel2json.utils import check_contains_required_columns
+from dsp_tools.commands.excel2json.utils import check_permissions
 from dsp_tools.commands.excel2json.utils import find_missing_required_values
 from dsp_tools.commands.excel2json.utils import get_comments
 from dsp_tools.commands.excel2json.utils import get_labels
 from dsp_tools.commands.excel2json.utils import read_and_clean_all_sheets
-from dsp_tools.models.exceptions import InputError
+from dsp_tools.error.exceptions import InputError
+from dsp_tools.error.problems import Problem
 
 languages = ["en", "de", "fr", "it", "rm"]
 
@@ -37,7 +39,7 @@ languages = ["en", "de", "fr", "it", "rm"]
 def excel2resources(
     excelfile: str,
     path_to_output_file: Optional[str] = None,
-) -> tuple[list[dict[str, Any]], bool]:
+) -> tuple[list[dict[str, Any]], PermissionsOverrulesUnprefixed, bool]:
     """
     Converts resources described in an Excel file into a "resources" section which can be inserted into a JSON
     project file.
@@ -48,12 +50,12 @@ def excel2resources(
             (otherwise, it's only returned as return value)
 
     Raises:
-        UserError: if something went wrong
-        InputError: is something went wrong
+        InputError: if something went wrong
 
     Returns:
-        a tuple consisting of the "resources" section as Python list,
-            and the success status (True if everything went well)
+        - the "resources" section as Python list,
+        - the unprefixed "default_permissions_overrule",
+        - the success status (True if everything went well)
     """
 
     all_dfs = read_and_clean_all_sheets(excelfile)
@@ -66,6 +68,7 @@ def excel2resources(
     # transform every row into a resource
     res = [_row2resource(row, resource_dfs.get(row["name"])) for i, row in classes_df.iterrows()]
     resources = [x.serialise() for x in res]
+    default_permissions_overrule = _extract_default_permissions_overrule(classes_df)
 
     # write final "resources" section into a JSON file
     _validate_resources(resources_list=resources)
@@ -75,7 +78,7 @@ def excel2resources(
             json.dump(resources, file, indent=4, ensure_ascii=False)
             print(f"resources section was created successfully and written to file '{path_to_output_file}'")
 
-    return resources, True
+    return resources, default_permissions_overrule, True
 
 
 def _validate_excel_file(all_dfs: dict[str, pd.DataFrame]) -> ExcelFileProblem | None:
@@ -91,6 +94,8 @@ def _validate_excel_file(all_dfs: dict[str, pd.DataFrame]) -> ExcelFileProblem |
         problems.append(cls_problem)
     if sheet_problems := _validate_individual_class_sheets(df_dict):
         problems.extend(sheet_problems)
+    if permissions_prob := check_permissions(df=classes_df, allowed_vals=["private", "limited_view"]):
+        problems.append(permissions_prob)
     if problems:
         return ExcelFileProblem("resources.xlsx", problems)
     return None
@@ -153,6 +158,7 @@ def _prepare_classes_df(resource_dfs: dict[str, pd.DataFrame]) -> tuple[pd.DataF
             "comment_fr",
             "comment_it",
             "comment_rm",
+            "default_permissions_overrule",
         },
     )
     resource_dfs = {k: add_optional_columns(v, {"gui_order"}) for k, v in resource_dfs.items()}
@@ -173,7 +179,7 @@ def _row2resource(
         class_df_with_cardinalities: Excel sheet of the individual class
 
     Raises:
-        UserError: if the row or the details sheet contains invalid data
+        InputError: if the row or the details sheet contains invalid data
 
     Returns:
         dict object of the resource
@@ -204,9 +210,10 @@ def _create_all_cardinalities(class_name: str, class_df_with_cardinalities: pd.D
 
 
 def _make_one_cardinality(detail_row: pd.Series[str | int]) -> ResourceCardinality:
-    return ResourceCardinality(
-        f":{detail_row["property"]}", str(detail_row["cardinality"]).lower(), int(detail_row["gui_order"])
-    )
+    prop_str = str(detail_row["property"])
+    knora_props = ["seqnum", "isPartOf"]
+    prop = prop_str if ":" in prop_str or prop_str in knora_props else f":{prop_str}"
+    return ResourceCardinality(prop, str(detail_row["cardinality"]).lower(), int(detail_row["gui_order"]))
 
 
 def _check_complete_gui_order(class_name: str, class_df_with_cardinalities: pd.DataFrame) -> pd.DataFrame:
@@ -314,3 +321,16 @@ def _find_validation_problem(
         original_msg=validation_error.message,
         message_path=validation_error.json_path,
     )
+
+
+def _extract_default_permissions_overrule(classes_df: pd.DataFrame) -> PermissionsOverrulesUnprefixed:
+    result = PermissionsOverrulesUnprefixed(private=[], limited_view=[])
+    for _, row in classes_df.iterrows():
+        perm = row.get("default_permissions_overrule")
+        if pd.isna(perm):
+            continue
+        if perm.strip().lower() == "private":
+            result.private.append(row["name"])
+        elif perm.strip().lower() == "limited_view":
+            result.limited_view.append(row["name"])
+    return result

dsp_tools/commands/excel2json/utils.py

@@ -11,11 +11,14 @@ import regex
 from dsp_tools.commands.excel2json.models.input_error import DuplicateSheetProblem
 from dsp_tools.commands.excel2json.models.input_error import DuplicatesInColumnProblem
 from dsp_tools.commands.excel2json.models.input_error import ExcelFileProblem
+from dsp_tools.commands.excel2json.models.input_error import InvalidPermissionsOverrule
+from dsp_tools.commands.excel2json.models.input_error import InvalidPermissionsOverruleProblem
 from dsp_tools.commands.excel2json.models.input_error import InvalidSheetNameProblem
 from dsp_tools.commands.excel2json.models.input_error import PositionInExcel
 from dsp_tools.commands.excel2json.models.input_error import RequiredColumnMissingProblem
 from dsp_tools.commands.excel2json.models.ontology import LanguageDict
-from dsp_tools.models.exceptions import InputError
+from dsp_tools.error.exceptions import InputError
+from dsp_tools.error.exceptions import UserFilepathNotFoundError
 
 languages = ["en", "de", "fr", "it", "rm"]
 
@@ -36,6 +39,8 @@ def read_and_clean_all_sheets(excelfile: str | Path) -> dict[str, pd.DataFrame]:
     Raises:
         InputError: If the sheets are not correctly named
     """
+    if not Path(excelfile).exists():
+        raise UserFilepathNotFoundError(excelfile)
     try:
         df_dict = pd.read_excel(excelfile, sheet_name=None)
     except ValueError:
@@ -331,3 +336,17 @@ def add_optional_columns(df: pd.DataFrame, optional_col_set: set[str]) -> pd.Dat
         additional_df = pd.DataFrame(columns=additional_col, index=df.index)
         df = pd.concat(objs=[df, additional_df], axis=1)
     return df
+
+
+def check_permissions(df: pd.DataFrame, allowed_vals: list[str]) -> None | InvalidPermissionsOverruleProblem:
+    problems: list[InvalidPermissionsOverrule] = []
+    for _, row in df.iterrows():
+        if pd.isna(actual_val := row.get("default_permissions_overrule")):
+            continue
+        if actual_val.strip().lower() not in allowed_vals:
+            prob = InvalidPermissionsOverrule(entity_name=row["name"], actual_val=actual_val, allowed_vals=allowed_vals)
+            problems.append(prob)
+    if problems:
+        return InvalidPermissionsOverruleProblem(problems)
+    else:
+        return None

dsp_tools/commands/excel2xml/__init__.py

@@ -3,5 +3,5 @@
 
 from dsp_tools.commands.excel2xml.excel2xml_lib import *
 from dsp_tools.commands.excel2xml.propertyelement import PropertyElement as PropertyElement
-from dsp_tools.utils.shared import check_notna as check_notna
-from dsp_tools.utils.shared import simplify_name as simplify_name
+from dsp_tools.utils.data_formats.shared import check_notna as check_notna
+from dsp_tools.utils.data_formats.shared import simplify_name as simplify_name