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

dsp_tools/commands/validate_data/prepare_data/get_rdf_like_data.py

@@ -0,0 +1,296 @@
+import json
+from json import JSONDecodeError
+from typing import Any
+from typing import cast
+
+import regex
+from lxml import etree
+
+from dsp_tools.commands.validate_data.mappers import FILE_TYPE_TO_PROP
+from dsp_tools.commands.validate_data.models.api_responses import ListLookup
+from dsp_tools.commands.validate_data.models.rdf_like_data import MigrationMetadata
+from dsp_tools.commands.validate_data.models.rdf_like_data import PropertyObject
+from dsp_tools.commands.validate_data.models.rdf_like_data import RdfLikeData
+from dsp_tools.commands.validate_data.models.rdf_like_data import RdfLikeResource
+from dsp_tools.commands.validate_data.models.rdf_like_data import RdfLikeValue
+from dsp_tools.commands.validate_data.models.rdf_like_data import TripleObjectType
+from dsp_tools.commands.validate_data.models.rdf_like_data import TriplePropertyType
+from dsp_tools.utils.data_formats.date_util import Era
+from dsp_tools.utils.data_formats.date_util import SingleDate
+from dsp_tools.utils.data_formats.date_util import parse_date_string
+from dsp_tools.utils.xml_parsing.models.parsed_resource import KnoraValueType
+from dsp_tools.utils.xml_parsing.models.parsed_resource import ParsedFileValue
+from dsp_tools.utils.xml_parsing.models.parsed_resource import ParsedFileValueMetadata
+from dsp_tools.utils.xml_parsing.models.parsed_resource import ParsedResource
+from dsp_tools.utils.xml_parsing.models.parsed_resource import ParsedValue
+
+
+def get_rdf_like_data(
+    resources: list[ParsedResource], authorship_lookup: dict[str, list[str]], list_node_lookup: ListLookup
+) -> RdfLikeData:
+    rdf_like_resources = [_get_one_resource(x, authorship_lookup, list_node_lookup) for x in resources]
+    return RdfLikeData(rdf_like_resources)
+
+
+def _get_one_resource(
+    resource: ParsedResource, authorship_lookup: dict[str, list[str]], list_node_lookup: ListLookup
+) -> RdfLikeResource:
+    values = [_get_one_value(x, list_node_lookup) for x in resource.values]
+    if resource.file_value:
+        if file_val := _get_file_value(resource.file_value, authorship_lookup):
+            values.append(file_val)
+    metadata = [
+        PropertyObject(TriplePropertyType.RDFS_LABEL, resource.label, TripleObjectType.STRING),
+        PropertyObject(TriplePropertyType.RDF_TYPE, resource.res_type, TripleObjectType.IRI),
+    ]
+    metadata.extend(_get_all_stand_off_links(resource.values))
+    if resource.permissions_id is not None:
+        metadata.append(
+            PropertyObject(TriplePropertyType.KNORA_PERMISSIONS, resource.permissions_id, TripleObjectType.STRING)
+        )
+    return RdfLikeResource(
+        res_id=resource.res_id,
+        property_objects=metadata,
+        values=values,
+        migration_metadata=MigrationMetadata(),
+    )
+
+
+def _get_all_stand_off_links(values: list[ParsedValue]) -> list[PropertyObject]:
+    stand_off_ids = set()
+    for val in values:
+        if val.value_type == KnoraValueType.RICHTEXT_VALUE:
+            if isinstance(val.value, str):
+                new_ids = _get_resource_ids_and_iri_strings(val.value)
+                stand_off_ids.update(new_ids)
+    return [_get_stand_off_links(x) for x in stand_off_ids]
+
+
+def _get_resource_ids_and_iri_strings(text: str) -> set[str]:
+    txt_wrapped = f"<wrapper>{text}</wrapper>"
+    text_tree = etree.fromstring(txt_wrapped)
+    all_hrefs = set()
+    for a_link in text_tree.iterdescendants(tag="a"):
+        if a_link.get("class") == "salsah-link":
+            if found := a_link.get("href"):
+                all_hrefs.add(found)
+    return all_hrefs
+
+
+def _get_stand_off_links(extracted: str) -> PropertyObject:
+    link, obj_type = _get_link_string_and_triple_object_type(extracted)
+    return PropertyObject(TriplePropertyType.KNORA_STANDOFF_LINK, link, obj_type)
+
+
+def _get_link_string_and_triple_object_type(res_link: str) -> tuple[str, TripleObjectType]:
+    if found := regex.search(r"IRI:(.*?):IRI", res_link):
+        return found.group(1), TripleObjectType.INTERNAL_ID
+    if res_link.startswith("http://rdfh.ch/"):
+        return res_link, TripleObjectType.IRI
+    # if it is not a valid IRI, rdflib may crash when trying to turn it into one
+    # the TripleObjectType.INTERNAL_ID only expects a string and is therefore able to deal with malformed content
+    return res_link, TripleObjectType.INTERNAL_ID
+
+
+def _get_one_value(value: ParsedValue, list_node_lookup: ListLookup) -> RdfLikeValue:
+    user_value = value.value
+    match value.value_type:
+        case KnoraValueType.DATE_VALUE:
+            return _get_date_value(value)
+        case KnoraValueType.INTERVAL_VALUE:
+            return _get_interval_value(value)
+        case KnoraValueType.LIST_VALUE:
+            user_value = _get_list_value_str(user_value, list_node_lookup)
+        case KnoraValueType.GEOM_VALUE:
+            user_value = _get_geometry_value_str(user_value)
+        case _:
+            pass
+    typed_val: str | None = user_value if isinstance(user_value, str) else None
+    return _get_generic_value(value, typed_val)
+
+
+def _get_generic_value(value: ParsedValue, user_value: str | None) -> RdfLikeValue:
+    return RdfLikeValue(
+        user_facing_prop=value.prop_name,
+        user_facing_value=user_value,
+        knora_type=value.value_type,
+        value_metadata=_get_value_metadata(value),
+    )
+
+
+def _get_date_value(value: ParsedValue) -> RdfLikeValue:
+    typed_val: str | None = value.value if isinstance(value.value, str) else None
+    date_metadata = _get_value_metadata(value)
+    if typed_val:
+        date_metadata.extend(_get_xsd_like_dates(typed_val))
+    return RdfLikeValue(
+        user_facing_prop=value.prop_name,
+        user_facing_value=typed_val,
+        knora_type=value.value_type,
+        value_metadata=date_metadata,
+    )
+
+
+def _get_xsd_like_dates(date_string: str) -> list[PropertyObject]:
+    parsed_date = parse_date_string(date_string)
+    dates = []
+    if not (ce_start := _make_xsd_compatible_date(parsed_date.start, TriplePropertyType.KNORA_DATE_START)):
+        return []
+    dates.append(ce_start)
+    if parsed_date.end:
+        if ce_end := _make_xsd_compatible_date(parsed_date.end, TriplePropertyType.KNORA_DATE_END):
+            dates.append(ce_end)
+    return dates
+
+
+def _make_xsd_compatible_date(single_date: SingleDate, prop_type: TriplePropertyType) -> PropertyObject | None:
+    if single_date.era in (Era.BC, Era.BCE):
+        return None
+    date_str = _get_date_str(single_date)
+    return PropertyObject(
+        property_type=prop_type,
+        object_value=date_str,
+        object_type=TripleObjectType.DATE_YYYY_MM_DD,
+    )
+
+
+def _get_date_str(date: SingleDate) -> str:
+    # SHACL cannot compare dates of varying precision, therefore we turn partial dates into full dates
+    date_str = [str(date.year).zfill(4)]
+    if date.month:
+        date_str.append(str(date.month).zfill(2))
+    else:
+        date_str.append("01")
+    if date.day:
+        date_str.append(str(date.day).zfill(2))
+    else:
+        date_str.append("01")
+    return "-".join(date_str)
+
+
+def _get_interval_value(value: ParsedValue) -> RdfLikeValue:
+    property_objects = []
+    tuple_val = value.value
+    if isinstance(tuple_val, tuple):
+        if first := tuple_val[0]:
+            property_objects.append(
+                PropertyObject(
+                    property_type=TriplePropertyType.KNORA_INTERVAL_START,
+                    object_value=first,
+                    object_type=TripleObjectType.DECIMAL,
+                )
+            )
+        if second := tuple_val[1]:
+            property_objects.append(
+                PropertyObject(
+                    property_type=TriplePropertyType.KNORA_INTERVAL_END,
+                    object_value=second,
+                    object_type=TripleObjectType.DECIMAL,
+                )
+            )
+    property_objects.extend(_get_value_metadata(value))
+    return RdfLikeValue(
+        user_facing_prop=value.prop_name,
+        user_facing_value=None,
+        knora_type=value.value_type,
+        value_metadata=property_objects,
+    )
+
+
+def _get_list_value_str(user_value: str | tuple[str | None, str | None] | None, list_node_lookup: ListLookup) -> str:
+    in_tuple = cast(tuple[Any, Any], user_value)
+    if found := list_node_lookup.lists.get(in_tuple):
+        return found
+    return " / ".join(x for x in in_tuple if x is not None)
+
+
+def _get_geometry_value_str(user_value: str | tuple[str | None, str | None] | None) -> str | None:
+    try:
+        if isinstance(user_value, str):
+            return json.dumps(json.loads(user_value))
+        return None
+    except JSONDecodeError:
+        return None
+
+
+def _get_value_metadata(value: ParsedValue) -> list[PropertyObject]:
+    metadata = []
+    if value.permissions_id is not None:
+        metadata.append(
+            PropertyObject(
+                property_type=TriplePropertyType.KNORA_PERMISSIONS,
+                object_value=value.permissions_id,
+                object_type=TripleObjectType.STRING,
+            )
+        )
+    if value.comment is not None:
+        metadata.append(
+            PropertyObject(
+                property_type=TriplePropertyType.KNORA_COMMENT_ON_VALUE,
+                object_value=value.comment,
+                object_type=TripleObjectType.STRING,
+            )
+        )
+    return metadata
+
+
+def _get_file_value(file_value: ParsedFileValue, authorship_lookup: dict[str, list[str]]) -> RdfLikeValue | None:
+    if not all([file_value.value, file_value.value_type]):
+        return None
+    file_type = cast(KnoraValueType, file_value.value_type)
+    user_prop = FILE_TYPE_TO_PROP[file_type]
+    return RdfLikeValue(
+        user_facing_prop=user_prop,
+        user_facing_value=file_value.value,
+        knora_type=file_type,
+        value_metadata=_get_file_metadata(file_value.metadata, authorship_lookup),
+    )
+
+
+def _get_file_metadata(
+    metadata: ParsedFileValueMetadata, authorship_lookup: dict[str, list[str]]
+) -> list[PropertyObject]:
+    property_objects = []
+    if metadata.license_iri is not None:
+        property_objects.append(
+            PropertyObject(
+                property_type=TriplePropertyType.KNORA_LICENSE,
+                object_value=metadata.license_iri,
+                object_type=TripleObjectType.IRI,
+            )
+        )
+    if metadata.copyright_holder is not None:
+        property_objects.append(
+            PropertyObject(
+                property_type=TriplePropertyType.KNORA_COPYRIGHT_HOLDER,
+                object_value=metadata.copyright_holder,
+                object_type=TripleObjectType.STRING,
+            )
+        )
+    if metadata.authorship_id is not None:
+        if not (found_authors := authorship_lookup.get(metadata.authorship_id)):
+            property_objects.append(
+                PropertyObject(
+                    property_type=TriplePropertyType.KNORA_AUTHORSHIP,
+                    object_value="",
+                    object_type=TripleObjectType.STRING,
+                )
+            )
+        else:
+            for auth in found_authors:
+                property_objects.append(
+                    PropertyObject(
+                        property_type=TriplePropertyType.KNORA_AUTHORSHIP,
+                        object_value=auth,
+                        object_type=TripleObjectType.STRING,
+                    )
+                )
+    if metadata.permissions_id is not None:
+        property_objects.append(
+            PropertyObject(
+                property_type=TriplePropertyType.KNORA_PERMISSIONS,
+                object_value=metadata.permissions_id,
+                object_type=TripleObjectType.STRING,
+            )
+        )
+    return property_objects

