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

dsp_tools/resources/validate_data/shacl-cli-image.yml

@@ -0,0 +1,4 @@
+---
+# Take the latest release from:
+# https://github.com/dasch-swiss/shacl-cli/releases
+image: "daschswiss/shacl-cli:v0.0.5"

dsp_tools/resources/validate_data/validate-ontology.ttl

@@ -0,0 +1,99 @@
+@prefix sh:         <http://www.w3.org/ns/shacl#> .
+@prefix rdfs:       <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix xsd:        <http://www.w3.org/2001/XMLSchema#> .
+@prefix owl:        <http://www.w3.org/2002/07/owl#> .
+@prefix knora-api:  <http://api.knora.org/ontology/knora-api/v2#> .
+
+@prefix api-shapes: <http://api.knora.org/ontology/knora-api/shapes/v2#> .
+
+
+api-shapes:FindMissingMaxCardinality_Seqnum_OntologyShape
+  a              sh:NodeShape ;
+  sh:targetClass owl:Class ;
+  sh:sparql      [
+                   a          sh:SPARQLConstraint ;
+                   sh:select  """
+                    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+                    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+                    PREFIX knora-api: <http://api.knora.org/ontology/knora-api/v2#>
+
+                    SELECT $this ?path WHERE {
+                        $this a owl:Class ;
+                              rdfs:subClassOf ?restriction .
+                        ?restriction a owl:Restriction ;
+                                     owl:onProperty ?path .
+
+                        ?path rdfs:subPropertyOf* knora-api:seqnum .
+
+                        FILTER NOT EXISTS {
+                            ?restriction owl:maxCardinality|owl:cardinality 1
+                        }
+                    }
+                    """ ;
+                   sh:message "seqnum must either have cardinality 1 or 0-1."
+                 ] ;
+  sh:severity    sh:Violation .
+
+
+api-shapes:FindMissingSeqnum_OntologyShape
+  a              sh:NodeShape ;
+  sh:targetClass owl:Class ;
+  sh:sparql      [
+                   a          sh:SPARQLConstraint ;
+                   sh:select  """
+                    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+                    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+                    PREFIX knora-api: <http://api.knora.org/ontology/knora-api/v2#>
+
+                    SELECT $this ?path WHERE {
+
+                        $this a owl:Class ;
+                              rdfs:subClassOf ?restrictionIsPartOf .
+                        ?restrictionIsPartOf a owl:Restriction ;
+                                             owl:onProperty ?path .
+                        ?path rdfs:subPropertyOf* knora-api:isPartOf .
+
+                        FILTER NOT EXISTS {
+                            $this a owl:Class ;
+                                  rdfs:subClassOf ?restrictionSeqnum .
+                            ?restrictionSeqnum a owl:Restriction ;
+                                               owl:onProperty ?seqnumProp .
+                            ?seqnumProp rdfs:subPropertyOf* knora-api:seqnum .
+                        }
+                    }
+                    """ ;
+                   sh:message "A class with a cardinality for isPartOf also requires a cardinality for seqnum."
+                 ] ;
+  sh:severity    sh:Violation .
+
+
+api-shapes:FindMissingIsPartOf_OntologyShape
+  a              sh:NodeShape ;
+  sh:targetClass owl:Class ;
+  sh:sparql      [
+                   a          sh:SPARQLConstraint ;
+                   sh:select  """
+                    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+                    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+                    PREFIX knora-api: <http://api.knora.org/ontology/knora-api/v2#>
+
+                    SELECT $this ?path WHERE {
+
+                        $this a owl:Class ;
+                              rdfs:subClassOf ?restrictionSeqnum .
+                        ?restrictionSeqnum a owl:Restriction ;
+                                           owl:onProperty ?path .
+                        ?path rdfs:subPropertyOf* knora-api:seqnum .
+
+                        FILTER NOT EXISTS {
+                            $this a owl:Class ;
+                                  rdfs:subClassOf ?restrictionIsPartOf .
+                            ?restrictionIsPartOf a owl:Restriction ;
+                                                 owl:onProperty ?isPartOfProp .
+                            ?isPartOfProp rdfs:subPropertyOf* knora-api:isPartOf .
+                        }
+                    }
+                    """ ;
+                   sh:message "A class with a cardinality for seqnum also requires a cardinality for isPartOf."
+                 ] ;
+  sh:severity    sh:Violation .

dsp_tools/utils/ansi_colors.py

