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

dsp_tools/commands/excel2xml/excel2xml_lib.py

@@ -1,332 +1,42 @@
 import copy
 import dataclasses
-import datetime
 import difflib
 import json
 import os
-import uuid
 import warnings
+from collections.abc import Iterable
 from pathlib import Path
 from typing import Any
-from typing import Iterable
 from typing import Optional
 from typing import Union
 
 import regex
 from lxml import etree
 from lxml.builder import E
-from namedentities.core import numeric_entities  # type: ignore[import-untyped]
-from regex import Match
 
 from dsp_tools.commands.excel2xml.propertyelement import PropertyElement
-from dsp_tools.models.custom_warnings import DspToolsUserWarning
-from dsp_tools.models.datetimestamp import DateTimeStamp
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.utils.date_util import is_full_date
-from dsp_tools.utils.shared import check_notna
-from dsp_tools.utils.shared import simplify_name
-from dsp_tools.utils.uri_util import is_iiif_uri
-from dsp_tools.utils.uri_util import is_uri
-from dsp_tools.utils.xml_validation import validate_xml_file
+from dsp_tools.error.custom_warnings import DspToolsUserWarning
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.legacy_models.datetimestamp import DateTimeStamp
+from dsp_tools.utils.data_formats.date_util import is_full_date
+from dsp_tools.utils.data_formats.shared import check_notna
+from dsp_tools.utils.data_formats.shared import simplify_name
+from dsp_tools.utils.data_formats.uri_util import is_iiif_uri
+from dsp_tools.utils.data_formats.uri_util import is_uri
+from dsp_tools.utils.xml_parsing.parse_clean_validate_xml import parse_and_validate_xml_file
+from dsp_tools.xmllib import find_dates_in_string as find_dates_in_string  # noqa: PLC0414 (explicit re-export)
+from dsp_tools.xmllib.general_functions import make_xsd_compatible_id
+from dsp_tools.xmllib.general_functions import make_xsd_compatible_id_with_uuid
+from dsp_tools.xmllib.internal.input_converters import numeric_entities
 
 # ruff: noqa: E501, UP031 (line-too-long, use f-string over percent formatting)
 
+make_xsd_id_compatible = make_xsd_compatible_id_with_uuid
+make_xsd_id_compatible_without_uuid = make_xsd_compatible_id
 
 xml_namespace_map = {None: "https://dasch.swiss/schema", "xsi": "http://www.w3.org/2001/XMLSchema-instance"}
 
 
