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

dsp_tools/commands/validate_data/validate_data.py

@@ -0,0 +1,283 @@
+from datetime import datetime
+from pathlib import Path
+from typing import cast
+
+import pandas as pd
+from loguru import logger
+
+from dsp_tools.cli.args import ServerCredentials
+from dsp_tools.cli.args import ValidateDataConfig
+from dsp_tools.cli.args import ValidationSeverity
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.authentication_client_live import AuthenticationClientLive
+from dsp_tools.clients.metadata_client import ExistingResourcesRetrieved
+from dsp_tools.commands.validate_data.models.input_problems import OntologyValidationProblem
+from dsp_tools.commands.validate_data.models.input_problems import SortedProblems
+from dsp_tools.commands.validate_data.models.input_problems import UnknownClassesInData
+from dsp_tools.commands.validate_data.models.input_problems import ValidateDataResult
+from dsp_tools.commands.validate_data.models.validation import RDFGraphs
+from dsp_tools.commands.validate_data.models.validation import ValidationReportGraphs
+from dsp_tools.commands.validate_data.prepare_data.prepare_data import get_info_and_parsed_resources_from_file
+from dsp_tools.commands.validate_data.prepare_data.prepare_data import prepare_data_for_validation_from_parsed_resource
+from dsp_tools.commands.validate_data.process_validation_report.get_user_validation_message import get_user_message
+from dsp_tools.commands.validate_data.process_validation_report.get_user_validation_message import sort_user_problems
+from dsp_tools.commands.validate_data.process_validation_report.query_validation_result import reformat_validation_graph
+from dsp_tools.commands.validate_data.shacl_cli_validator import ShaclCliValidator
+from dsp_tools.commands.validate_data.validation.check_duplicate_files import check_for_duplicate_files
+from dsp_tools.commands.validate_data.validation.check_for_unknown_classes import check_for_unknown_resource_classes
+from dsp_tools.commands.validate_data.validation.check_for_unknown_classes import get_msg_str_unknown_classes_in_data
+from dsp_tools.commands.validate_data.validation.get_validation_report import get_validation_report
+from dsp_tools.commands.validate_data.validation.validate_ontology import get_msg_str_ontology_validation_violation
+from dsp_tools.commands.validate_data.validation.validate_ontology import validate_ontology
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.utils.ansi_colors import BACKGROUND_BOLD_CYAN
+from dsp_tools.utils.ansi_colors import BACKGROUND_BOLD_GREEN
+from dsp_tools.utils.ansi_colors import BACKGROUND_BOLD_RED
+from dsp_tools.utils.ansi_colors import BACKGROUND_BOLD_YELLOW
+from dsp_tools.utils.ansi_colors import BOLD_CYAN
+from dsp_tools.utils.ansi_colors import BOLD_RED
+from dsp_tools.utils.ansi_colors import BOLD_YELLOW
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+from dsp_tools.utils.data_formats.uri_util import is_prod_like_server
+from dsp_tools.utils.xml_parsing.models.parsed_resource import ParsedResource
+
+VALIDATION_ERRORS_FOUND_MSG = BACKGROUND_BOLD_RED + "\n   Validation errors found!   " + RESET_TO_DEFAULT
+NO_VALIDATION_ERRORS_FOUND_MSG = BACKGROUND_BOLD_GREEN + "\n   No validation errors found!   " + RESET_TO_DEFAULT
+
+
+def validate_data(
+    filepath: Path,
+    creds: ServerCredentials,
+    ignore_duplicate_files_warning: bool,
+    save_graphs: bool,
+    skip_ontology_validation: bool,
+    id2iri_file: str | None,
+    do_not_request_resource_metadata_from_db: bool,
+) -> bool:
+    """
+    Takes a file and project information and validates it against the ontologies on the server.
+
+    Args:
+        filepath: path to the xml data file
+        creds: server credentials for authentication
+        ignore_duplicate_files_warning: ignore the shape that checks for duplicate files
+        save_graphs: if this flag is set, all the graphs will be saved in a folder
+        skip_ontology_validation: skip the ontology validation
+        id2iri_file: to replace internal IDs of an XML file by IRIs provided in this mapping file
+        do_not_request_resource_metadata_from_db: true if no metadata for existing resources should be requested
+
+    Returns:
+        True if no errors that impede an xmlupload were found.
+        Warnings and user info do not impede an xmlupload.
+    """
+    graph_save_dir = None
+
+    if save_graphs:
+        graph_save_dir = _get_graph_save_dir(filepath)
+    config = ValidateDataConfig(
+        xml_file=filepath,
+        save_graph_dir=graph_save_dir,
+        severity=ValidationSeverity.INFO,
+        ignore_duplicate_files_warning=ignore_duplicate_files_warning,
+        is_on_prod_server=is_prod_like_server(creds.server),
+        skip_ontology_validation=skip_ontology_validation,
+        do_not_request_resource_metadata_from_db=do_not_request_resource_metadata_from_db,
+    )
+    auth = AuthenticationClientLive(server=creds.server, email=creds.user, password=creds.password)
+
+    parsed_resources, shortcode, authorship_lookup, permission_ids = get_info_and_parsed_resources_from_file(
+        file=filepath,
+        api_url=auth.server,
+        id2iri_file=id2iri_file,
+    )
+    return validate_parsed_resources(
+        parsed_resources=parsed_resources,
+        authorship_lookup=authorship_lookup,
+        permission_ids=permission_ids,
+        shortcode=shortcode,
+        config=config,
+        auth=auth,
+    )
+
+
+def validate_parsed_resources(
+    parsed_resources: list[ParsedResource],
+    authorship_lookup: dict[str, list[str]],
+    permission_ids: list[str],
+    shortcode: str,
+    config: ValidateDataConfig,
+    auth: AuthenticationClient,
+) -> bool:
+    msg = "Starting SHACL schema validation."
+    print(msg)
+    logger.debug(msg)
+    rdf_graphs, used_iris, existing_resources_retrieved = prepare_data_for_validation_from_parsed_resource(
+        parsed_resources=parsed_resources,
+        authorship_lookup=authorship_lookup,
+        permission_ids=permission_ids,
+        auth=auth,
+        shortcode=shortcode,
+        do_not_request_resource_metadata_from_db=config.do_not_request_resource_metadata_from_db,
+    )
+    validation_result = _validate_data(
+        rdf_graphs, used_iris, parsed_resources, config, shortcode, existing_resources_retrieved
+    )
+    if validation_result.no_problems:
+        logger.debug("No validation errors found.")
+        print(NO_VALIDATION_ERRORS_FOUND_MSG)
+        return True
+    if isinstance(validation_result.problems, UnknownClassesInData):
+        msg = get_msg_str_unknown_classes_in_data(validation_result.problems)
+        logger.error(msg)
+        print(VALIDATION_ERRORS_FOUND_MSG)
+        print(msg + "\n")
+        # if unknown classes are found, we cannot validate all the data in the file
+        return False
+    if isinstance(validation_result.problems, OntologyValidationProblem):
+        msg = get_msg_str_ontology_validation_violation(validation_result.problems)
+        logger.error(msg)
+        print(VALIDATION_ERRORS_FOUND_MSG)
+        print(msg + "\n")
+        # if the ontology itself has errors, we will not validate the data
+        return False
+    if isinstance(validation_result.problems, SortedProblems):
+        _print_shacl_validation_violation_message(validation_result.problems, validation_result.report_graphs, config)
+        return _get_validation_status(validation_result.problems, config.is_on_prod_server)
+    else:
+        raise BaseError(f"Unknown validate data problems: {validation_result.problems!s}")
+
+
+def _validate_data(
+    graphs: RDFGraphs,
+    used_iris: set[str],
+    parsed_resources: list[ParsedResource],
+    config: ValidateDataConfig,
+    shortcode: str,
+    existing_resources_retrieved: ExistingResourcesRetrieved,
+) -> ValidateDataResult:
+    logger.debug(f"Validate-data called with the following config: {vars(config)}")
+    # Check if unknown classes are used
+    if unknown_classes := check_for_unknown_resource_classes(graphs, used_iris):
+        return ValidateDataResult(False, unknown_classes, None)
+    shacl_validator = ShaclCliValidator()
+    if not config.skip_ontology_validation:
+        # Validation of the ontology
+        onto_validation_result = validate_ontology(graphs.ontos, shacl_validator, config)
+        if onto_validation_result:
+            return ValidateDataResult(False, onto_validation_result, None)
+    # Validation of the data
+    duplicate_file_warnings = None
+    if not config.ignore_duplicate_files_warning:
+        duplicate_file_warnings = check_for_duplicate_files(parsed_resources)
+    report = get_validation_report(graphs, shacl_validator, config.save_graph_dir)
+    if report.conforms:
+        if not duplicate_file_warnings:
+            return ValidateDataResult(True, None, None)
+        else:
+            sorted_problems = SortedProblems(
+                unique_violations=[],
+                user_warnings=duplicate_file_warnings.problems,
+                user_info=[],
+                unexpected_shacl_validation_components=[],
+            )
+            return ValidateDataResult(False, sorted_problems, report)
+    reformatted = reformat_validation_graph(report)
+    sorted_problems = sort_user_problems(reformatted, duplicate_file_warnings, shortcode, existing_resources_retrieved)
+    return ValidateDataResult(False, sorted_problems, report)
+
+
+def _get_graph_save_dir(filepath: Path) -> Path:
+    parent_directory = filepath.parent
+    new_directory = parent_directory / "graphs"
+    new_directory.mkdir(exist_ok=True)
+    save_file_template = new_directory / filepath.stem
+    print(BOLD_CYAN + f"\n   Saving graphs to {save_file_template}   " + RESET_TO_DEFAULT)
+    return save_file_template
+
+
+def _get_validation_status(all_problems: SortedProblems, is_on_prod: bool) -> bool:
+    violations = any(
+        [
+            bool(all_problems.unique_violations),
+            bool(all_problems.unexpected_shacl_validation_components),
+        ]
+    )
+    if violations:
+        return False
+    if is_on_prod and all_problems.user_warnings:
+        return False
+    return True
+
+
+def _print_shacl_validation_violation_message(
+    sorted_problems: SortedProblems, report: ValidationReportGraphs | None, config: ValidateDataConfig
+) -> None:
+    messages = get_user_message(sorted_problems, config.severity)
+    if messages.violations:
+        print(VALIDATION_ERRORS_FOUND_MSG)
+        print(BOLD_RED, messages.violations.message_header, RESET_TO_DEFAULT)
+        v_body = messages.violations.message_body
+        if messages.violations.message_df is not None:
+            v_body = _save_message_df_get_message_body(messages.violations.message_df, "error", config.xml_file)
+        print(v_body)
+        logger.error(messages.violations.message_header, v_body)
+    else:
+        logger.debug("No validation errors found.")
+        print(NO_VALIDATION_ERRORS_FOUND_MSG)
+    if messages.warnings and config.severity.value <= 2:
+        print(BACKGROUND_BOLD_YELLOW + "\n    Warning!    " + RESET_TO_DEFAULT)
+        print(BOLD_YELLOW, messages.warnings.message_header, RESET_TO_DEFAULT)
+        w_body = messages.warnings.message_body
+        if messages.warnings.message_df is not None:
+            w_body = _save_message_df_get_message_body(messages.warnings.message_df, "warning", config.xml_file)
+        print(w_body)
+        logger.warning(messages.warnings.message_header, w_body)
+    if messages.infos and config.severity.value == 1:
+        print(BACKGROUND_BOLD_CYAN + "\n    Potential Problems Found    " + RESET_TO_DEFAULT)
+        print(BOLD_CYAN, messages.infos.message_header, RESET_TO_DEFAULT)
+        i_body = messages.infos.message_body
+        if messages.infos.message_df is not None:
+            i_body = _save_message_df_get_message_body(messages.infos.message_df, "info", config.xml_file)
+        print(i_body)
+        logger.info(messages.infos.message_header, i_body)
+    if messages.unexpected_violations:
+        logger.error(messages.unexpected_violations.message_header, messages.unexpected_violations.message_body)
+        print(
+            BACKGROUND_BOLD_RED,
+            "\n    Unknown violations found!   ",
+            RESET_TO_DEFAULT,
+        )
+        if config.save_graph_dir:
+            print(
+                BOLD_RED,
+                messages.unexpected_violations.message_header,
+                "Consult the saved graphs for details.",
+                RESET_TO_DEFAULT,
+            )
+            print(messages.unexpected_violations.message_body)
+        else:
+            report_graph = cast(ValidationReportGraphs, report)
+            _save_unexpected_results_and_inform_user(report_graph, config.xml_file)
+    print("\n")
+
+
+def _save_message_df_get_message_body(df: pd.DataFrame, severity: str, file_path: Path) -> str:
+    out_path = file_path.parent / f"{file_path.stem}_validation_{severity}.csv"
+    msg = f"Due to the large number of violations the information was saved at '{out_path}'"
+    df.to_csv(out_path, index=False)
+    return msg
+
+
+def _save_unexpected_results_and_inform_user(report: ValidationReportGraphs, filepath: Path) -> None:
+    timestamp = f"{datetime.now()!s}_"
+    save_path = filepath.parent / f"{timestamp}_validation_result.ttl"
+    report.validation_graph.serialize(save_path)
+    shacl_p = filepath.parent / f"{timestamp}_shacl.ttl"
+    report.shacl_graph.serialize(shacl_p)
+    data_p = filepath.parent / f"{timestamp}_data.ttl"
+    report.data_graph.serialize(data_p)
+    msg = (
+        f"\nPlease contact the development team with the files starting with the timestamp '{timestamp}' "
+        f"in the directory '{filepath.parent}'."
+    )
+    print(BOLD_RED + msg + RESET_TO_DEFAULT)