@@ -0,0 +1,32 @@
+# These are ANSI escape codes which can be used to configure the print output on the terminal
+# http://www.lihaoyi.com/post/BuildyourownCommandLinewithANSIescapecodes.html
+# The semicolon separates different configurations
+
+# All codes must start with an escape sequence, it may differ in different languages, in Python "\u001b[" works
+SEQUENCE_START = "\u001b["
+
+# the "m" at the end signals,
+# that the configuration code is finished and after that the string that should be printed starts
+SEQUENCE_END = "m"
+
+# reset to the default setting of the console
+RESET_TO_DEFAULT = f"{SEQUENCE_START}0{SEQUENCE_END}"
+
+BOLD = f"{SEQUENCE_START}1{SEQUENCE_END}"  # 1 (bold) ; 32 (green)
+
+# If you want to change for example both the text color and the background color you can combine the sequences
+# for example: BACKGROUND_BOLD_MAGENTA + YELLOW -> magenta background with yellow text
+
+# Colored Text
+BOLD_GREEN = f"{SEQUENCE_START}1;32{SEQUENCE_END}"  # 1 (bold) ; 32 (green)
+BOLD_RED = f"{SEQUENCE_START}1;31{SEQUENCE_END}"  # 1 (bold) ; 31 (red)
+BOLD_CYAN = f"{SEQUENCE_START}1;36{SEQUENCE_END}"  # 1 (bold) ; 36 (cyan)
+BOLD_YELLOW = f"{SEQUENCE_START}1;33{SEQUENCE_END}"  # 1 (bold) ; 33 (yellow)
+YELLOW = f"{SEQUENCE_START}0;33{SEQUENCE_END}"  # 0 (normal font) ; 33 (yellow)
+RED = f"{SEQUENCE_START}0;31{SEQUENCE_END}"  # 0 (normal font) ; 31 (red)
+
+# Colored Background
+BACKGROUND_BOLD_RED = f"{SEQUENCE_START}1;41{SEQUENCE_END}"  # 1 (bold) ; 41 (background red)
+BACKGROUND_BOLD_YELLOW = f"{SEQUENCE_START}1;43{SEQUENCE_END}"  # 1 (bold) ; 43 (background yellow)
+BACKGROUND_BOLD_GREEN = f"{SEQUENCE_START}1;42{SEQUENCE_END}"  # 1 (bold) ; 42 (background green)
+BACKGROUND_BOLD_CYAN = f"{SEQUENCE_START}1;46{SEQUENCE_END}"  # 1 (bold) ; 46 (background cyan)