dsp_tools/commands/validate_data/prepare_data/make_data_graph.py

@@ -0,0 +1,91 @@
+from loguru import logger
+from rdflib import RDF
+from rdflib import XSD
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+from rdflib.xsd_datetime import parse_xsd_date
+
+from dsp_tools.commands.validate_data.mappers import TRIPLE_OBJECT_TYPE_TO_XSD
+from dsp_tools.commands.validate_data.mappers import TRIPLE_PROP_TYPE_TO_IRI_MAPPER
+from dsp_tools.commands.validate_data.mappers import VALUE_INFO_TO_RDF_MAPPER
+from dsp_tools.commands.validate_data.mappers import VALUE_INFO_TRIPLE_OBJECT_TYPE
+from dsp_tools.commands.validate_data.models.rdf_like_data import PropertyObject
+from dsp_tools.commands.validate_data.models.rdf_like_data import RdfLikeData
+from dsp_tools.commands.validate_data.models.rdf_like_data import RdfLikeResource
+from dsp_tools.commands.validate_data.models.rdf_like_data import RdfLikeValue
+from dsp_tools.commands.validate_data.models.rdf_like_data import TripleObjectType
+from dsp_tools.commands.validate_data.models.rdf_like_data import TriplePropertyType
+from dsp_tools.utils.rdf_constants import DATA
+from dsp_tools.utils.xml_parsing.models.parsed_resource import KnoraValueType
+
+
+def make_data_graph(data: RdfLikeData) -> Graph:
+    logger.debug("Creating the RDF data graph.")
+    g = Graph()
+    for r in data.resources:
+        g += _make_one_resource(r)
+    return g
+
+
+def _make_one_resource(res: RdfLikeResource) -> Graph:
+    res_iri = DATA[res.res_id]
+    g = _make_property_objects_graph(res.property_objects, res_iri)
+    for v in res.values:
+        g += _make_one_value(v, res_iri)
+    return g
+
+
+def _make_one_value(val: RdfLikeValue, res_iri: URIRef) -> Graph:
+    prop_type_info = VALUE_INFO_TO_RDF_MAPPER[val.knora_type]
+
+    val_iri = DATA[val.value_uuid]
+    g = _make_property_objects_graph(val.value_metadata, val_iri)
+    g.add((res_iri, URIRef(val.user_facing_prop), val_iri))
+    g.add((val_iri, RDF.type, prop_type_info.knora_type))
+    # The interval values are added in the property objects graph
+    if val.knora_type == KnoraValueType.INTERVAL_VALUE:
+        return g
+    if val.knora_type == KnoraValueType.LINK_VALUE:
+        link_val = val.user_facing_value if val.user_facing_value else ""
+        if link_val.startswith("http://rdfh.ch/"):
+            triple_object: Literal | URIRef = URIRef(link_val)
+        else:
+            triple_object = DATA[link_val]
+    else:
+        triple_object = _make_one_rdflib_object(val.user_facing_value, VALUE_INFO_TRIPLE_OBJECT_TYPE[val.knora_type])
+    g.add((val_iri, prop_type_info.knora_prop, triple_object))
+    return g
+
+
+def _make_property_objects_graph(property_objects: list[PropertyObject], subject_iri: URIRef) -> Graph:
+    g = Graph()
+    for trpl in property_objects:
+        object_val = _make_one_rdflib_object(trpl.object_value, trpl.object_type, trpl.property_type)
+        g.add((subject_iri, TRIPLE_PROP_TYPE_TO_IRI_MAPPER[trpl.property_type], object_val))
+    return g
+
+
+def _make_one_rdflib_object(
+    object_value: str | None, object_type: TripleObjectType, prop_type: TriplePropertyType | None = None
+) -> Literal | URIRef:
+    if not object_value:
+        return Literal("", datatype=XSD.string)
+    if object_type == TripleObjectType.IRI:
+        return URIRef(object_value)
+    if object_type == TripleObjectType.INTERNAL_ID:
+        return DATA[object_value]
+    if prop_type in (TriplePropertyType.KNORA_DATE_START, TriplePropertyType.KNORA_DATE_END):
+        return _process_date_string(object_value, object_type)
+    return Literal(object_value, datatype=TRIPLE_OBJECT_TYPE_TO_XSD[object_type])
+
+
+def _process_date_string(object_value: str, object_type: TripleObjectType) -> Literal:
+    # In case a date is not a valid xsd datatype, rdflib only raises the error when serialising the graph
+    # not during the construction of the literal.
+    # Therefore, we test the validity beforehand with the rdflib native functions.
+    try:
+        parse_xsd_date(object_value)
+        return Literal(object_value, datatype=TRIPLE_OBJECT_TYPE_TO_XSD[object_type])
+    except ValueError:
+        return Literal(object_value, datatype=XSD.string)