dsp_tools/commands/validate_data/validation/check_duplicate_files.py

@@ -0,0 +1,55 @@
+from collections import defaultdict
+
+from loguru import logger
+
+from dsp_tools.commands.validate_data.models.input_problems import DuplicateFileWarning
+from dsp_tools.commands.validate_data.models.input_problems import InputProblem
+from dsp_tools.commands.validate_data.models.input_problems import ProblemType
+from dsp_tools.commands.validate_data.models.input_problems import Severity
+from dsp_tools.utils.xml_parsing.models.parsed_resource import ParsedResource
+
+
+def check_for_duplicate_files(parsed_resources: list[ParsedResource]) -> DuplicateFileWarning | None:
+    """
+    Too many duplicate filepaths in the data may cause the SHACL validator to crash.
+    If one file is referenced n times, this produces n * (n-1) validation errors.
+    Therefore, this programmatic pre-validation prevents crashes during later validation steps.
+
+    Args:
+        parsed_resources: Resources to check
+
+    Returns:
+        Results for the user and decisions how the program should continue
+    """
+    count_dict = _get_filepaths_with_more_than_one_usage(parsed_resources)
+    if not count_dict:
+        return None
+    input_problems = _create_input_problems(count_dict)
+    return DuplicateFileWarning(input_problems)
+
+
+def _get_filepaths_with_more_than_one_usage(parsed_resources: list[ParsedResource]) -> dict[str, int]:
+    count_dict: dict[str, int] = defaultdict(int)
+    for res in parsed_resources:
+        if res.file_value and res.file_value.value:
+            count_dict[res.file_value.value] += 1
+    return {f_path: count for f_path, count in count_dict.items() if count > 1}
+
+
+def _create_input_problems(duplicates: dict[str, int]) -> list[InputProblem]:
+    all_duplicates = []
+    for dup_entry, usage_count in duplicates.items():
+        msg = f"value used {usage_count} times"
+        logger.warning(f"File '{dup_entry}' {msg}")
+        all_duplicates.append(
+            InputProblem(
+                problem_type=ProblemType.FILE_DUPLICATE,
+                res_id=None,
+                res_type=None,
+                prop_name="bitstream / iiif-uri",
+                severity=Severity.WARNING,
+                message=msg,
+                input_value=dup_entry,
+            )
+        )
+    return all_duplicates