-def make_xsd_id_compatible(string: str) -> str:
-    """
-    An xsd:ID may not contain all types of special characters.
-    This function replaces illegal characters with "_" and appends a random UUID.
-    The UUID will be different each time the function is called.
-
-    The string must contain at least one Unicode letter (matching the regex ``\\p{L}``),
-    underscore, !, ?, or number, but must not be `None`, `<NA>`, `N/A`, or `-`.
-    Otherwise, a BaseError will be raised.
-
-    Args:
-        string: input string
-
-    Raises:
-        BaseError: if the input cannot be transformed to an xsd:ID
-
-    Returns:
-        an xsd ID based on the input string, with a UUID attached.
-    """
-    res = make_xsd_id_compatible_without_uuid(string)
-    _uuid = uuid.uuid4()
-    res = f"{res}_{_uuid}"
-    return res
-
-
-def make_xsd_id_compatible_without_uuid(string: str) -> str:
-    """
-    An xsd:ID may not contain all types of special characters.
-    This function replaces illegal characters with "_".
-
-    The string must contain at least one Unicode letter (matching the regex ``\\p{L}``),
-    underscore, !, ?, or number, but must not be `None`, `<NA>`, `N/A`, or `-`.
-    Otherwise, a BaseError will be raised.
-
-    Args:
-        string: input string
-
-    Raises:
-        BaseError: if the input cannot be transformed to an xsd:ID
-
-    Returns:
-        an xsd ID compatible string based on the input string
-    """
-    if not isinstance(string, str) or not check_notna(string):
-        raise BaseError(f"The input '{string}' cannot be transformed to an xsd:ID")
-    # if start of string is neither letter nor underscore, add an underscore
-    res = regex.sub(r"^(?=[^A-Za-z_])", "_", string)
-    # replace all illegal characters by underscore
-    res = regex.sub(r"[^\w_\-.]", "_", res, flags=regex.ASCII)
-    return res
-
-
-def _find_french_bc_date(
-    string: str,
-    lookbehind: str,
-    lookahead: str,
-) -> Optional[str]:
-    french_bc_regex = r"av(?:\. |\.| )J\.?-?C\.?"
-    if not regex.search(french_bc_regex, string):
-        return None
-
-    year_regex = r"\d{1,5}"
-    sep_regex = r" ?- ?"
-
-    year_range_regex = rf"{lookbehind}({year_regex}){sep_regex}({year_regex}) {french_bc_regex}{lookahead}"
-    year_range = regex.search(year_range_regex, string)
-    if year_range:
-        start_year = int(year_range.group(1))
-        end_year = int(year_range.group(2))
-        if end_year > start_year:
-            return None
-        return f"GREGORIAN:BC:{start_year}:BC:{end_year}"
-
-    single_year_regex = rf"{lookbehind}({year_regex}) {french_bc_regex}{lookahead}"
-    single_year = regex.search(single_year_regex, string)
-    if single_year:
-        start_year = int(single_year.group(1))
-        return f"GREGORIAN:BC:{start_year}:BC:{start_year}"
-
-    return None
-
-
-def find_date_in_string(string: str) -> Optional[str]:
-    """
-    Checks if a string contains a date value (single date, or date range),
-    and returns the first found date as DSP-formatted string.
-    Returns None if no date was found.
-
-    Notes:
-        - All dates are interpreted in the Christian era and the Gregorian calendar.
-        - BC dates are only supported in French notation (e.g. 1000-900 av. J.-C.).
-        - The years 0000-2999 are supported, in 3/4-digit form.
-        - Dates written with slashes are always interpreted in a European manner: 5/11/2021 is the 5th of November.
-        - In the European notation, 2-digit years are expanded to 4 digits, with the current year as watershed:
-            - 30.4.24 -> 30.04.2024
-            - 30.4.25 -> 30.04.1925
-
-    Currently supported date formats:
-        - 0476-09-04 -> GREGORIAN:CE:0476-09-04:CE:0476-09-04
-        - 0476_09_04 -> GREGORIAN:CE:0476-09-04:CE:0476-09-04
-        - 30.4.2021 -> GREGORIAN:CE:2021-04-30:CE:2021-04-30
-        - 30.4.21 -> GREGORIAN:CE:2021-04-30:CE:2021-04-30
-        - 5/11/2021 -> GREGORIAN:CE:2021-11-05:CE:2021-11-05
-        - Jan 26, 1993 -> GREGORIAN:CE:1993-01-26:CE:1993-01-26
-        - 28.2.-1.12.1515 -> GREGORIAN:CE:1515-02-28:CE:1515-12-01
-        - 25.-26.2.0800 -> GREGORIAN:CE:0800-02-25:CE:0800-02-26
-        - 1.9.2022-3.1.2024 -> GREGORIAN:CE:2022-09-01:CE:2024-01-03
-        - 1848 -> GREGORIAN:CE:1848:CE:1848
-        - 1849/1850 -> GREGORIAN:CE:1849:CE:1850
-        - 1849/50 -> GREGORIAN:CE:1849:CE:1850
-        - 1845-50 -> GREGORIAN:CE:1845:CE:1850
-        - 840-50 -> GREGORIAN:CE:840:CE:850
-        - 840-1 -> GREGORIAN:CE:840:CE:841
-        - 1000-900 av. J.-C. -> GREGORIAN:BC:1000:BC:900
-        - 45 av. J.-C. -> GREGORIAN:BC:45:BC:45
-
-    Args:
-        string: string to check
-
-    Returns:
-        DSP-formatted date string, or None
-
-    Examples:
-        >>> if find_date_in_string(row["Epoch"]):
-        >>>     resource.append(make_date_prop(":hasDate", find_date_in_string(row["Epoch"]))
-
-    See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#date-prop
-    """
-
-    # sanitize input, just in case that the method was called on an empty or N/A cell
-    if not check_notna(string):
-        return None
-    try:
-        return _find_date_in_string_throwing(string)
-    except ValueError:
-        return None
-
-
-_months_dict = {
-    "January": 1,
-    "Jan": 1,
-    "February": 2,
-    "Feb": 2,
-    "March": 3,
-    "Mar": 3,
-    "April": 4,
-    "Apr": 4,
-    "May": 5,
-    "June": 6,
-    "Jun": 6,
-    "July": 7,
-    "Jul": 7,
-    "August": 8,
-    "Aug": 8,
-    "September": 9,
-    "Sept": 9,
-    "October": 10,
-    "Oct": 10,
-    "November": 11,
-    "Nov": 11,
-    "December": 12,
-    "Dec": 12,
-}
-
-
-def _find_date_in_string_throwing(string: str) -> str | None:
-    """
-    This function is the same as find_date_in_string(), but may raise a ValueError instead of returning None.
-    """
-    year_regex = r"([0-2]?[0-9][0-9][0-9])"
-    year_regex_2_or_4_digits = r"((?:[0-2]?[0-9])?[0-9][0-9])"
-    month_regex = r"([0-1]?[0-9])"
-    day_regex = r"([0-3]?[0-9])"
-    sep_regex = r"[\./]"
-    lookbehind = r"(?<![0-9A-Za-z])"
-    lookahead = r"(?![0-9A-Za-z])"
-
-    if french_bc_date := _find_french_bc_date(string=string, lookbehind=lookbehind, lookahead=lookahead):
-        return french_bc_date
-
-    # template: 2021-01-01 | 2015_01_02
-    iso_date = regex.search(rf"{lookbehind}{year_regex}[_-]([0-1][0-9])[_-]([0-3][0-9]){lookahead}", string)
-
-    # template: 6.-8.3.1948 | 6/2/1947 - 24.03.1948
-    eur_date_range_regex = (
-        rf"{lookbehind}"
-        rf"{day_regex}{sep_regex}(?:{month_regex}{sep_regex}{year_regex_2_or_4_digits}?)? ?(?:-|:|to) ?"
-        rf"{day_regex}{sep_regex}{month_regex}{sep_regex}{year_regex_2_or_4_digits}"
-        rf"{lookahead}"
-    )
-    eur_date_range = regex.search(eur_date_range_regex, string)
-
-    # template: 1.4.2021 | 5/11/2021
-    eur_date_regex = rf"{lookbehind}{day_regex}{sep_regex}{month_regex}{sep_regex}{year_regex_2_or_4_digits}{lookahead}"
-    eur_date = regex.search(
-        eur_date_regex,
-        string,
-    )
-
-    # template: March 9, 1908 | March5,1908 | May 11, 1906
-    all_months = "|".join(_months_dict)
-    monthname_date_regex = rf"{lookbehind}({all_months}) ?{day_regex}, ?{year_regex}{lookahead}"
-    monthname_date = regex.search(monthname_date_regex, string)
-
-    # template: 1849/50 | 1849-50 | 1849/1850
-    year_range = regex.search(lookbehind + year_regex + r"[/-](\d{1,4})" + lookahead, string)
-
-    # template: 1907
-    year_only = regex.search(rf"{lookbehind}{year_regex}{lookahead}", string)
-
-    res: str | None = None
-    if iso_date:
-        res = _from_iso_date(iso_date)
-    elif eur_date_range:
-        res = _from_eur_date_range(eur_date_range)
-    elif eur_date:
-        res = _from_eur_date(eur_date)
-    elif monthname_date:
-        res = _from_monthname_date(monthname_date)
-    elif year_range:
-        res = _from_year_range(year_range)
-    elif year_only:
-        year = int(year_only.group(0))
-        res = f"GREGORIAN:CE:{year}:CE:{year}"
-    return res
-
-
-def _from_iso_date(iso_date: Match[str]) -> str:
-    year = int(iso_date.group(1))
-    month = int(iso_date.group(2))
-    day = int(iso_date.group(3))
-    date = datetime.date(year, month, day)
-    return f"GREGORIAN:CE:{date.isoformat()}:CE:{date.isoformat()}"
-
-
-def _expand_2_digit_year(year: int) -> int:
-    current_year = datetime.date.today().year - 2000
-    if year <= current_year:
-        return year + 2000
-    elif year <= 99:
-        return year + 1900
-    else:
-        return year
-
-
-def _from_eur_date_range(eur_date_range: Match[str]) -> str:
-    startday = int(eur_date_range.group(1))
-    startmonth = int(eur_date_range.group(2)) if eur_date_range.group(2) else int(eur_date_range.group(5))
-    startyear = int(eur_date_range.group(3)) if eur_date_range.group(3) else int(eur_date_range.group(6))
-    startyear = _expand_2_digit_year(startyear)
-    endday = int(eur_date_range.group(4))
-    endmonth = int(eur_date_range.group(5))
-    endyear = int(eur_date_range.group(6))
-    endyear = _expand_2_digit_year(endyear)
-    startdate = datetime.date(startyear, startmonth, startday)
-    enddate = datetime.date(endyear, endmonth, endday)
-    if enddate < startdate:
-        raise ValueError
-    return f"GREGORIAN:CE:{startdate.isoformat()}:CE:{enddate.isoformat()}"
-
-
-def _from_eur_date(eur_date: Match[str]) -> str:
-    startday = int(eur_date.group(1))
-    startmonth = int(eur_date.group(2))
-    startyear = int(eur_date.group(3))
-    startyear = _expand_2_digit_year(startyear)
-    date = datetime.date(startyear, startmonth, startday)
-    return f"GREGORIAN:CE:{date.isoformat()}:CE:{date.isoformat()}"
-
-
-def _from_monthname_date(monthname_date: Match[str]) -> str:
-    day = int(monthname_date.group(2))
-    month = _months_dict[monthname_date.group(1)]
-    year = int(monthname_date.group(3))
-    date = datetime.date(year, month, day)
-    return f"GREGORIAN:CE:{date.isoformat()}:CE:{date.isoformat()}"
-
-
-def _from_year_range(year_range: Match[str]) -> str:
-    startyear = int(year_range.group(1))
-    endyear = int(year_range.group(2))
-    if endyear // 10 == 0:
-        # endyear is only 1-digit: add the first 2-3 digits of startyear
-        endyear = startyear // 10 * 10 + endyear
-    elif endyear // 100 == 0:
-        # endyear is only 2-digit: add the first 1-2 digits of startyear
-        endyear = startyear // 100 * 100 + endyear
-    if endyear <= startyear:
-        raise ValueError
-    return f"GREGORIAN:CE:{startyear}:CE:{endyear}"
-
-
 def prepare_value(
     value: Union[PropertyElement, str, int, float, bool, Iterable[Union[PropertyElement, str, int, float, bool]]],
 ) -> list[PropertyElement]:
