plastron-utils 4.3.2__tar.gz

plastron_utils-4.3.2/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: plastron-utils
+Version: 4.3.2
+Summary: Utility functions and namespace definitions for Plastron
+Author-email: University of Maryland Libraries <lib-ssdr@umd.edu>, Josh Westgard <westgard@umd.edu>, Peter Eichman <peichman@umd.edu>, Mohamed Abdul Rasheed <mohideen@umd.edu>, Ben Wallberg <wallberg@umd.edu>, David Steelman <dsteelma@umd.edu>, Marc Andreu Grillo Aguilar <aguilarm@umd.edu>
+Project-URL: Homepage, https://github.com/umd-lib/plastron
+Project-URL: Bug Reports, https://github.com/umd-lib/plastron/issues
+Project-URL: Source, https://github.com/umd-lib/plastron
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rdflib
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+
+# plastron-utils
+
+Namespace definitions and other utilities used by Plastron

plastron_utils-4.3.2/README.md

@@ -0,0 +1,3 @@
+# plastron-utils
+
+Namespace definitions and other utilities used by Plastron

plastron_utils-4.3.2/VERSION

@@ -0,0 +1 @@
+4.3.2

plastron_utils-4.3.2/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = 'plastron-utils'
+description = 'Utility functions and namespace definitions for Plastron'
+authors = [
+    { name='University of Maryland Libraries', email='lib-ssdr@umd.edu' },
+    { name='Josh Westgard', email='westgard@umd.edu' },
+    { name='Peter Eichman', email='peichman@umd.edu' },
+    { name='Mohamed Abdul Rasheed', email='mohideen@umd.edu' },
+    { name='Ben Wallberg', email='wallberg@umd.edu' },
+    { name='David Steelman', email='dsteelma@umd.edu' },
+    { name='Marc Andreu Grillo Aguilar', email='aguilarm@umd.edu' },
+]
+readme = "README.md"
+requires-python = '>=3.8'
+dependencies = [
+    "rdflib",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-cov",
+]
+
+[project.urls]
+Homepage = 'https://github.com/umd-lib/plastron'
+'Bug Reports' = 'https://github.com/umd-lib/plastron/issues'
+Source = 'https://github.com/umd-lib/plastron'
+
+[build-system]
+requires = ["setuptools>=66.1.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = { "file" = "VERSION" }

plastron_utils-4.3.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

plastron_utils-4.3.2/src/plastron/namespaces/__init__.py

@@ -0,0 +1,136 @@
+"""Useful namespaces for use with `rdflib` code."""
+
+import sys
+from typing import Optional
+
+from rdflib import Namespace, Graph
+from rdflib.namespace import NamespaceManager
+
+acl = Namespace('http://www.w3.org/ns/auth/acl#')
+"""[Web Access Controls (WebAC)](https://solidproject.org/TR/wac)"""
+
+activitystreams = Namespace('https://www.w3.org/ns/activitystreams#')
+"""[Activity Streams 2.0](https://www.w3.org/TR/activitystreams-core/)"""
+
+bibo = Namespace('http://purl.org/ontology/bibo/')
+"""[Bibliographic Ontology](https://www.dublincore.org/specifications/bibo/bibo/)"""
+
+carriers = Namespace('http://id.loc.gov/vocabulary/carriers/')
+"""[Library of Congress Carriers Schema](https://id.loc.gov/vocabulary/carriers.html)"""
+
+dc = Namespace('http://purl.org/dc/elements/1.1/')
+"""[Dublin Core Elements 1.1](https://www.dublincore.org/specifications/dublin-core/dcmi-terms/#section-3)"""
+
+dcmitype = Namespace('http://purl.org/dc/dcmitype/')
+"""[Dublin Core Type Vocabulary](https://www.dublincore.org/specifications/dublin-core/dcmi-terms/#section-7)"""
+
+dcterms = Namespace('http://purl.org/dc/terms/')
+"""[Dublin Core Terms](https://www.dublincore.org/specifications/dublin-core/dcmi-terms/#section-2)"""
+
+ebucore = Namespace('http://www.ebu.ch/metadata/ontologies/ebucore/ebucore#')
+"""[European Broadcasting Union (EBU) Core](https://www.ebu.ch/metadata/ontologies/ebucore/)"""
+
+edm = Namespace('http://www.europeana.eu/schemas/edm/')
+"""[Europeana Data Model](https://pro.europeana.eu/page/edm-documentation)"""
+
+ex = Namespace('http://www.example.org/terms/')
+"""Example Namespace"""
+
+fabio = Namespace('http://purl.org/spar/fabio/')
+"""[FRBR-aligned Bibliographic Ontology](https://sparontologies.github.io/fabio/current/fabio.html)"""
+
+fedora = Namespace('http://fedora.info/definitions/v4/repository#')
+"""[Fedora Commons Repository Ontology](https://fedora.info/definitions/v4/2016/10/18/repository)"""
+
+foaf = Namespace('http://xmlns.com/foaf/0.1/')
+"""[FOAF ("Friend-of-a-friend") Vocabulary](http://xmlns.com/foaf/0.1/)"""
+
+geo = Namespace('http://www.w3.org/2003/01/geo/wgs84_pos#')
+"""[WGS84 Geo Positioning](https://www.w3.org/2003/01/geo/wgs84_pos)"""
+
+iana = Namespace('http://www.iana.org/assignments/relation/')
+"""IANA Link Relations"""
+
+ldp = Namespace('http://www.w3.org/ns/ldp#')
+"""[Linked Data Platform](https://www.w3.org/TR/ldp/)"""
+
+ndnp = Namespace('http://chroniclingamerica.loc.gov/terms/')
+"""[National Digital Newspaper Program (NDNP) Vocabulary](https://chroniclingamerica.loc.gov/terms/)
+
+**Note:** This namespace is actually incorrect; it should end with "#" and not "/". Unfortunately,
+correction would require modification of many resources in fcrepo."""
+
+oa = Namespace('http://www.w3.org/ns/oa#')
+"""[Web Annotations](https://www.w3.org/TR/annotation-vocab/)"""
+
+ore = Namespace('http://www.openarchives.org/ore/terms/')
+"""[OAI Object Reuse and Exchange (ORE)](http://openarchives.org/ore/1.0/vocabulary)"""
+
+owl = Namespace('http://www.w3.org/2002/07/owl#')
+"""[Web Ontology Language (OWL)](https://www.w3.org/TR/owl2-syntax/)"""
+
+pcdm = Namespace('http://pcdm.org/models#')
+"""[Portland Common Data Model (PCDM)](https://pcdm.org/2016/04/18/models)"""
+
+pcdmuse = Namespace('http://pcdm.org/use#')
+"""[PCDM Use Extension](https://pcdm.org/2021/04/09/use)"""
+
+premis = Namespace('http://www.loc.gov/premis/rdf/v1#')
+"""[Preservation Metadata: Implementation Strategies (PREMIS)](https://id.loc.gov/ontologies/premis-1-0-0.html)"""
+
+prov = Namespace('http://www.w3.org/ns/prov#')
+"""[Provenance Ontology (PROV-O)](https://www.w3.org/TR/prov-o/)"""
+
+rdf = Namespace('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
+"""[RDF](https://www.w3.org/TR/rdf11-schema/)"""
+
+rdfs = Namespace('http://www.w3.org/2000/01/rdf-schema#')
+"""[RDF Schema](https://www.w3.org/TR/rdf11-schema/)"""
+
+rel = Namespace('http://id.loc.gov/vocabulary/relators/')
+"""[Library of Congress Relator Terms](https://id.loc.gov/vocabulary/relators.html)"""
+
+sc = Namespace('http://www.shared-canvas.org/ns/')
+"""[Shared Canvas Data Model](https://iiif.io/api/model/shared-canvas/1.0/)"""
+
+schema = Namespace('https://schema.org/')
+"""[Schema.org](https://schema.org/)"""
+
+skos = Namespace('http://www.w3.org/2004/02/skos/core#')
+"""[Simple Knowledge Organization System (SKOS)](https://www.w3.org/TR/skos-reference/)"""
+
+umd = Namespace('http://vocab.lib.umd.edu/model#')
+"""[UMD Content Models Vocabulary](http://vocab.lib.umd.edu/model)"""
+
+umdaccess = Namespace('http://vocab.lib.umd.edu/access#')
+"""[UMD Access Classes Vocabulary](http://vocab.lib.umd.edu/access)"""
+
+umdform = Namespace('http://vocab.lib.umd.edu/form#')
+"""[UMD Genre/Form Vocabulary](http://vocab.lib.umd.edu/form)"""
+
+umdtype = Namespace('http://vocab.lib.umd.edu/datatype#')
+"""[UMD Datatypes Vocabulary](http://vocab.lib.umd.edu/datatype)"""
+
+umdact = Namespace('http://vocab.lib.umd.edu/activity#')
+"""[UMD Activity Types Vocabulary](http://vocab.lib.umd.edu/activity)"""
+
+webac = Namespace('http://fedora.info/definitions/v4/webac#')
+"""[Fedora Commons WebAC Ontology](https://fedora.info/definitions/v4/2015/09/03/webac)"""
+
+xsd = Namespace('http://www.w3.org/2001/XMLSchema#')
+"""[XML Schema Datatypes](https://www.w3.org/TR/xmlschema-2/#built-in-datatypes)"""
+
+
+def get_manager(graph: Optional[Graph] = None) -> NamespaceManager:
+    """Scan this module's attributes for `Namespace` objects, and bind them
+    to a prefix corresponding to their attribute name defined above."""
+    if graph is None:
+        graph = Graph()
+    nsm = NamespaceManager(graph)
+    prefixes = {attr: value for attr, value in sys.modules[__name__].__dict__.items() if isinstance(value, Namespace)}
+    for prefix, ns in prefixes.items():
+        nsm.bind(prefix, ns)
+    return nsm
+
+
+namespace_manager = get_manager()

plastron_utils-4.3.2/src/plastron/utils/__init__.py

@@ -0,0 +1,291 @@
+import collections.abc
+import csv
+import logging
+import os
+import platform
+import re
+from abc import ABC
+from argparse import ArgumentTypeError
+from datetime import datetime
+from pathlib import Path
+from typing import Union, Mapping, Sequence, Optional, List
+
+from rdflib import URIRef
+from rdflib.term import Node
+from rdflib.util import from_n3
+
+from plastron import namespaces
+
+DEFAULT_LOGGING_OPTIONS = {
+    'version': 1,
+    'formatters': {
+        'full': {
+            'format': '%(levelname)s|%(asctime)s|%(threadName)s|%(name)s|%(message)s'
+        },
+        'messageonly': {
+            'format': '%(message)s'
+        }
+    },
+    'handlers': {
+        'console': {
+            'class': 'logging.StreamHandler',
+            'level': 'INFO',
+            'formatter': 'messageonly',
+            'stream': 'ext://sys.stderr'
+        },
+        'file': {
+            'class': 'logging.FileHandler',
+            'level': 'DEBUG',
+            'formatter': 'full'
+        }
+    },
+    'loggers': {
+        '__main__': {
+            'level': 'DEBUG',
+            'handlers': ['console', 'file'],
+            'propagate': False
+        },
+        'plastron': {
+            'level': 'DEBUG',
+            'handlers': ['console', 'file'],
+            'propagate': False
+        },
+        # suppress logging output from paramiko by default
+        'paramiko': {
+            'propagate': False
+        }
+    },
+    'root': {
+        'level': 'DEBUG'
+    }
+}
+logger = logging.getLogger(__name__)
+
+
+def datetimestamp(digits_only: bool = True) -> str:
+    """Returns a string containing the current UTC timestamp. By default, it
+    is only digits (`20231117151827` vs. `2023-11-17T15:18:27`). If you want
+    the full ISO 8601 representation, set `digits_only` to `True`.
+
+    ```pycon
+    >>> datetimestamp()
+    '20231117152014'
+
+    >>> datetimestamp(digits_only=False)
+    '2023-11-17T15:20:57'
+    ```
+    """
+    now = str(datetime.utcnow().isoformat(timespec='seconds'))
+    if digits_only:
+        return re.sub(r'[^0-9]', '', now)
+    else:
+        return now
+
+
+def envsubst(value: Union[str, list, dict], env: Mapping[str, str] = None) -> Union[str, list, dict]:
+    """
+    Recursively replace `${VAR_NAME}` placeholders in value with the values of the
+    corresponding keys of env. If env is not given, it defaults to the environment
+    variables in os.environ.
+
+    Any placeholders that do not have a corresponding key in the env dictionary
+    are left as is.
+
+    :param value: String, list, or dictionary to search for `${VAR_NAME}` placeholders.
+    :param env: Dictionary of values to use as replacements. If not given, defaults
+        to `os.environ`.
+    :return: If `value` is a string, returns the result of replacing `${VAR_NAME}` with the
+        corresponding `value` from env. If `value` is a list, returns a new list where each
+        item in `value` replaced with the result of calling `envsubst()` on that item. If
+        `value` is a dictionary, returns a new dictionary where each item in `value` is replaced
+        with the result of calling `envsubst()` on that item.
+    """
+    if env is None:
+        env = os.environ
+    if isinstance(value, str):
+        if '${' in value:
+            try:
+                return value.replace('${', '{').format(**env)
+            except KeyError as e:
+                missing_key = str(e.args[0])
+                logger.warning(f'Environment variable ${{{missing_key}}} not found')
+                # for a missing key, just return the string without substitution
+                return envsubst(value, {missing_key: f'${{{missing_key}}}', **env})
+        else:
+            return value
+    elif isinstance(value, list):
+        return [envsubst(v, env) for v in value]
+    elif isinstance(value, dict):
+        return {k: envsubst(v, env) for k, v in value.items()}
+    else:
+        return value
+
+
+def check_python_version():
+    # check Python version
+    major, minor, patch = (int(v) for v in platform.python_version_tuple())
+    if minor < 8:
+        logger.warning(
+            f'You appear to be running Python {platform.python_version()}. '
+            'Upgrading to Python 3.8+ is STRONGLY recommended.'
+        )
+
+
+def strtobool(val: str) -> int:
+    """Convert a string representation of truth to true (1) or false (0).
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+
+    This implementation is copied from distutils/util.py in Python 3.10.4,
+    in order to retain this functionality once distutils is removed in
+    Python 3.12. See also https://peps.python.org/pep-0632/#migration-advice
+    and https://docs.python.org/3.10/whatsnew/3.10.html#distutils-deprecated.
+
+    Note that even though this function is named `strtobool`, it actually
+    returns an integer. This is copied directly from the distutils module.
+    """
+    val = val.lower()
+    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+        return 1
+    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+        return 0
+    else:
+        raise ValueError("invalid truth value %r" % (val,))
+
+
+class AppendableSequence(collections.abc.Sequence, ABC):
+    """Abstract base class for appendable sequences"""
+    def append(self, _value):
+        raise NotImplementedError
+
+
+class NullLog(AppendableSequence):
+    """Stub replacement for `ItemLog` that simply discards logged items
+    and returns `False` for any containment checks."""
+    def __len__(self) -> int:
+        return 0
+
+    def __getitem__(self, item):
+        raise IndexError
+
+    def __contains__(self, item):
+        return False
+
+    def append(self, _value):
+        """This class just discards the given value"""
+        pass
+
+
+class ItemLog(AppendableSequence):
+    """Log backed by a CSV file that is used to record item information,
+    keyed by a particular column, with the ability to check whether a
+    given key exists in the log already.
+
+    `ItemLog` objects are iterable, and support direct indexing to a row
+    by key.
+    """
+    def __init__(self, filename: Union[str, Path], fieldnames: Sequence[str], keyfield: str, header: bool = True):
+        self.filename: Path = Path(filename)
+        self.fieldnames: Sequence[str] = fieldnames
+        self.keyfield: str = keyfield
+        self.write_header: bool = header
+        self._item_keys = set()
+        self._fh = None
+        self._writer = None
+        if self.exists():
+            self._load_keys()
+
+    def exists(self) -> bool:
+        """Returns `True` if the CSV log file exists."""
+        return self.filename.is_file()
+
+    def create(self):
+        """Create the CSV log file. This will overwrite an existing file. If
+        `write_header` is `True`, it will also write a header row to the file."""
+        with self.filename.open(mode='w', buffering=1) as fh:
+            writer = csv.DictWriter(fh, fieldnames=self.fieldnames)
+            if self.write_header:
+                writer.writeheader()
+
+    def _load_keys(self):
+        for row in iter(self):
+            self._item_keys.add(row[self.keyfield])
+
+    def __iter__(self):
+        try:
+            with self.filename.open(mode='r', buffering=1) as fh:
+                reader = csv.DictReader(fh)
+                # check the validity of the map file data
+                if not reader.fieldnames == self.fieldnames:
+                    logger.warning(
+                        f'Fieldnames in {self.filename} do not match expected fieldnames; '
+                        f'expected: {self.fieldnames}; found: {reader.fieldnames}'
+                    )
+                # read the data from the existing file
+                yield from reader
+        except FileNotFoundError:
+            # log file not found, so stop the iteration
+            return
+
+    @property
+    def writer(self) -> csv.DictWriter:
+        """CSV dictionary writer"""
+        if not self.exists():
+            self.create()
+        if self._fh is None:
+            self._fh = self.filename.open(mode='a', buffering=1)
+        if self._writer is None:
+            self._writer = csv.DictWriter(self._fh, fieldnames=self.fieldnames)
+        return self._writer
+
+    def append(self, row):
+        """Write this `row` to the log."""
+        self.writer.writerow(row)
+        self._item_keys.add(row[self.keyfield])
+
+    def writerow(self, row):
+        """Alias for `append`"""
+        self.append(row)
+
+    def __contains__(self, other):
+        return other in self._item_keys
+
+    def __len__(self):
+        return len(self._item_keys)
+
+    def __getitem__(self, item):
+        for n, row in enumerate(self):
+            if n == item:
+                return row
+        raise IndexError(item)
+
+
+class ItemLogError(Exception):
+    pass
+
+
+def uri_or_curie(arg: str) -> URIRef:
+    """Convert a string to a URIRef. If it begins with either `http://`
+    or `https://`, treat it as an absolute HTTP URI. Otherwise, try to
+    parse it as a CURIE (e.g., "dcterms:title") and return the expanded
+    URI. If the prefix is not recognized, or if `from_n3()` returns anything
+    but a URIRef, raises `ArgumentTypeError`."""
+    if arg and (arg.startswith('http://') or arg.startswith('https://')):
+        # looks like an absolute HTTP URI
+        return URIRef(arg)
+    try:
+        term = from_n3(arg, nsm=namespaces.get_manager())
+    except KeyError:
+        raise ArgumentTypeError(f'"{arg[:arg.index(":") + 1]}" is not a known prefix')
+    if not isinstance(term, URIRef):
+        raise ArgumentTypeError(f'"{arg}" must be a URI or CURIE')
+    return term
+
+
+def parse_predicate_list(string: str, delimiter: str = ',') -> Optional[List[Node]]:
+    if string is None:
+        return None
+    manager = namespaces.get_manager()
+    return [from_n3(p, nsm=manager) for p in string.split(delimiter)]

plastron_utils-4.3.2/src/plastron_utils.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: plastron-utils
+Version: 4.3.2
+Summary: Utility functions and namespace definitions for Plastron
+Author-email: University of Maryland Libraries <lib-ssdr@umd.edu>, Josh Westgard <westgard@umd.edu>, Peter Eichman <peichman@umd.edu>, Mohamed Abdul Rasheed <mohideen@umd.edu>, Ben Wallberg <wallberg@umd.edu>, David Steelman <dsteelma@umd.edu>, Marc Andreu Grillo Aguilar <aguilarm@umd.edu>
+Project-URL: Homepage, https://github.com/umd-lib/plastron
+Project-URL: Bug Reports, https://github.com/umd-lib/plastron/issues
+Project-URL: Source, https://github.com/umd-lib/plastron
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rdflib
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+
+# plastron-utils
+
+Namespace definitions and other utilities used by Plastron

plastron_utils-4.3.2/src/plastron_utils.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+VERSION
+pyproject.toml
+../VERSION
+src/plastron/namespaces/__init__.py
+src/plastron/utils/__init__.py
+src/plastron_utils.egg-info/PKG-INFO
+src/plastron_utils.egg-info/SOURCES.txt
+src/plastron_utils.egg-info/dependency_links.txt
+src/plastron_utils.egg-info/requires.txt
+src/plastron_utils.egg-info/top_level.txt
+tests/test_envsubst.py
+tests/test_util.py

plastron_utils-4.3.2/src/plastron_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

plastron_utils-4.3.2/src/plastron_utils.egg-info/requires.txt

@@ -0,0 +1,5 @@
+rdflib
+
+[test]
+pytest
+pytest-cov

plastron_utils-4.3.2/src/plastron_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+plastron

plastron_utils-4.3.2/tests/test_envsubst.py

@@ -0,0 +1,28 @@
+from plastron.utils import envsubst
+
+
+def test_simple_strings():
+    env = {'FOO': 'a', 'BAR': 'z'}
+    assert envsubst('${FOO}bc', env) == 'abc'
+    assert envsubst('${FOO}bc${BAR}yx', env) == 'abczyx'
+
+
+def test_unknown_variable_name():
+    assert envsubst('${FOO}qrs', {}) == '${FOO}qrs'
+
+
+def test_lists():
+    env = {'FOO': 'a', 'BAR': 'z'}
+    assert envsubst(['${FOO}', '${BAR}'], env) == ['a', 'z']
+    assert envsubst(['${FOO}', '${BAR}', '${BAZ}'], env) == ['a', 'z', '${BAZ}']
+
+
+def test_dicts():
+    env = {'FOO': 'a', 'BAR': 'z'}
+    assert envsubst({'foo': '${FOO}', 'bar': '${BAR}'}, env) == {'foo': 'a', 'bar': 'z'}
+    assert envsubst({'foo': '${FOO}', 'bar': '${BAZ}'}, env) == {'foo': 'a', 'bar': '${BAZ}'}
+
+
+def test_deep_structure():
+    env = {'FOO': 'a'}
+    assert envsubst([{'foo': ['${FOO}']}], env) == [{'foo': ['a']}]

plastron_utils-4.3.2/tests/test_util.py

@@ -0,0 +1,87 @@
+import pytest
+
+from argparse import ArgumentParser, ArgumentTypeError
+
+from plastron.namespaces import dcterms, rdf, pcdm
+from plastron.cli import parse_data_property, parse_object_property
+from plastron.utils import uri_or_curie
+from rdflib.term import URIRef, Literal
+
+INVALID_URI_OR_CURIE_ARGS = [
+    # None
+    None,
+    # empty string
+    '',
+    # unrecognized namespace
+    'not_in_namespace:Foo'
+]
+VALID_URI_OR_CURIE_ARGS = [
+    # CURIE
+    'umdaccess:Public',
+    # N3-formatted URI
+    '<http://vocab.lib.umd.edu/access#Public>',
+    # plain string HTTP URI
+    'http://vocab.lib.umd.edu/access#Public'
+]
+EXPECTED_TERM = URIRef('http://vocab.lib.umd.edu/access#Public')
+
+
+# Tests for the "uri_or_curie" function
+
+@pytest.mark.parametrize(
+    'arg_value', INVALID_URI_OR_CURIE_ARGS
+)
+def test_given_invalid_uri_or_curie__raises_error(arg_value):
+    with pytest.raises(ArgumentTypeError):
+        uri_or_curie(arg_value)
+
+
+@pytest.mark.parametrize(
+    'arg_value', VALID_URI_OR_CURIE_ARGS
+)
+def test_given_valid_uri_or_curie__returns_term(arg_value):
+    assert uri_or_curie(arg_value) == EXPECTED_TERM
+
+
+@pytest.mark.parametrize(
+    'arg_value', VALID_URI_OR_CURIE_ARGS
+)
+def test_given_valid_uri_or_curie_type__parse_args_returns_uriref(arg_value):
+    parser = ArgumentParser()
+    parser.add_argument('--access', type=uri_or_curie)
+    args = parser.parse_args(('--access', arg_value))
+    assert isinstance(args.access, URIRef)
+    assert args.access == EXPECTED_TERM
+
+
+@pytest.mark.parametrize(
+    'arg_value', INVALID_URI_OR_CURIE_ARGS
+)
+def test_given_invalid_uri_or_curie_type__parse_args_exits(arg_value):
+    parser = ArgumentParser()
+    parser.add_argument('--access', type=uri_or_curie)
+    with pytest.raises(SystemExit):
+        parser.parse_args(('--access', arg_value))
+
+
+@pytest.mark.parametrize(
+    ('p', 'o', 'expected'),
+    [
+        ('dcterms:title', 'Foobar', (dcterms.title, Literal('Foobar'))),
+        ('dcterms:title', '"der Hund"@de', (dcterms.title, Literal('der Hund', lang='de')))
+    ]
+)
+def test_parse_data_property(p, o, expected):
+    assert parse_data_property(p, o) == expected
+
+
+@pytest.mark.parametrize(
+    ('p', 'o', 'expected'),
+    [
+        ('rdf:type', 'pcdm:Object', (rdf.type, pcdm.Object)),
+        ('dcterms:creator', 'https://www.lib.umd.edu/', (dcterms.creator, URIRef('https://www.lib.umd.edu/'))),
+        ('dcterms:creator', '<https://www.lib.umd.edu/>', (dcterms.creator, URIRef('https://www.lib.umd.edu/')))
+    ]
+)
+def test_parse_object_property(p, o, expected):
+    assert parse_object_property(p, o) == expected