dsp_tools/commands/validate_data/validation/check_for_unknown_classes.py

@@ -0,0 +1,67 @@
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.commands.validate_data.models.input_problems import UnknownClassesInData
+from dsp_tools.commands.validate_data.models.validation import RDFGraphs
+from dsp_tools.commands.validate_data.utils import reformat_onto_iri
+from dsp_tools.utils.rdf_constants import KNORA_API_PREFIX
+
+
+def check_for_unknown_resource_classes(
+    rdf_graphs: RDFGraphs, used_resource_iris: set[str]
+) -> UnknownClassesInData | None:
+    """
+    Checks if any classes are referenced in the data that are not in the ontology.
+
+    Args:
+        rdf_graphs: Data graphs
+        used_resource_iris: resource IRIs in use
+
+    Returns:
+        Unknown classes if any
+    """
+    res_cls = _get_all_onto_classes(rdf_graphs)
+    if extra_cls := used_resource_iris - res_cls:
+        unknown_classes = {reformat_onto_iri(x) for x in extra_cls}
+        defined_classes = {reformat_onto_iri(x) for x in res_cls}
+        return UnknownClassesInData(unknown_classes=unknown_classes, defined_classes=defined_classes)
+    return None
+
+
+def _get_all_onto_classes(rdf_graphs: RDFGraphs) -> set[str]:
+    ontos = rdf_graphs.ontos + rdf_graphs.knora_api
+    is_resource_iri = URIRef(KNORA_API_PREFIX + "isResourceClass")
+    resource_classes = set(ontos.subjects(is_resource_iri, Literal(True)))
+    is_usable = URIRef(KNORA_API_PREFIX + "canBeInstantiated")
+    usable_resource_classes = set(ontos.subjects(is_usable, Literal(True)))
+    user_facing = usable_resource_classes.intersection(resource_classes)
+    return {str(x) for x in user_facing}
+
+
+def get_msg_str_unknown_classes_in_data(unknown: UnknownClassesInData) -> str:
+    if unknown_onto_msg := _get_unknown_ontos_msg(unknown):
+        return unknown_onto_msg
+    unknown_classes = sorted(list(unknown.unknown_classes))
+    known_classes = sorted(list(unknown.defined_classes))
+    return (
+        f"Your data uses resource classes that do not exist in the ontologies in the database.\n"
+        f"The following classes that are used in the data are unknown: {', '.join(unknown_classes)}\n"
+        f"The following classes exist in the uploaded ontologies: {', '.join(known_classes)}"
+    )
+
+
+def _get_unknown_ontos_msg(unknown: UnknownClassesInData) -> str | None:
+    def split_prefix(relative_iri: str) -> str | None:
+        if ":" not in relative_iri:
+            return None
+        return relative_iri.split(":")[0]
+
+    used_ontos = set(not_knora for x in unknown.unknown_classes if (not_knora := split_prefix(x)))
+    exising_ontos = set(not_knora for x in unknown.defined_classes if (not_knora := split_prefix(x)))
+    if unknown_found := used_ontos - exising_ontos:
+        return (
+            f"Your data uses ontologies that don't exist in the database.\n"
+            f"The following ontologies that are used in the data are unknown: {', '.join(unknown_found)}\n"
+            f"The following ontologies are uploaded: {', '.join(exising_ontos)}"
+        )
+    return None