@@ -384,15 +94,15 @@ def make_root(
 
 def append_permissions(root_element: etree._Element) -> etree._Element:
     """
-    After having created a root element, call this method to append the four permissions "res-default",
-    "res-restricted", "prop-default", and "prop-restricted" to it. These four permissions are a good basis to
+    After having created a root element, call this function to append the standard permission definitions "public",
+    "limited_view", and "private" to it. These definitions are a good basis to
     start with, but remember that they can be adapted, and that other permissions can be defined instead of these.
 
     Args:
         root_element: The XML root element `<knora>` created by make_root()
 
     Returns:
-        The root element with the four permission blocks appended
+        The root element with the permission definition blocks appended
 
     Examples:
         >>> root = excel2xml.make_root(shortcode=shortcode, default_ontology=default_ontology)
@@ -406,33 +116,24 @@ def append_permissions(root_element: etree._Element) -> etree._Element:
     # lxml.builder.E is a more sophisticated element factory than etree.Element.
     # E.tag is equivalent to E("tag") and results in <tag>
 
-    res_default = etree.Element("{%s}permissions" % xml_namespace_map[None], id="res-default")
-    res_default.append(ALLOW("V", group="UnknownUser"))
-    res_default.append(ALLOW("V", group="KnownUser"))
-    res_default.append(ALLOW("D", group="ProjectMember"))
-    res_default.append(ALLOW("CR", group="ProjectAdmin"))
-    res_default.append(ALLOW("CR", group="Creator"))
-    root_element.append(res_default)
-
-    res_restricted = PERMISSIONS(id="res-restricted")
-    res_restricted.append(ALLOW("M", group="ProjectMember"))
-    res_restricted.append(ALLOW("CR", group="ProjectAdmin"))
-    res_restricted.append(ALLOW("CR", group="Creator"))
-    root_element.append(res_restricted)
-
-    prop_default = PERMISSIONS(id="prop-default")
-    prop_default.append(ALLOW("V", group="UnknownUser"))
-    prop_default.append(ALLOW("V", group="KnownUser"))
-    prop_default.append(ALLOW("D", group="ProjectMember"))
-    prop_default.append(ALLOW("CR", group="ProjectAdmin"))
-    prop_default.append(ALLOW("CR", group="Creator"))
-    root_element.append(prop_default)
-
-    prop_restricted = PERMISSIONS(id="prop-restricted")
-    prop_restricted.append(ALLOW("M", group="ProjectMember"))
-    prop_restricted.append(ALLOW("CR", group="ProjectAdmin"))
-    prop_restricted.append(ALLOW("CR", group="Creator"))
-    root_element.append(prop_restricted)
+    _public = PERMISSIONS(id="public")
+    _public.append(ALLOW("V", group="UnknownUser"))
+    _public.append(ALLOW("V", group="KnownUser"))
+    _public.append(ALLOW("D", group="ProjectMember"))
+    _public.append(ALLOW("CR", group="ProjectAdmin"))
+    root_element.append(_public)
+
+    _private_view = PERMISSIONS(id="limited_view")
+    _private_view.append(ALLOW("RV", group="UnknownUser"))
+    _private_view.append(ALLOW("RV", group="KnownUser"))
+    _private_view.append(ALLOW("D", group="ProjectMember"))
+    _private_view.append(ALLOW("CR", group="ProjectAdmin"))
+    root_element.append(_private_view)
+
+    _private = PERMISSIONS(id="private")
+    _private.append(ALLOW("D", group="ProjectMember"))
+    _private.append(ALLOW("CR", group="ProjectAdmin"))
+    root_element.append(_private)
 
     return root_element
 
@@ -441,7 +142,7 @@ def make_resource(  # noqa: D417 (undocumented-param)
     label: str,
     restype: str,
     id: str,
-    permissions: str = "res-default",
+    permissions: str = "public",
     ark: Optional[str] = None,
     iri: Optional[str] = None,
     creation_date: Optional[str] = None,
@@ -496,7 +197,7 @@ def make_resource(  # noqa: D417 (undocumented-param)
 
 def make_bitstream_prop(
     path: Union[str, os.PathLike[Any]],
-    permissions: str = "prop-default",
+    permissions: str = "public",
     check: bool = False,
     calling_resource: str = "",
 ) -> etree._Element:
@@ -540,7 +241,7 @@ def make_bitstream_prop(
 
 def make_iiif_uri_prop(
     iiif_uri: str,
-    permissions: str = "prop-default",
+    permissions: str = "public",
     calling_resource: str = "",
 ) -> etree._Element:
     """
@@ -622,7 +323,7 @@ def make_boolean_prop(
      - true: (True, "true", "True", "1", 1, "yes", "Yes")
      - false: (False, "false", "False", "0", 0, "no", "No")
 
-    Unless provided as PropertyElement, the permissions of the value default to "prop-default".
+    Unless provided as PropertyElement, the permissions of the value default to "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -638,11 +339,11 @@ def make_boolean_prop(
     Examples:
         >>> excel2xml.make_boolean_prop(":testproperty", "no")
                 <boolean-prop name=":testproperty">
-                    <boolean permissions="prop-default">false</boolean>
+                    <boolean permissions="public">false</boolean>
                 </boolean-prop>
-        >>> excel2xml.make_boolean_prop(":testproperty", excel2xml.PropertyElement("1", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_boolean_prop(":testproperty", excel2xml.PropertyElement("1", permissions="private", comment="example"))
                 <boolean-prop name=":testproperty">
-                    <boolean permissions="prop-restricted" comment="example">true</boolean>
+                    <boolean permissions="private" comment="example">true</boolean>
                 </boolean-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#boolean-prop
@@ -651,7 +352,7 @@ def make_boolean_prop(
     # validate input
     if isinstance(value, PropertyElement):
         value_new = dataclasses.replace(value, value=_format_bool(value.value, name, calling_resource))
-    elif isinstance(value, (str, bool, int)):
+    elif isinstance(value, str | bool | int):
         value_new = PropertyElement(_format_bool(value, name, calling_resource))
     else:
         raise BaseError(
@@ -685,7 +386,7 @@ def make_color_prop(
 ) -> etree._Element:
     """
     Make a `<color-prop>` from one or more colors. The color(s) can be provided as string or as PropertyElement with a
-    string inside. If provided as string, the permissions default to "prop-default".
+    string inside. If provided as string, the permissions default to "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -701,16 +402,16 @@ def make_color_prop(
     Examples:
         >>> excel2xml.make_color_prop(":testproperty", "#00ff66")
                 <color-prop name=":testproperty">
-                    <color permissions="prop-default">#00ff66</color>
+                    <color permissions="public">#00ff66</color>
                 </color-prop>
-        >>> excel2xml.make_color_prop(":testproperty", excel2xml.PropertyElement("#00ff66", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_color_prop(":testproperty", excel2xml.PropertyElement("#00ff66", permissions="private", comment="example"))
                 <color-prop name=":testproperty">
-                    <color permissions="prop-restricted" comment="example">#00ff66</color>
+                    <color permissions="private" comment="example">#00ff66</color>
                 </color-prop>
         >>> excel2xml.make_color_prop(":testproperty", ["#00ff66", "#000000"])
                 <color-prop name=":testproperty">
-                    <color permissions="prop-default">#00ff66</color>
-                    <color permissions="prop-default">#000000</color>
+                    <color permissions="public">#00ff66</color>
+                    <color permissions="public">#000000</color>
                 </color-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#color-prop
@@ -756,7 +457,7 @@ def make_date_prop(
 ) -> etree._Element:
     """
     Make a `<date-prop>` from one or more dates/date ranges. The date(s) can be provided as string or as PropertyElement
-    with a string inside. If provided as string, the permissions default to "prop-default".
+    with a string inside. If provided as string, the permissions default to "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -772,20 +473,20 @@ def make_date_prop(
     Examples:
         >>> excel2xml.make_date_prop(":testproperty", "GREGORIAN:CE:2014-01-31")
                 <date-prop name=":testproperty">
-                    <date permissions="prop-default">GREGORIAN:CE:2014-01-31</date>
+                    <date permissions="public">GREGORIAN:CE:2014-01-31</date>
                 </date-prop>
-        >>> excel2xml.make_date_prop(":testproperty", excel2xml.PropertyElement("GREGORIAN:CE:2014-01-31", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_date_prop(":testproperty", excel2xml.PropertyElement("GREGORIAN:CE:2014-01-31", permissions="private", comment="example"))
                 <date-prop name=":testproperty">
-                    <date permissions="prop-restricted" comment="example">
+                    <date permissions="private" comment="example">
                         GREGORIAN:CE:2014-01-31
                     </date>
                 </date-prop>
         >>> excel2xml.make_date_prop(":testproperty", ["GREGORIAN:CE:1930-09-02:CE:1930-09-03", "GREGORIAN:CE:1930-09-02:CE:1930-09-03"])
                 <date-prop name=":testproperty">
-                    <date permissions="prop-default">
+                    <date permissions="public">
                         GREGORIAN:CE:1930-09-02:CE:1930-09-03
                     </date>
-                    <date permissions="prop-default">
+                    <date permissions="public">
                         GREGORIAN:CE:1930-09-02:CE:1930-09-03
                     </date>
                 </date-prop>
@@ -834,7 +535,7 @@ def make_decimal_prop(
     """
     Make a `<decimal-prop>` from one or more decimal numbers. The decimal(s) can be provided as string, float, or as
     PropertyElement with a string/float inside. If provided as string/float, the permissions default to
-    "prop-default".
+    "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -850,16 +551,16 @@ def make_decimal_prop(
     Examples:
         >>> excel2xml.make_decimal_prop(":testproperty", "3.14159")
                 <decimal-prop name=":testproperty">
-                    <decimal permissions="prop-default">3.14159</decimal>
+                    <decimal permissions="public">3.14159</decimal>
                 </decimal-prop>
-        >>> excel2xml.make_decimal_prop(":testproperty", excel2xml.PropertyElement("3.14159", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_decimal_prop(":testproperty", excel2xml.PropertyElement("3.14159", permissions="private", comment="example"))
                 <decimal-prop name=":testproperty">
-                    <decimal permissions="prop-restricted" comment="example">3.14159</decimal>
+                    <decimal permissions="private" comment="example">3.14159</decimal>
                 </decimal-prop>
         >>> excel2xml.make_decimal_prop(":testproperty", ["3.14159", "2.718"])
                 <decimal-prop name=":testproperty">
-                    <decimal permissions="prop-default">3.14159</decimal>
-                    <decimal permissions="prop-default">2.718</decimal>
+                    <decimal permissions="public">3.14159</decimal>
+                    <decimal permissions="public">2.718</decimal>
                 </decimal-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#decimal-prop
@@ -907,7 +608,7 @@ def make_geometry_prop(
 ) -> etree._Element:
     """
     Make a `<geometry-prop>` from one or more areas of an image. The area(s) can be provided as JSON-string or as
-    PropertyElement with the JSON-string inside. If provided as string, the permissions default to "prop-default".
+    PropertyElement with the JSON-string inside. If provided as string, the permissions default to "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -923,16 +624,16 @@ def make_geometry_prop(
     Examples:
         >>> excel2xml.make_geometry_prop(":testproperty", json_string)
                 <geometry-prop name=":testproperty">
-                    <geometry permissions="prop-default">{JSON}</geometry>
+                    <geometry permissions="public">{JSON}</geometry>
                 </geometry-prop>
-        >>> excel2xml.make_geometry_prop(":testproperty", excel2xml.PropertyElement(json_string, permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_geometry_prop(":testproperty", excel2xml.PropertyElement(json_string, permissions="private", comment="example"))
                 <geometry-prop name=":testproperty">
-                    <geometry permissions="prop-restricted" comment="example">{JSON}</geometry>
+                    <geometry permissions="private" comment="example">{JSON}</geometry>
                 </geometry-prop>
         >>> excel2xml.make_geometry_prop(":testproperty", [json_string1, json_string2])
                 <geometry-prop name=":testproperty">
-                    <geometry permissions="prop-default">{JSON}</geometry>
-                    <geometry permissions="prop-default">{JSON}</geometry>
+                    <geometry permissions="public">{JSON}</geometry>
+                    <geometry permissions="public">{JSON}</geometry>
                 </geometry-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#geometry-prop
@@ -992,7 +693,7 @@ def make_geoname_prop(
     """
     Make a `<geoname-prop>` from one or more geonames.org IDs. The ID(s) can be provided as string, integer, or as
     PropertyElement with a string/integer inside. If provided as string/integer, the permissions default to
-    "prop-default".
+    "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -1008,16 +709,16 @@ def make_geoname_prop(
     Examples:
         >>> excel2xml.make_geoname_prop(":testproperty", "2761369")
                 <geoname-prop name=":testproperty">
-                    <geoname permissions="prop-default">2761369</geoname>
+                    <geoname permissions="public">2761369</geoname>
                 </geoname-prop>
-        >>> excel2xml.make_geoname_prop(":testproperty", excel2xml.PropertyElement("2761369", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_geoname_prop(":testproperty", excel2xml.PropertyElement("2761369", permissions="private", comment="example"))
                 <geoname-prop name=":testproperty">
-                    <geoname permissions="prop-restricted" comment="example">2761369</geoname>
+                    <geoname permissions="private" comment="example">2761369</geoname>
                 </geoname-prop>
         >>> excel2xml.make_geoname_prop(":testproperty", ["2761369", "1010101"])
                 <geoname-prop name=":testproperty">
-                    <geoname permissions="prop-default">2761369</geoname>
-                    <geoname permissions="prop-default">1010101</geoname>
+                    <geoname permissions="public">2761369</geoname>
+                    <geoname permissions="public">1010101</geoname>
                 </geoname-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#geoname-prop
@@ -1064,7 +765,7 @@ def make_integer_prop(
     """
     Make a `<integer-prop>` from one or more integers. The integers can be provided as string, integer, or as
     PropertyElement with a string/integer inside. If provided as string/integer, the permissions default to
-    "prop-default".
+    "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -1080,16 +781,16 @@ def make_integer_prop(
     Examples:
         >>> excel2xml.make_integer_prop(":testproperty", "2761369")
                 <integer-prop name=":testproperty">
-                    <integer permissions="prop-default">2761369</integer>
+                    <integer permissions="public">2761369</integer>
                 </integer-prop>
-        >>> excel2xml.make_integer_prop(":testproperty", excel2xml.PropertyElement("2761369", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_integer_prop(":testproperty", excel2xml.PropertyElement("2761369", permissions="private", comment="example"))
                 <integer-prop name=":testproperty">
-                    <integer permissions="prop-restricted" comment="example">2761369</integer>
+                    <integer permissions="private" comment="example">2761369</integer>
                 </integer-prop>
         >>> excel2xml.make_integer_prop(":testproperty", ["2761369", "1010101"])
                 <integer-prop name=":testproperty">
-                    <integer permissions="prop-default">2761369</integer>
-                    <integer permissions="prop-default">1010101</integer>
+                    <integer permissions="public">2761369</integer>
+                    <integer permissions="public">1010101</integer>
                 </integer-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#integer-prop
@@ -1138,7 +839,7 @@ def make_list_prop(
 ) -> etree._Element:
     """
     Make a `<list-prop>` from one or more list nodes. The name(s) of the list node(s) can be provided as string or as
-    PropertyElement with a string inside. If provided as string, the permissions default to "prop-default".
+    PropertyElement with a string inside. If provided as string, the permissions default to "public".
 
     Args:
         list_name: the name of the list as defined in the onto
@@ -1155,16 +856,16 @@ def make_list_prop(
     Examples:
         >>> excel2xml.make_list_prop("mylist", ":testproperty", "first_node")
                 <list-prop list="mylist" name=":testproperty">
-                    <list permissions="prop-default">first_node</list>
+                    <list permissions="public">first_node</list>
                 </list-prop>
-        >>> excel2xml.make_list_prop("mylist", ":testproperty", excel2xml.PropertyElement("first_node", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_list_prop("mylist", ":testproperty", excel2xml.PropertyElement("first_node", permissions="private", comment="example"))
                 <list-prop list="mylist" name=":testproperty">
-                    <list permissions="prop-restricted" comment="example">first_node</list>
+                    <list permissions="private" comment="example">first_node</list>
                 </list-prop>
         >>> excel2xml.make_list_prop("mylist", ":testproperty", ["first_node", "second_node"])
                 <list-prop list="mylist" name=":testproperty">
-                    <list permissions="prop-default">first_node</list>
-                    <list permissions="prop-default">second_node</list>
+                    <list permissions="public">first_node</list>
+                    <list permissions="public">second_node</list>
                 </list-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#list-prop
@@ -1211,7 +912,7 @@ def make_resptr_prop(
 ) -> etree._Element:
     """
     Make a `<resptr-prop>` from one or more IDs of other resources. The ID(s) can be provided as string or as
-    PropertyElement with a string inside. If provided as string, the permissions default to "prop-default".
+    PropertyElement with a string inside. If provided as string, the permissions default to "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -1227,16 +928,16 @@ def make_resptr_prop(
     Examples:
         >>> excel2xml.make_resptr_prop(":testproperty", "resource_1")
                 <resptr-prop name=":testproperty">
-                    <resptr permissions="prop-default">resource_1</resptr>
+                    <resptr permissions="public">resource_1</resptr>
                 </resptr-prop>
-        >>> excel2xml.make_resptr_prop(":testproperty", excel2xml.PropertyElement("resource_1", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_resptr_prop(":testproperty", excel2xml.PropertyElement("resource_1", permissions="private", comment="example"))
                 <resptr-prop name=":testproperty">
-                    <resptr permissions="prop-restricted" comment="example">resource_1</resptr>
+                    <resptr permissions="private" comment="example">resource_1</resptr>
                 </resptr-prop>
         >>> excel2xml.make_resptr_prop(":testproperty", ["resource_1", "resource_2"])
                 <resptr-prop name=":testproperty">
-                    <resptr permissions="prop-default">resource_1</resptr>
-                    <resptr permissions="prop-default">resource_2</resptr>
+                    <resptr permissions="public">resource_1</resptr>
+                    <resptr permissions="public">resource_2</resptr>
                 </resptr-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#resptr-prop
@@ -1282,7 +983,7 @@ def make_text_prop(
 ) -> etree._Element:
     """
     Make a `<text-prop>` from one or more strings. The string(s) can be provided as string or as PropertyElement with a
-    string inside. If provided as string, the encoding defaults to utf8, and the permissions to "prop-default".
+    string inside. If provided as string, the encoding defaults to utf8, and the permissions to "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -1300,16 +1001,16 @@ def make_text_prop(
     Examples:
         >>> excel2xml.make_text_prop(":testproperty", "first text")
                 <text-prop name=":testproperty">
-                    <text encoding="utf8" permissions="prop-default">first text</text>
+                    <text encoding="utf8" permissions="public">first text</text>
                 </text-prop>
-        >>> excel2xml.make_text_prop(":testproperty", excel2xml.PropertyElement("first text", permissions="prop-restricted", encoding="xml"))
+        >>> excel2xml.make_text_prop(":testproperty", excel2xml.PropertyElement("first text", permissions="private", encoding="xml"))
                 <text-prop name=":testproperty">
-                    <text encoding="xml" permissions="prop-restricted">first text</text>
+                    <text encoding="xml" permissions="private">first text</text>
                 </text-prop>
         >>> excel2xml.make_text_prop(":testproperty", ["first text", "second text"])
                 <text-prop name=":testproperty">
-                    <text encoding="utf8" permissions="prop-default">first text</text>
-                    <text encoding="utf8" permissions="prop-default">second text</text>
+                    <text encoding="utf8" permissions="public">first text</text>
+                    <text encoding="utf8" permissions="public">second text</text>
                 </text-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#text-prop
@@ -1361,7 +1062,6 @@ def make_text_prop(
 def _add_richtext_to_etree_element(richtext: str, element: etree._Element) -> etree._Element:
     new_element = copy.deepcopy(element)
     escaped_text = _escape_reserved_chars(richtext)
-    # transform named entities (=character references) to numeric entities, e.g. &nbsp; -> &#160;
     num_ent = numeric_entities(escaped_text)
     pseudo_xml = f"<ignore-this>{num_ent}</ignore-this>"
     try:
@@ -1436,7 +1136,7 @@ def make_time_prop(
     """
     Make a `<time-prop>` from one or more datetime values of the form "2009-10-10T12:00:00-05:00". The time(s) can be
     provided as string or as PropertyElement with a string inside. If provided as string, the permissions default to
-    "prop-default".
+    "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -1452,22 +1152,22 @@ def make_time_prop(
     Examples:
         >>> excel2xml.make_time_prop(":testproperty", "2009-10-10T12:00:00-05:00")
                 <time-prop name=":testproperty">
-                    <time permissions="prop-default">
+                    <time permissions="public">
                         2009-10-10T12:00:00-05:00
                     </time>
                 </time-prop>
-        >>> excel2xml.make_time_prop(":testproperty", excel2xml.PropertyElement("2009-10-10T12:00:00-05:00", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_time_prop(":testproperty", excel2xml.PropertyElement("2009-10-10T12:00:00-05:00", permissions="private", comment="example"))
                 <time-prop name=":testproperty">
-                    <time permissions="prop-restricted" comment="example">
+                    <time permissions="private" comment="example">
                         2009-10-10T12:00:00-05:00
                     </time>
                 </time-prop>
         >>> excel2xml.make_time_prop(":testproperty", ["2009-10-10T12:00:00-05:00", "1901-01-01T01:00:00-00:00"])
                 <time-prop name=":testproperty">
-                    <time permissions="prop-default">
+                    <time permissions="public">
                         2009-10-10T12:00:00-05:00
                     </time>
-                    <time permissions="prop-default">
+                    <time permissions="public">
                         1901-01-01T01:00:00-00:002
                     </time>
                 </time-prop>
@@ -1516,7 +1216,7 @@ def make_uri_prop(
 ) -> etree._Element:
     """
     Make an `<uri-prop>` from one or more URIs. The URI(s) can be provided as string or as PropertyElement with a string
-    inside. If provided as string, the permissions default to "prop-default".
+    inside. If provided as string, the permissions default to "public".
 
     Args:
         name: the name of this property as defined in the onto
@@ -1532,16 +1232,16 @@ def make_uri_prop(
     Examples:
         >>> excel2xml.make_uri_prop(":testproperty", "www.test.com")
                 <uri-prop name=":testproperty">
-                    <uri permissions="prop-default">www.test.com</uri>
+                    <uri permissions="public">www.test.com</uri>
                 </uri-prop>
-        >>> excel2xml.make_uri_prop(":testproperty", excel2xml.PropertyElement("www.test.com", permissions="prop-restricted", comment="example"))
+        >>> excel2xml.make_uri_prop(":testproperty", excel2xml.PropertyElement("www.test.com", permissions="private", comment="example"))
                 <uri-prop name=":testproperty">
-                    <uri permissions="prop-restricted" comment="example">www.test.com</uri>
+                    <uri permissions="private" comment="example">www.test.com</uri>
                 </uri-prop>
         >>> excel2xml.make_uri_prop(":testproperty", ["www.1.com", "www.2.com"])
                 <uri-prop name=":testproperty">
-                    <uri permissions="prop-default">www.1.com</uri>
-                    <uri permissions="prop-default">www.2.com</uri>
+                    <uri permissions="public">www.1.com</uri>
+                    <uri permissions="public">www.2.com</uri>
                 </uri-prop>
 
     See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#uri-prop
@@ -1583,7 +1283,7 @@ def make_uri_prop(
 def make_region(  # noqa: D417 (undocumented-param)
     label: str,
     id: str,
-    permissions: str = "res-default",
+    permissions: str = "public",
     ark: Optional[str] = None,
     iri: Optional[str] = None,
     creation_date: Optional[str] = None,
@@ -1637,65 +1337,10 @@ def make_region(  # noqa: D417 (undocumented-param)
     )
 
 
-def make_annotation(  # noqa: D417 (undocumented-param)
-    label: str,
-    id: str,
-    permissions: str = "res-default",
-    ark: Optional[str] = None,
-    iri: Optional[str] = None,
-    creation_date: Optional[str] = None,
-) -> etree._Element:
-    """
-    Creates an empty annotation element, with the attributes as specified by the arguments.
-
-    Args:
-        The arguments correspond 1:1 to the attributes of the `<annotation>` element.
-
-    Raises:
-        Warning: if both an ARK and an IRI are provided
-        BaseError: if the creation date is invalid
-
-    Returns:
-        The annotation element, without any children, but with the attributes
-        `<annotation label=label id=id permissions=permissions ark=ark iri=iri></annotation>`
-
-    Examples:
-        >>> annotation = excel2xml.make_annotation("label", "id")
-        >>> annotation.append(excel2xml.make_text_prop("hasComment", "This is a comment"))
-        >>> annotation.append(excel2xml.make_resptr_prop("isAnnotationOf", "resource_0"))
-        >>> root.append(annotation)
-
-    See https://docs.dasch.swiss/latest/DSP-TOOLS/file-formats/xml-data-file/#annotation
-    """
-
-    kwargs = {"label": label, "id": id, "permissions": permissions, "nsmap": xml_namespace_map}
-    if ark:
-        kwargs["ark"] = ark
-    if iri:
-        kwargs["iri"] = iri
-    if ark and iri:
-        warning = f"Both ARK and IRI were provided for resource '{label}' ({id}). The ARK will override the IRI."
-        warnings.warn(DspToolsUserWarning(warning))
-    if creation_date:
-        try:
-            DateTimeStamp(creation_date)
-        except BaseError:
-            raise BaseError(
-                f"The annotation '{label}' (ID: {id}) has an invalid creation date '{creation_date}'. "
-                f"Did you perhaps forget the timezone?"
-            ) from None
-        kwargs["creation_date"] = creation_date
-
-    return etree.Element(
-        "{%s}annotation" % xml_namespace_map[None],
-        **kwargs,  # type: ignore[arg-type]
-    )
-
-
 def make_link(  # noqa: D417 (undocumented-param)
     label: str,
     id: str,
-    permissions: str = "res-default",
+    permissions: str = "public",
     ark: Optional[str] = None,
     iri: Optional[str] = None,
     creation_date: Optional[str] = None,
@@ -1750,7 +1395,7 @@ def make_link(  # noqa: D417 (undocumented-param)
 def make_audio_segment(  # noqa: D417 (undocumented-param)
     label: str,
     id: str,
-    permissions: str = "res-default",
+    permissions: str = "public",
 ) -> etree._Element:
     """
     Creates an empty `<audio-segment>` element, with the attributes as specified by the arguments.
@@ -1782,7 +1427,7 @@ def make_audio_segment(  # noqa: D417 (undocumented-param)
 def make_video_segment(  # noqa: D417 (undocumented-param)
     label: str,
     id: str,
-    permissions: str = "res-default",
+    permissions: str = "public",
 ) -> etree._Element:
     """
     Creates an empty `<video-segment>` element, with the attributes as specified by the arguments.
@@ -1812,14 +1457,14 @@ def make_video_segment(  # noqa: D417 (undocumented-param)
 
 
 def make_isSegmentOf_prop(
-    target_id: str, permissions: str = "prop-default", comment: str | None = None, calling_resource: str = ""
+    target_id: str, permissions: str = "public", comment: str | None = None, calling_resource: str = ""
 ) -> etree._Element:
     """
     Make a `<isSegmentOf>` property for a `<video-segment>` or `<audio-segment>`.
 
     Args:
         target_id: ID of target video/audio resource
-        permissions: defaults to "prop-default".
+        permissions: defaults to "public".
         comment: optional comment for this property. Defaults to None.
         calling_resource: the name of the parent resource (for better error messages)
 
@@ -1849,14 +1494,14 @@ def make_isSegmentOf_prop(
 
 
 def make_relatesTo_prop(
-    target_id: str, permissions: str = "prop-default", comment: str | None = None, calling_resource: str = ""
+    target_id: str, permissions: str = "public", comment: str | None = None, calling_resource: str = ""
 ) -> etree._Element:
     """
     Make a `<relatesTo>` property for a `<video-segment>` or `<audio-segment>`.
 
     Args:
         target_id: ID of the related resource
-        permissions: defaults to "prop-default".
+        permissions: defaults to "public".
         comment: optional comment for this property. Defaults to None.
         calling_resource: the name of the parent resource (for better error messages)
 
@@ -1889,7 +1534,7 @@ def make_relatesTo_prop(
 def make_hasSegmentBounds_prop(
     segment_start: int | float,
     segment_end: int | float,
-    permissions: str = "prop-default",
+    permissions: str = "public",
     comment: str | None = None,
     calling_resource: str = "",
 ) -> etree._Element:
@@ -1899,7 +1544,7 @@ def make_hasSegmentBounds_prop(
     Args:
         segment_start: start, in seconds, counted from the beginning of the audio/video
         segment_end: end, in seconds, counted from the beginning of the audio/video
-        permissions: Defaults to "prop-default".
+        permissions: Defaults to "public".
         comment: Optional comment for this property. Defaults to None.
         calling_resource: the name of the parent resource (for better error messages)
 
@@ -1916,7 +1561,7 @@ def make_hasSegmentBounds_prop(
     Returns:
         an etree._Element that can be appended to an audio/video segment with `segment.append(make_hasSegmentBounds_prop(...))`
     """
-    if not isinstance(segment_start, (int, float)) or not isinstance(segment_end, (int, float)):
+    if not isinstance(segment_start, int | float) or not isinstance(segment_end, int | float):
         try:
             segment_start = float(segment_start)
             segment_end = float(segment_end)
@@ -1927,11 +1572,7 @@ def make_hasSegmentBounds_prop(
                 f"but you provided: {segment_start=} and {segment_end=}"
             )
             warnings.warn(DspToolsUserWarning(msg))
-    if (
-        isinstance(segment_start, (int, float))
-        and isinstance(segment_end, (int, float))
-        and segment_start > segment_end
-    ):
+    if isinstance(segment_start, int | float) and isinstance(segment_end, int | float) and segment_start > segment_end:
         msg = (
             f"Validation Error in resource '{calling_resource}', property 'hasSegmentBounds': "
             f"The start of an audio/video segment must be less than the end, "
@@ -1950,14 +1591,14 @@ def make_hasSegmentBounds_prop(
 
 
 def make_hasTitle_prop(
-    title: str, permissions: str = "prop-default", comment: str | None = None, calling_resource: str = ""
+    title: str, permissions: str = "public", comment: str | None = None, calling_resource: str = ""
 ) -> etree._Element:
     """
     Make a `<hasTitle>` property for a `<video-segment>` or `<audio-segment>`.
 
     Args:
         title: the title of the segment
-        permissions: defaults to "prop-default".
+        permissions: defaults to "public".
         comment: optional comment for this property. Defaults to None.
         calling_resource: the name of the parent resource (for better error messages)
 
@@ -1987,14 +1628,14 @@ def make_hasTitle_prop(
 
 
 def make_hasKeyword_prop(
-    keyword: str, permissions: str = "prop-default", comment: str | None = None, calling_resource: str = ""
+    keyword: str, permissions: str = "public", comment: str | None = None, calling_resource: str = ""
 ) -> etree._Element:
     """
     Make a `<hasKeyword>` property for a `<video-segment>` or `<audio-segment>`.
 
     Args:
         keyword: a keyword of the segment
-        permissions: defaults to "prop-default".
+        permissions: defaults to "public".
         comment: optional comment for this property. Defaults to None.
         calling_resource: the name of the parent resource (for better error messages)
 
@@ -2025,14 +1666,14 @@ def make_hasKeyword_prop(
 
 
 def make_hasComment_prop(
-    comment_text: str, permissions: str = "prop-default", comment: str | None = None, calling_resource: str = ""
+    comment_text: str, permissions: str = "public", comment: str | None = None, calling_resource: str = ""
 ) -> etree._Element:
     """
     Make a `<hasComment>` property for a `<video-segment>` or `<audio-segment>`.
 
     Args:
         comment_text: a text with some background info about the segment. Can be formatted with tags.
-        permissions: defaults to "prop-default".
+        permissions: defaults to "public".
         comment: optional comment for this property. Defaults to None.
         calling_resource: the name of the parent resource (for better error messages)
 
@@ -2063,14 +1704,14 @@ def make_hasComment_prop(
 
 
 def make_hasDescription_prop(
-    description: str, permissions: str = "prop-default", comment: str | None = None, calling_resource: str = ""
+    description: str, permissions: str = "public", comment: str | None = None, calling_resource: str = ""
 ) -> etree._Element:
     """
     Make a `<hasDescription>` property for a `<video-segment>` or `<audio-segment>`.
 
     Args:
         description: a text with some background info about the segment. Can be formatted with tags.
-        permissions: defaults to "prop-default".
+        permissions: defaults to "public".
         comment: optional comment for this property. Defaults to None.
         calling_resource: the name of the parent resource (for better error messages)
 
@@ -2161,7 +1802,7 @@ def create_json_excel_list_mapping(
     excel_values_new = []
     for val in excel_values:
         if isinstance(val, str):
-            excel_values_new.extend([x.strip() for x in val.split(sep) if x])
+            excel_values_new.extend([x.strip() for x in val.split(sep) if x.strip()])
 
     # read the list of the JSON project (works also for nested lists)
     with open(path_to_json, encoding="utf-8") as f:
@@ -2287,6 +1928,11 @@ def write_xml(
     Warning:
         if the XML is not valid according to the schema
     """
+    warn_msg = (
+        "The excel2xml lib is deprecated in favor of the xmllib. It will be removed in a future release.\n"
+        "See the xmllib docs: https://docs.dasch.swiss/latest/DSP-TOOLS/xmllib-docs/xmlroot/"
+    )
+    warnings.warn(DspToolsUserWarning(warn_msg))
     etree.indent(root, space="    ")
     xml_string = etree.tostring(
         root,
@@ -2294,11 +1940,10 @@ def write_xml(
         pretty_print=True,
         doctype='<?xml version="1.0" encoding="UTF-8"?>',
     )
-    xml_string = xml_string.replace(r"\'", "'")
     with open(filepath, "w", encoding="utf-8") as f:
         f.write(xml_string)
     try:
-        validate_xml_file(input_file=filepath)
+        parse_and_validate_xml_file(input_file=filepath)
         print(f"The XML file was successfully saved to {filepath}")
     except BaseError as err:
         msg = (