dsp_tools/utils/data_formats/date_util.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import cast
+
+import regex
+
+from dsp_tools.error.exceptions import BaseError
+
+_calendar = r"GREGORIAN|JULIAN|ISLAMIC"
+_era = r"CE|BCE|BC|AD"
+_year = r"\d{1,4}"
+_month = r"\d{1,2}"
+_day = r"\d{1,2}"
+_full_date_pattern = rf"""
+^
+(?:({_calendar}):)?                         # optional calendar
+(?:({_era}):)?                              # optional era
+({_year}(?:-{_month})?(?:-{_day})?)         # date
+(?::({_era}))?                              # optional era
+(?::({_year}(?:-{_month})?(?:-{_day})?))?   # optional date
+$
+"""
+_single_date_pattern = rf"^({_year})(?:-({_month}))?(?:-({_day}))?$"
+
+
+class Calendar(Enum):
+    """Enum for calendar types."""
+
+    GREGORIAN = "GREGORIAN"
+    ISLAMIC = "ISLAMIC"
+    JULIAN = "JULIAN"
+
+    @staticmethod
+    def from_string(s: str) -> Calendar:
+        """Parses a string into a calendar type, potentially failing with a BaseError."""
+        match s:
+            case "GREGORIAN":
+                return Calendar.GREGORIAN
+            case "ISLAMIC":
+                return Calendar.ISLAMIC
+            case "JULIAN":
+                return Calendar.JULIAN
+            case _:
+                raise BaseError(f"Invalid calendar type: {s}")
+
+
+class Era(Enum):
+    """Enum for era types."""
+
+    AD = "AD"
+    BC = "BC"
+    BCE = "BCE"
+    CE = "CE"
+
+    @staticmethod
+    def from_string(s: str) -> Era:
+        """Parses a string into an era type, potentially failing with a BaseError."""
+        match s:
+            case "AD":
+                return Era.AD
+            case "BC":
+                return Era.BC
+            case "BCE":
+                return Era.BCE
+            case "CE":
+                return Era.CE
+            case _:
+                raise BaseError(f"Invalid era type: {s}")
+
+
+class DayMonthYearEra(Enum):
+    DAY = "Day"
+    MONTH = "Month"
+    YEAR = "Year"
+    ERA = "Era"
+
+
+class StartEnd(Enum):
+    START = "Start"
+    END = "End"
+
+
+@dataclass(frozen=True)
+class SingleDate:
+    """Information about a single date."""
+
+    era: Era | None
+    year: int
+    month: int | None
+    day: int | None
+
+
+@dataclass(frozen=True)
+class Date:
+    """Information about a date."""
+
+    calendar: Calendar
+    start: SingleDate
+    end: SingleDate | None
+
+
+def parse_date_string(s: str) -> Date:
+    """Parse a date string into a Date object.
+
+    Args:
+        s: date string
+
+    Returns:
+        Date object
+
+    Raises:
+        BaseError: if the date string cannot be parsed
+    """
+
+    calendar, start_era, start_date, end_era, end_date = _split_date_string(s)
+    calendar_enum = Calendar.from_string(calendar or "GREGORIAN")
+    if not end_date:
+        end_date = start_date
+    if calendar_enum != Calendar.ISLAMIC:
+        if not start_era:
+            start_era = "CE"
+        if end_date and not end_era:
+            end_era = start_era
+    start_era_enum = Era.from_string(start_era) if start_era else None
+    end_era_enum = Era.from_string(end_era) if end_era else None
+    start = _parse_single_date(start_date, start_era_enum)
+    end = _parse_single_date(end_date, end_era_enum) if end_date else None
+
+    return Date(calendar_enum, start, end)
+
+
+def is_full_date(s: str) -> bool:
+    """
+    Check if a string is a full DSP date string of the scheme calendar:epoch:yyyy-mm-dd:epoch:yyyy-mm-dd.
+    """
+    return bool(regex.search(_full_date_pattern, s, flags=regex.VERBOSE))
+
+
+def _split_date_string(s: str) -> tuple[str | None, str | None, str, str | None, str | None]:
+    date_match = regex.search(_full_date_pattern, s, flags=regex.VERBOSE)
+    if not date_match:
+        raise BaseError(f"Could not parse date: {s}")
+    date_groups = date_match.groups()
+    match date_groups:
+        case ("ISLAMIC", start_era, _, end_era, _) if start_era or end_era:
+            raise BaseError(f"ISLAMIC calendar does not support eras: {s}")
+        case (str() | None, str() | None, str(), str() | None, str() | None):
+            return cast(tuple[str | None, str | None, str, str | None, str | None], date_groups)
+        case _:
+            raise BaseError(f"Could not parse date: {s}")
+
+
+def _parse_single_date(date: str, era: Era | None) -> SingleDate:
+    date_match = regex.search(_single_date_pattern, date)
+    if not date_match:
+        raise BaseError(f"Could not parse date: {date}")
+    match date_match.groups():
+        case (str() as year, str() | None as month, str() | None as day):
+            y = int(year)
+            m = int(month) if month else None
+            d = int(day) if day else None
+            return SingleDate(era, y, m, d)
+        case _:
+            raise BaseError(f"Could not parse date: {date}")

dsp_tools/utils/data_formats/iri_util.py

@@ -0,0 +1,30 @@
+import regex
+
+_iri_pattern = r"^(http)s?://[\w\.\-~]*(:\d{,6})?(/[\w\-~]+)*(#[\w\-~]*)?"
+_resource_iri_pattern = r"https?://rdfh.ch/[a-fA-F0-9]{4}/[\w-]{22}"
+
+
+def is_iri(s: str) -> bool:
+    """Checks whether a string is a valid IRI."""
+    return regex.fullmatch(_iri_pattern, s) is not None
+
+
+def is_resource_iri(s: str) -> bool:
+    """Checks whether a string is a valid resource IRI."""
+    return regex.fullmatch(_resource_iri_pattern, s) is not None
+
+
+def from_dsp_iri_to_prefixed_iri(iri: str) -> str:
+    dsp_iri_re = r".+\/(.+?)\/v2#(.+)$"
+    if not (found := regex.search(dsp_iri_re, iri)):
+        return iri
+    return f"{found.group(1)}:{found.group(2)}"
+
+
+def make_dsp_ontology_prefix(api_url: str, shortcode: str, onto_name: str) -> str:
+    api_fixed = convert_api_url_for_correct_iri_namespace_construction(api_url)
+    return f"{api_fixed}/ontology/{shortcode}/{onto_name}/v2#"
+
+
+def convert_api_url_for_correct_iri_namespace_construction(api_url: str) -> str:
+    return regex.sub(r"^https", "http", api_url)