dsp_tools/commands/validate_data/validation/get_validation_report.py

@@ -0,0 +1,94 @@
+from pathlib import Path
+
+from loguru import logger
+from rdflib import Graph
+
+from dsp_tools.commands.validate_data.constants import CARDINALITY_DATA_TTL
+from dsp_tools.commands.validate_data.constants import CARDINALITY_REPORT_TTL
+from dsp_tools.commands.validate_data.constants import CARDINALITY_SHACL_TTL
+from dsp_tools.commands.validate_data.constants import CONTENT_DATA_TTL
+from dsp_tools.commands.validate_data.constants import CONTENT_REPORT_TTL
+from dsp_tools.commands.validate_data.constants import CONTENT_SHACL_TTL
+from dsp_tools.commands.validate_data.models.validation import RDFGraphs
+from dsp_tools.commands.validate_data.models.validation import ValidationFilePaths
+from dsp_tools.commands.validate_data.models.validation import ValidationReportGraphs
+from dsp_tools.commands.validate_data.shacl_cli_validator import ShaclCliValidator
+from dsp_tools.commands.validate_data.utils import clean_up_temp_directory
+from dsp_tools.commands.validate_data.utils import get_temp_directory
+from dsp_tools.error.exceptions import ShaclValidationError
+
+
+def get_validation_report(
+    rdf_graphs: RDFGraphs, shacl_validator: ShaclCliValidator, graph_save_dir: Path | None = None
+) -> ValidationReportGraphs:
+    tmp_dir = get_temp_directory()
+    tmp_path = Path(tmp_dir.name)
+    dir_to_save_graphs = graph_save_dir
+    try:
+        result = _call_shacl_cli(rdf_graphs, shacl_validator, tmp_path)
+        return result
+    except Exception as e:  # noqa: BLE001
+        logger.exception(e)
+        dir_to_save_graphs = tmp_path.parent / "validation-graphs"
+        msg = (
+            f"An error occurred during the data validation. "
+            f"Please contact the dsp-tools development team (at support@dasch.swiss) "
+            f"with your log files and the files in the directory: {dir_to_save_graphs}"
+        )
+        raise ShaclValidationError(msg) from None
+    finally:
+        clean_up_temp_directory(tmp_dir, dir_to_save_graphs)
+
+
+def _call_shacl_cli(
+    rdf_graphs: RDFGraphs, shacl_validator: ShaclCliValidator, tmp_path: Path
+) -> ValidationReportGraphs:
+    _create_and_write_graphs(rdf_graphs, tmp_path)
+    results_graph = Graph()
+    conforms = True
+    card_files = ValidationFilePaths(
+        directory=tmp_path,
+        data_file=CARDINALITY_DATA_TTL,
+        shacl_file=CARDINALITY_SHACL_TTL,
+        report_file=CARDINALITY_REPORT_TTL,
+    )
+    card_result = shacl_validator.validate(card_files)
+    if not card_result.conforms:
+        results_graph += card_result.validation_graph
+        conforms = False
+    content_files = ValidationFilePaths(
+        directory=tmp_path,
+        data_file=CONTENT_DATA_TTL,
+        shacl_file=CONTENT_SHACL_TTL,
+        report_file=CONTENT_REPORT_TTL,
+    )
+    content_result = shacl_validator.validate(content_files)
+    if not content_result.conforms:
+        results_graph += content_result.validation_graph
+        conforms = False
+    return ValidationReportGraphs(
+        conforms=conforms,
+        validation_graph=results_graph,
+        shacl_graph=rdf_graphs.cardinality_shapes + rdf_graphs.content_shapes,
+        onto_graph=rdf_graphs.ontos + rdf_graphs.knora_api,
+        data_graph=rdf_graphs.data,
+    )
+
+
+def _create_and_write_graphs(rdf_graphs: RDFGraphs, tmp_path: Path) -> None:
+    logger.debug("Serialise RDF graphs into turtle strings")
+    data_str = rdf_graphs.data.serialize(format="ttl")
+    ontos_str = rdf_graphs.ontos.serialize(format="ttl")
+    card_shape_str = rdf_graphs.cardinality_shapes.serialize(format="ttl")
+    content_shape_str = rdf_graphs.content_shapes.serialize(format="ttl")
+    knora_api_str = rdf_graphs.knora_api.serialize(format="ttl")
+    res_in_db_str = rdf_graphs.resources_in_db_graph.serialize(format="ttl")
+    turtle_paths_and_graphs = [
+        (tmp_path / CARDINALITY_DATA_TTL, data_str),
+        (tmp_path / CARDINALITY_SHACL_TTL, card_shape_str + ontos_str + knora_api_str),
+        (tmp_path / CONTENT_DATA_TTL, data_str + ontos_str + knora_api_str + res_in_db_str),
+        (tmp_path / CONTENT_SHACL_TTL, content_shape_str + ontos_str + knora_api_str),
+    ]
+    for f_path, content in turtle_paths_and_graphs:
+        with open(f_path, "w") as writer:
+            writer.write(content)