dsp_tools/commands/validate_data/prepare_data/prepare_data.py

@@ -0,0 +1,184 @@
+import importlib.resources
+from pathlib import Path
+
+from loguru import logger
+from rdflib import RDF
+from rdflib import Graph
+from rdflib import URIRef
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.legal_info_client_live import LegalInfoClientLive
+from dsp_tools.clients.list_client import OneList
+from dsp_tools.clients.list_client_live import ListGetClientLive
+from dsp_tools.clients.metadata_client import ExistingResourcesRetrieved
+from dsp_tools.clients.metadata_client_live import MetadataClientLive
+from dsp_tools.clients.ontology_clients import OntologyGetClient
+from dsp_tools.clients.ontology_get_client_live import OntologyGetClientLive
+from dsp_tools.commands.validate_data.models.api_responses import EnabledLicenseIris
+from dsp_tools.commands.validate_data.models.api_responses import InfoForResourceInDB
+from dsp_tools.commands.validate_data.models.api_responses import ListLookup
+from dsp_tools.commands.validate_data.models.api_responses import ProjectDataFromApi
+from dsp_tools.commands.validate_data.models.validation import RDFGraphs
+from dsp_tools.commands.validate_data.prepare_data.get_rdf_like_data import get_rdf_like_data
+from dsp_tools.commands.validate_data.prepare_data.make_data_graph import make_data_graph
+from dsp_tools.commands.validate_data.sparql.construct_shacl import construct_shapes_graphs
+from dsp_tools.utils.rdf_constants import API_SHAPES_PREFIX
+from dsp_tools.utils.rdf_constants import DASH_PREFIX
+from dsp_tools.utils.rdf_constants import KNORA_API_PREFIX
+from dsp_tools.utils.rdf_constants import SALSAH_GUI_PREFIX
+from dsp_tools.utils.replace_id_with_iri import use_id2iri_mapping_to_replace_ids
+from dsp_tools.utils.xml_parsing.get_lookups import get_authorship_lookup
+from dsp_tools.utils.xml_parsing.get_parsed_resources import get_parsed_resources
+from dsp_tools.utils.xml_parsing.models.parsed_resource import ParsedResource
+from dsp_tools.utils.xml_parsing.parse_clean_validate_xml import parse_and_clean_xml_file
+
+
+def get_info_and_parsed_resources_from_file(
+    file: Path, api_url: str, id2iri_file: str | None
+) -> tuple[list[ParsedResource], str, dict[str, list[str]], list[str]]:
+    root = parse_and_clean_xml_file(file)
+    shortcode = root.attrib["shortcode"]
+    authorship_lookup = get_authorship_lookup(root)
+    permission_ids = [perm.attrib["id"] for perm in root.findall("permissions")]
+    parsed_resources = get_parsed_resources(root, api_url)
+    if id2iri_file:
+        parsed_resources = use_id2iri_mapping_to_replace_ids(parsed_resources, Path(id2iri_file))
+    return parsed_resources, shortcode, authorship_lookup, permission_ids
+
+
+def prepare_data_for_validation_from_parsed_resource(
+    parsed_resources: list[ParsedResource],
+    authorship_lookup: dict[str, list[str]],
+    permission_ids: list[str],
+    auth: AuthenticationClient,
+    shortcode: str,
+    do_not_request_resource_metadata_from_db: bool,
+) -> tuple[RDFGraphs, set[str], ExistingResourcesRetrieved]:
+    used_iris = {x.res_type for x in parsed_resources}
+    proj_info, existing_resources_retrieved = _get_project_specific_information_from_api(
+        auth, shortcode, do_not_request_resource_metadata_from_db
+    )
+    list_lookup = _make_list_lookup(proj_info.all_lists)
+    data_rdf = _make_data_graph_from_parsed_resources(parsed_resources, authorship_lookup, list_lookup)
+    rdf_graphs = _create_graphs(data_rdf, shortcode, auth, proj_info, permission_ids)
+    return rdf_graphs, used_iris, existing_resources_retrieved
+
+
+def _make_list_lookup(project_lists: list[OneList]) -> ListLookup:
+    lookup = {}
+    for li in project_lists:
+        for nd in li.nodes:
+            lookup[(li.list_name, nd.name)] = nd.iri
+            lookup[("", nd.iri)] = nd.iri
+    return ListLookup(lookup)
+
+
+def _get_project_specific_information_from_api(
+    auth: AuthenticationClient, shortcode: str, do_not_request_resource_metadata_from_db: bool
+) -> tuple[ProjectDataFromApi, ExistingResourcesRetrieved]:
+    list_client = ListGetClientLive(auth.server, shortcode)
+    all_lists = list_client.get_all_lists_and_nodes()
+    enabled_licenses = _get_license_iris(shortcode, auth)
+    if do_not_request_resource_metadata_from_db:
+        existing_resources_retrieved = ExistingResourcesRetrieved.FALSE
+        formatted_metadata: list[InfoForResourceInDB] = []
+    else:
+        existing_resources_retrieved, formatted_metadata = _get_metadata_info(auth, shortcode)
+    return ProjectDataFromApi(all_lists, enabled_licenses, formatted_metadata), existing_resources_retrieved
+
+
+def _get_metadata_info(
+    auth: AuthenticationClient, shortcode: str
+) -> tuple[ExistingResourcesRetrieved, list[InfoForResourceInDB]]:
+    metadata_client = MetadataClientLive(auth.server, auth)
+    retrieval_status, metadata = metadata_client.get_resource_metadata(shortcode)
+    formatted_metadata = [InfoForResourceInDB(x["resourceIri"], x["resourceClassIri"]) for x in metadata]
+    return retrieval_status, formatted_metadata
+
+
+def _make_data_graph_from_parsed_resources(
+    parsed_resources: list[ParsedResource], authorship_lookup: dict[str, list[str]], list_lookup: ListLookup
+) -> Graph:
+    rdf_like_data = get_rdf_like_data(parsed_resources, authorship_lookup, list_lookup)
+    rdf_data = make_data_graph(rdf_like_data)
+    return rdf_data
+
+
+def _create_graphs(
+    data_rdf: Graph,
+    shortcode: str,
+    auth: AuthenticationClient,
+    proj_info: ProjectDataFromApi,
+    permission_ids: list[str],
+) -> RDFGraphs:
+    logger.debug("Create all graphs.")
+    onto_client = OntologyGetClientLive(auth.server, shortcode)
+    ontologies, onto_iris = _get_project_ontos(onto_client)
+    knora_ttl = onto_client.get_knora_api()
+    knora_api = Graph()
+    knora_api.parse(data=knora_ttl, format="ttl")
+    shapes = construct_shapes_graphs(ontologies, knora_api, proj_info, permission_ids)
+    api_shapes = Graph()
+    api_shapes_path = importlib.resources.files("dsp_tools").joinpath("resources/validate_data/api-shapes.ttl")
+    api_shapes.parse(str(api_shapes_path))
+    api_card_shapes = Graph()
+    api_card_path = importlib.resources.files("dsp_tools").joinpath(
+        "resources/validate_data/api-shapes-resource-cardinalities.ttl"
+    )
+    api_card_shapes.parse(str(api_card_path))
+    content_shapes = shapes.content + api_shapes
+    card_shapes = shapes.cardinality + api_card_shapes
+    resources_in_db = _make_resource_in_db_graph(proj_info.resource_iris_in_db)
+    resources_in_db = _bind_prefixes_to_graph(resources_in_db, onto_iris)
+    data_rdf = _bind_prefixes_to_graph(data_rdf, onto_iris)
+    ontologies = _bind_prefixes_to_graph(ontologies, onto_iris)
+    card_shapes = _bind_prefixes_to_graph(card_shapes, onto_iris)
+    content_shapes = _bind_prefixes_to_graph(content_shapes, onto_iris)
+    knora_api = _bind_prefixes_to_graph(knora_api, onto_iris)
+    return RDFGraphs(
+        data=data_rdf,
+        ontos=ontologies,
+        cardinality_shapes=card_shapes,
+        content_shapes=content_shapes,
+        knora_api=knora_api,
+        resources_in_db_graph=resources_in_db,
+    )
+
+
+def _bind_prefixes_to_graph(g: Graph, project_ontos: list[str]) -> Graph:
+    def get_one_prefix(ontology_iri: str) -> str:
+        iri_split = ontology_iri.split("/")
+        return iri_split[-2]
+
+    g.bind("knora-api", KNORA_API_PREFIX)
+    g.bind("api-shapes", API_SHAPES_PREFIX)
+    g.bind("dash", DASH_PREFIX)
+    g.bind("salsah-gui", SALSAH_GUI_PREFIX)
+    for iri in project_ontos:
+        g.bind(get_one_prefix(iri), f"{iri}#")
+    return g
+
+
+def _get_project_ontos(onto_client: OntologyGetClient) -> tuple[Graph, list[str]]:
+    logger.debug("Get project ontologies from server.")
+    all_ontos, onto_iris = onto_client.get_ontologies()
+    onto_g = Graph()
+    for onto in all_ontos:
+        og = Graph()
+        og.parse(data=onto, format="ttl")
+        onto_g += og
+    return onto_g, onto_iris
+
+
+def _get_license_iris(shortcode: str, auth: AuthenticationClient) -> EnabledLicenseIris:
+    legal_client = LegalInfoClientLive(auth.server, shortcode, auth)
+    license_info = legal_client.get_licenses_of_a_project()
+    iris = [x["id"] for x in license_info]
+    return EnabledLicenseIris(iris)
+
+
+def _make_resource_in_db_graph(resources_in_db: list[InfoForResourceInDB]) -> Graph:
+    g = Graph()
+    for r in resources_in_db:
+        g.add((URIRef(r.res_iri), RDF.type, URIRef(r.res_type)))
+    return g