dsp_tools/utils/data_formats/shared.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import unicodedata
+from typing import Any
+from typing import Optional
+from typing import TypeGuard
+
+import pandas as pd
+import regex
+
+from dsp_tools.commands.excel2xml.propertyelement import PropertyElement
+
+
+def simplify_name(value: str) -> str:
+    """
+    Simplifies a given value in order to use it as node name
+
+    Args:
+        value: The value to be simplified
+
+    Returns:
+        str: The simplified value
+    """
+    simplified_value = value.lower()
+
+    # normalize characters (p.ex. ä becomes a)
+    simplified_value = unicodedata.normalize("NFKD", simplified_value)
+
+    # replace forward slash and whitespace with a dash
+    simplified_value = regex.sub("[/\\s]+", "-", simplified_value)
+
+    # delete all characters which are not letters, numbers or dashes
+    simplified_value = regex.sub("[^A-Za-z0-9\\-]+", "", simplified_value)
+
+    return simplified_value
+
+
+def check_notna(value: Optional[Any]) -> TypeGuard[Any]:
+    """
+    Check a value if it is usable in the context of data archiving. A value is considered usable if it is
+     - a number (integer or float, but not np.nan)
+     - a boolean
+     - a string with at least one Unicode letter (matching the regex ``\\p{L}``) or number, or at least one _, !, or ?
+       (The strings `None`, `<NA>`, `N/A`, and `-` are considered invalid.)
+     - a PropertyElement whose "value" fulfills the above criteria
+
+    Args:
+        value: any object encountered when analysing data
+
+    Returns:
+        True if the value is usable, False if it is N/A or otherwise unusable
+
+    Examples:
+        >>> check_notna(0)      == True
+        >>> check_notna(False)  == True
+        >>> check_notna("œ")    == True
+        >>> check_notna("0")    == True
+        >>> check_notna("_")    == True
+        >>> check_notna("!")    == True
+        >>> check_notna("?")    == True
+        >>> check_notna(None)   == False
+        >>> check_notna("None") == False
+        >>> check_notna(<NA>)   == False
+        >>> check_notna("<NA>") == False
+        >>> check_notna("-")    == False
+        >>> check_notna(" ")    == False
+    """
+
+    if isinstance(value, PropertyElement):
+        value = value.value
+
+    if isinstance(value, bool | int) or (
+        isinstance(value, float) and pd.notna(value)
+    ):  # necessary because isinstance(np.nan, float)
+        return True
+    elif isinstance(value, str):
+        return bool(regex.search(r"[\p{L}\d_!?]", value, flags=regex.UNICODE)) and not bool(
+            regex.search(r"^(none|<NA>|-|n/a)$", value, flags=regex.IGNORECASE)
+        )
+    else:
+        return False

dsp_tools/utils/data_formats/uri_util.py