dsp_tools/commands/validate_data/validation/validate_ontology.py

@@ -0,0 +1,107 @@
+import shutil
+from importlib.resources import as_file
+from importlib.resources import files
+from pathlib import Path
+
+from loguru import logger
+from rdflib import RDF
+from rdflib import SH
+from rdflib import Graph
+
+from dsp_tools.cli.args import ValidateDataConfig
+from dsp_tools.commands.validate_data.constants import ONTOLOGIES_DATA_TTL
+from dsp_tools.commands.validate_data.constants import ONTOLOGIES_REPORT_TTL
+from dsp_tools.commands.validate_data.constants import ONTOLOGIES_SHACL_TTL
+from dsp_tools.commands.validate_data.models.input_problems import OntologyResourceProblem
+from dsp_tools.commands.validate_data.models.input_problems import OntologyValidationProblem
+from dsp_tools.commands.validate_data.models.validation import ValidationFilePaths
+from dsp_tools.commands.validate_data.shacl_cli_validator import ShaclCliValidator
+from dsp_tools.commands.validate_data.utils import clean_up_temp_directory
+from dsp_tools.commands.validate_data.utils import get_temp_directory
+from dsp_tools.commands.validate_data.utils import reformat_onto_iri
+from dsp_tools.error.exceptions import ShaclValidationError
+from dsp_tools.utils.rdf_constants import SubjectObjectTypeAlias
+
+LIST_SEPARATOR = "\n    - "
+
+
+def validate_ontology(
+    onto_graph: Graph, shacl_validator: ShaclCliValidator, config: ValidateDataConfig
+) -> OntologyValidationProblem | None:
+    """
+    The API accepts erroneous cardinalities in the ontology.
+    To distinguish a mistake in the data from the erroneous ontology, the ontology will be validated beforehand.
+    This way, we do not have to take an erroneous ontology into account when validating the data.
+
+    Args:
+        onto_graph: the graph of the project ontologies
+        shacl_validator: SHACL CLI validator
+        config: The configuration where to save the information to
+
+    Returns:
+        A validation report if errors were found
+    """
+    tmp_dir = get_temp_directory()
+    tmp_path = Path(tmp_dir.name)
+    save_graph_dir = config.save_graph_dir
+    try:
+        result = _get_ontology_validation_result(onto_graph, shacl_validator, tmp_path)
+        return result
+    except Exception as e:  # noqa: BLE001
+        logger.exception(e)
+        save_graph_dir = tmp_path.parent / "validation-graphs"
+        msg = (
+            f"An error occurred during the ontology validation. "
+            f"Please contact the dsp-tools development team (at support@dasch.swiss) "
+            f"with your log files and the files in the directory: {save_graph_dir}"
+        )
+        raise ShaclValidationError(msg) from None
+    finally:
+        clean_up_temp_directory(tmp_dir, save_graph_dir)
+
+
+def _get_ontology_validation_result(
+    onto_graph: Graph, shacl_validator: ShaclCliValidator, tmp_path: Path
+) -> OntologyValidationProblem | None:
+    with as_file(files("dsp_tools").joinpath("resources/validate_data/validate-ontology.ttl")) as shacl_file_path:
+        shacl_file = Path(shacl_file_path)
+        shutil.copy(shacl_file, tmp_path / ONTOLOGIES_SHACL_TTL)
+    onto_graph.serialize(tmp_path / ONTOLOGIES_DATA_TTL)
+    paths = ValidationFilePaths(
+        directory=tmp_path,
+        data_file=ONTOLOGIES_DATA_TTL,
+        shacl_file=ONTOLOGIES_SHACL_TTL,
+        report_file=ONTOLOGIES_REPORT_TTL,
+    )
+    validation_result = shacl_validator.validate(paths)
+    if validation_result.conforms:
+        return None
+    return OntologyValidationProblem(_reformat_ontology_validation_result(validation_result.validation_graph))
+
+
+def _reformat_ontology_validation_result(validation_result: Graph) -> list[OntologyResourceProblem]:
+    bns = validation_result.subjects(RDF.type, SH.ValidationResult)
+    return [_get_one_problem(validation_result, bn) for bn in bns]
+
+
+def _get_one_problem(val_g: Graph, result_bn: SubjectObjectTypeAlias) -> OntologyResourceProblem:
+    iri = next(val_g.objects(result_bn, SH.focusNode))
+    iri_str = reformat_onto_iri(iri)
+    msg = str(next(val_g.objects(result_bn, SH.resultMessage)))
+    splt = [x.strip() for x in msg.split("\n")]
+    return OntologyResourceProblem(iri_str, " ".join(splt))
+
+
+def get_msg_str_ontology_validation_violation(onto_violations: OntologyValidationProblem) -> str:
+    probs = sorted(onto_violations.problems, key=lambda x: x.res_iri)
+
+    def get_resource_msg(res: OntologyResourceProblem) -> str:
+        return f"Resource Class: {res.res_iri} | Problem: {res.msg}"
+
+    problems = [get_resource_msg(x) for x in probs]
+    return (
+        "The ontology structure contains errors that prevent the validation of the data.\n"
+        "Please correct the following errors and re-upload the corrected ontology.\n"
+        f"Once those two steps are done, the command `validate-data` will find any problems in the data.\n"
+        f"{LIST_SEPARATOR}{LIST_SEPARATOR.join(problems)}"
+    )