@@ -0,0 +1,76 @@
+import regex
+
+
+def is_prod_like_server(server: str) -> bool:
+    return server in [
+        "https://api.dasch.swiss",
+        "https://api.rdu.dasch.swiss",
+        "https://api.ls-prod-server.dasch.swiss",
+        "https://api.ls-test-server.dasch.swiss",
+        "https://api.stage.dasch.swiss",
+    ]
+
+
+def is_uri(s: str) -> bool:
+    """Checks if the given string is a valid URI."""
+    # URI = scheme ":" ["//" host [":" port]] path ["?" query] ["#" fragment]
+    chars_for_path_query_fragment = r"\w_.\-:~%()!@,;/=*&'+"
+    scheme = r"(?<scheme>[a-z][a-z0-9+.\-]*)"
+    host = r"(?<host>[\w_.\-:~\[\]]+)"
+    port = r"(?<port>:\d{0,6})"
+    path = rf"(?<path>/[{chars_for_path_query_fragment}]*)"
+    query = rf"(?<query>\?[{chars_for_path_query_fragment}]+)"
+    fragment = rf"(?<fragment>#[{chars_for_path_query_fragment}]*)"
+    m = regex.match(rf"{scheme}:(//{host}{port}?){path}*{query}*{fragment}?", s, flags=regex.UNICODE)
+    return m is not None
+
+
+def is_iiif_uri(uri: str) -> bool:
+    """
+    Checks if the given URL is a valid IIIF URL.
+    It should support all versions of IIIF servers,
+    but was constructed with the syntax described in: https://iiif.io/api/image/3.0/#2-uri-syntax.
+    IIIF is open to modifications which are not described in the official documentation
+    (see https://iiif.io/api/annex/notes/design_principles/#define-success-not-failure).
+
+    Args:
+        uri: The URI to be checked.
+
+    Returns:
+        True if the URI is a valid IIIF URI, False otherwise.
+    """
+    # {scheme}://{server}/{prefix}/{identifier}/{region}/{size}/{rotation}/{quality}.{format}
+    split_uri = uri.lower().split("/")
+    try:
+        region_seg, size_seg, rotation_seg, quality_format_seg = split_uri[-4:]
+    except ValueError:
+        return False
+    # %5E is the URL encoded version of ^ ->
+    # because we do change the uri to lower case we need to change that in the regex
+    # (\d+(\.\d+)?) -> number, can be integer or float
+    # everything needs to be encapsulated in a group
+    # otherwise the ^ and $ only apply respectively to the first and last listed in the alternative options
+    region_re = (
+        r"^(full|square|"  # full | square
+        r"((pct:)?(\d+(\.\d+)?,){3}(\d+(\.\d+)?)))$"  # x,y,w,h | pct:x,y,w,h
+    )
+    if not regex.search(region_re, region_seg):
+        return False
+    size_re = (
+        r"^((\^|%5e)?max|"  # max | ^max
+        r"(\^|%5e)?full|"  # full | ^full
+        r"(\^|%5e)?pct:\d+(\.\d+)?|"  # pct:n | ^pct:n
+        r"(\^|%5e)?(\d+(\.\d+)?)+(,|%2c)|"  # w, | ^w,
+        r"(\^|%5e)?,\d+(\.\d+)?|"  # ,h | ^,h
+        r"(\^|%5e)?!?\d+(\.\d+)?,\d+(\.\d+)?)$"  # w,h | ^w,h | !w,h | ^!w,h
+    )
+    if not regex.search(size_re, size_seg):
+        return False
+    # rotation -> floating point number 0-360 -> n | !n (positive and negative are allowed)
+    rotation_re = r"^!?[+-]?\d+(\.\d+)?$"
+    if not regex.search(rotation_re, rotation_seg):
+        return False
+    # quality -> color | colour | gray | grey | bitonal | default | native
+    # format -> jpg | tif | png | gif | jp2 | pdf | webp
+    quality_format_re = r"^(colou?r|gr[ae]y|bitonal|default|native)(\.(jpg|tif|png|jp2|gif|pdf|webp))?$"
+    return bool(regex.search(quality_format_re, quality_format_seg))

dsp_tools/utils/fuseki_bloating.py

@@ -0,0 +1,63 @@
+from typing import assert_never
+
+from loguru import logger
+
+from dsp_tools.clients.fuseki_metrics import FusekiBloatingLevel
+from dsp_tools.clients.fuseki_metrics import FusekiMetrics
+from dsp_tools.config.logger_config import LOGGER_SAVEPATH
+from dsp_tools.utils.ansi_colors import BACKGROUND_BOLD_RED
+from dsp_tools.utils.ansi_colors import BOLD_YELLOW
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+
+_1_GB_IN_BYTES = 1_000_000_000
+WARNING_BLOATING = 10 * _1_GB_IN_BYTES
+CRITICAL_BLOATING = 20 * _1_GB_IN_BYTES
+
+
+def communicate_fuseki_bloating(fuseki_metrics: FusekiMetrics) -> None:
+    size_diff = _analyse_fuseki_sizes(fuseki_metrics)
+    bloating_level = _get_bloating_level(size_diff)
+    if size_diff is not None:
+        rounded = round(size_diff / _1_GB_IN_BYTES, 2)
+    else:
+        rounded = None
+    msg = (
+        f"The xmlupload caused the database to use {rounded} GB disk space. "
+        f"Please check that your test server has enough disk space for an upload. "
+        f"If you have any questions contact the dsp-tools developers at support@dasch.swiss."
+    )
+    match bloating_level:
+        case FusekiBloatingLevel.OK:
+            logger.debug(msg)
+        case FusekiBloatingLevel.WARNING:
+            logger.warning(msg)
+            print(f"{BOLD_YELLOW}WARNING: {msg}{RESET_TO_DEFAULT}")
+        case FusekiBloatingLevel.CRITICAL:
+            logger.warning(msg)
+            print(f"{BACKGROUND_BOLD_RED}WARNING: {msg}{RESET_TO_DEFAULT}")
+        case FusekiBloatingLevel.CALCULATION_FAILURE:
+            msg = (
+                "The database bloating size could not be calculated. "
+                f"Please contact the dsp-tools developers (at support@dasch.swiss) "
+                f"with your logs saved at {LOGGER_SAVEPATH}."
+            )
+            print(f"{BACKGROUND_BOLD_RED}{msg}{RESET_TO_DEFAULT}")
+            logger.error(msg)
+        case _:
+            assert_never(bloating_level)
+
+
+def _get_bloating_level(size_diff: int | None) -> FusekiBloatingLevel:
+    if size_diff is None:
+        return FusekiBloatingLevel.CALCULATION_FAILURE
+    if size_diff <= WARNING_BLOATING:
+        return FusekiBloatingLevel.OK
+    if size_diff <= CRITICAL_BLOATING:
+        return FusekiBloatingLevel.WARNING
+    return FusekiBloatingLevel.CRITICAL
+
+
+def _analyse_fuseki_sizes(fuseki_metrics: FusekiMetrics) -> int | None:
+    if fuseki_metrics.end_size is not None and fuseki_metrics.start_size is not None:
+        return fuseki_metrics.end_size - fuseki_metrics.start_size
+    return None

dsp_tools/utils/json_parsing.py

@@ -0,0 +1,22 @@
+import json
+from pathlib import Path
+from typing import Any
+from typing import cast
+
+from loguru import logger
+
+from dsp_tools.error.exceptions import JSONFileParsingError
+from dsp_tools.error.exceptions import UserFilepathNotFoundError
+
+
+def parse_json_file(filepath: Path) -> dict[str, Any]:
+    if not filepath.exists():
+        raise UserFilepathNotFoundError(filepath)
+    with open(filepath, encoding="utf-8") as f:
+        try:
+            loaded = json.load(f)
+            return cast(dict[str, Any], loaded)
+        except json.JSONDecodeError as e:
+            logger.error(e)
+            msg = f"The input file '{filepath}' cannot be parsed to a JSON object."
+            raise JSONFileParsingError(msg) from None

dsp_tools/utils/rdf_constants.py

@@ -0,0 +1,42 @@
+from typing import Union
+
+from rdflib import IdentifiedNode
+from rdflib import Literal
+from rdflib import Namespace
+from rdflib import Variable
+from rdflib.term import Node
+
+# naming conventions of prefixes and namespaces
+
+# a prefix as a string is called [...]_PREFIX
+# a prefix as a rdflib Namespace has no further suffix
+
+#####
+# rdflib typing
+type PropertyTypeAlias = Union[IdentifiedNode, Variable]
+type SubjectObjectTypeAlias = Union[IdentifiedNode, Literal, Variable, Node]
+
+#####
+# DSP-Namespaces
+KNORA_API_PREFIX = "http://api.knora.org/ontology/knora-api/v2#"
+KNORA_API = Namespace(KNORA_API_PREFIX)
+
+KNORA_ADMIN_PREFIX = "http://www.knora.org/ontology/knora-admin#"
+
+SALSAH_GUI_PREFIX = "http://api.knora.org/ontology/salsah-gui/v2#"
+SALSAH_GUI = Namespace(SALSAH_GUI_PREFIX)
+
+
+#####
+# Mappers
+
+DSP_NAME_TO_PREFIX = {"knora-api": KNORA_API_PREFIX, "salsah-gui": SALSAH_GUI_PREFIX}
+
+
+#####
+# For validate-data
+API_SHAPES_PREFIX = "http://api.knora.org/ontology/knora-api/shapes/v2#"
+API_SHAPES = Namespace(API_SHAPES_PREFIX)
+DATA = Namespace("http://data/")
+DASH_PREFIX = "http://datashapes.org/dash#"
+DASH = Namespace(DASH_PREFIX)

dsp_tools/utils/rdflib_utils.py

@@ -0,0 +1,10 @@
+import json
+from typing import Any
+
+from rdflib import Graph
+
+
+def serialise_json(rdf_graph: Graph) -> list[dict[str, Any]]:
+    graph_bytes = rdf_graph.serialize(format="json-ld", encoding="utf-8")
+    json_graph: list[dict[str, Any]] = json.loads(graph_bytes)
+    return json_graph