oldap-tools 0.1.4__py3-none-any.whl

oldap_tools/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

oldap_tools/cli.py

@@ -0,0 +1,114 @@
+from pathlib import Path
+
+import typer
+from importlib.metadata import version
+
+from oldap_tools.dump_list import dump_list
+from oldap_tools.config import AppConfig
+from oldap_tools.dump_project import dump_project
+from oldap_tools.load_list import load_list
+from oldap_tools.load_project import load_project
+
+from oldap_tools.logging import setup_logging
+
+app = typer.Typer(
+    no_args_is_help=True,
+    help="OLDAP command line tools"
+)
+
+@app.callback()
+def app_callback(ctx: typer.Context,
+                 verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose (debug) logging"),
+                 graphdb_base: str = typer.Option("http://localhost:7200", "--graphdb", "-g", help="GraphDB base URL"),
+                 repo: str = typer.Option("oldap", "--repo", "-r", help="GraphDB repository"),
+                 user: str = typer.Option(..., "--user", "-u", help="OLDAP user"),
+                 password: str = typer.Option(..., "--password", "-p", help="OLDAP password", hide_input=True),
+                 graphdb_user: str = typer.Option(None, "--graphdb_user", envvar="GRAPHDB_USER", help="GraphDB user"),
+                 graphdb_password: str = typer.Option(None, "--graphdb_password", envvar="GRAPHDB_PASSWORD", help="GraphDB password", hide_input=True)
+                 ):
+    setup_logging(verbose)
+    ctx.obj = AppConfig(
+        graphdb_base=graphdb_base,
+        repo=repo,
+        user=user,
+        password=password,
+        graphdb_user=graphdb_user,
+        graphdb_password=graphdb_password
+    )
+
+@app.command()
+def show_version():
+    """Show version information."""
+    typer.echo(version("oldap-tools"))
+
+project = typer.Typer(help="Project-related commands")
+app.add_typer(project, name="project")
+
+@project.command("dump")
+def project_dump(
+        ctx: typer.Context,
+        project_id: str = typer.Argument(..., help="Project ID (e.g. swissbritnet, hyha, ...)"),
+        out: Path = typer.Option(Path("<project>.trig.gz"), "--out", "-o", help="Output dump file"),
+        include_data: bool = typer.Option(True, "--data/--no-data", help="Include '<project>:data' graph"),
+):
+    """Export project data."""
+    if out == Path("<project>.trig.gz"):
+        out = Path(project_id).with_suffix(".trig.gz")
+    typer.echo(f"Exporting '{project_id}' data to {out}")
+    cfg = ctx.obj
+    dump_project(project_id=project_id,
+                 graphdb_base=cfg.graphdb_base,
+                 repo=cfg.repo,
+                 out=out,
+                 include_data=include_data,
+                 user=cfg.user,
+                 password=cfg.password,
+                 graphdb_user=cfg.graphdb_user,
+                 graphdb_password=cfg.graphdb_password)
+
+@project.command("load")
+def project_load(ctx: typer.Context,
+                 inf: Path = typer.Option(Path("dump.trig.gz"), "--inf", "-i", help="Input file for load")):
+    cfg = ctx.obj
+    load_project(graphdb_base=cfg.graphdb_base,
+                 repo=cfg.repo,
+                 inf=inf,
+                 user=cfg.user,
+                 password=cfg.password,
+                 graphdb_user=cfg.graphdb_user,
+                 graphdb_password=cfg.graphdb_password)
+
+lists = typer.Typer(help="List-related commands")
+app.add_typer(lists, name="lists")
+
+@lists.command("dump", help="Dump all list data to a YAML file.")
+def list_dump(ctx: typer.Context,
+              project_id: str = typer.Argument(..., help="Project ID (e.g. swissbritnet, hyha, ...)"),
+              list_id: str = typer.Argument(..., help="List ID (e.g. 'CreativeCommons', 'BuildingCategories', ...)"),
+              out: Path = typer.Option(Path("dump.trig"), "--out", "-o", help="Output dump file")):
+    cfg = ctx.obj
+    dump_list(project_id=project_id,
+              list_id=list_id,
+              graphdb_base=cfg.graphdb_base,
+              repo=cfg.repo,
+              filepath=out,
+              user=cfg.user,
+              password=cfg.password,
+              graphdb_user = cfg.graphdb_user,
+              graphdb_password = cfg.graphdb_password
+    )
+
+@lists.command("load", help="Load project data from a JSON/YAML file.")
+def list_load(ctx: typer.Context,
+              project_id: str = typer.Argument(..., help="Project ID (e.g. swissbritnet, hyha, ...)"),
+              inf: Path = typer.Option(Path("dump.trig.gz"), "--inf", "-i", help="Input file for load")):
+    cfg = ctx.obj
+    load_list(project_id=project_id,
+              graphdb_base=cfg.graphdb_base,
+              repo=cfg.repo,
+              filepath=inf,
+              user=cfg.user,
+              password=cfg.password)
+
+def main():
+    app()

oldap_tools/config.py

@@ -0,0 +1,11 @@
+# src/oldap_tools/config.py
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class AppConfig:
+    graphdb_base: str
+    repo: str
+    user: str | None = None
+    password: str | None = None
+    graphdb_user: str | None = None
+    graphdb_password: str | None = None

oldap_tools/dump_list.py

@@ -0,0 +1,43 @@
+import logging
+from pathlib import Path
+
+import typer
+from oldaplib.src.connection import Connection
+from oldaplib.src.helpers.oldaperror import OldapError
+from oldaplib.src.oldaplist_helpers import ListFormat, dump_list_to
+from oldaplib.src.project import Project
+
+log = logging.getLogger(__name__)
+
+def dump_list(project_id: str,
+              list_id: str,
+              graphdb_base: str,
+              repo: str,
+              filepath: Path,
+              user: str,
+              password: str,
+              graphdb_user: str | None = None,
+              graphdb_password: str | None = None
+              ):
+    try:
+        con = Connection(server=graphdb_base,
+                         repo=repo,
+                         dbuser=graphdb_user,
+                         dbpassword=graphdb_password,
+                         userId=user,
+                         credentials=password,
+                         context_name="DEFAULT")
+        yamlfile = dump_list_to(con=con,
+                                project=project_id,
+                                oldapListId=list_id,
+                                listformat=ListFormat.YAML,
+                                ignore_cache=False)
+    except OldapError as error:
+        log.error(f"ERROR: Failed to connect to GraphDB database at '{graphdb_base}': {error}")
+        raise typer.Exit(code=1)
+    except FileNotFoundError as error:
+        log.error(f"ERROR: File {filepath} not found': {error}")
+        raise typer.Exit(code=1)
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(yamlfile)

oldap_tools/dump_project.py

@@ -0,0 +1,127 @@
+import gzip
+import json
+from datetime import datetime
+from pathlib import Path
+
+import requests
+import typer
+import logging
+
+from oldaplib.src.connection import Connection
+from oldaplib.src.helpers.context import Context
+from oldaplib.src.helpers.oldaperror import OldapError
+from oldaplib.src.helpers.serializer import serializer
+from oldaplib.src.role import Role
+from oldaplib.src.project import Project
+from oldaplib.src.user import User
+from oldaplib.src.xsd.xsd_qname import Xsd_QName
+from rdflib import Dataset
+
+log = logging.getLogger(__name__)
+
+def export_graphs_as_trig(
+    graphdb_base: str,      # e.g. "http://localhost:7200"
+    repo: str,              # e.g. "oldap"
+    graph_iris: list[str],  # the 4 graphs you want
+    auth: tuple[str, str] | None = None,
+    timeout: int = 120,
+) -> str:
+    ds = Dataset()
+
+    for g in graph_iris:
+        # RDF4J "statements" endpoint; context must be given as <IRI>
+        url = f"{graphdb_base.rstrip('/')}/repositories/{repo}/statements"
+        params = {"context": f"<{g}>"}
+        r = requests.get(
+            url,
+            params=params,
+            headers={"Accept": "application/n-quads"},
+            auth=auth,
+            timeout=timeout,
+        )
+        if r.status_code != 200:
+            log.error(f"ERROR: Request to '{url}' failed with status code {r.status_code}")
+            raise typer.Exit(code=1)
+
+        # N-Quads keeps the graph/context in each statement -> perfect for Dataset
+        ds.parse(data=r.text, format="nquads")
+
+    trig = ds.serialize(format="trig")
+    return trig.decode("utf-8") if isinstance(trig, bytes) else trig
+
+
+def dump_project(project_id: str,
+                 graphdb_base: str,
+                 repo: str,
+                 out: Path,
+                 include_data: bool,
+                 user: str,
+                 password: str,
+                 graphdb_user: str | None = None,
+                 graphdb_password: str | None = None):
+    try:
+        con = Connection(server=graphdb_base,
+                         repo = repo,
+                         dbuser=graphdb_user,
+                         dbpassword=graphdb_password,
+                         userId=user,
+                         credentials=password)
+    except OldapError as e:
+        log.error(f"ERROR: Failed to connect to GraphDB database at '{graphdb_base}': {e}")
+        raise typer.Exit(code=1)
+
+    try:
+        project = Project.read(con=con, projectIri_SName=project_id)
+    except OldapError as e:
+        log.error(f"ERROR: Failed to connect to read project '{project_id}': {e}")
+        raise typer.Exit(code=1)
+
+    trig = "################################################################################\n"
+    trig += f"# Project: {project.projectShortName}\n"
+    trig += f"# Date: {datetime.now().isoformat()}\n"
+    trig += "################################################################################\n"
+    trig += "\n#\n# User info\n#\n"
+    userIris = User.search(con=con, inProject=project.projectIri)
+    for userIri in userIris:
+        user = User.read(con=con, userId=str(userIri))
+        user_json = json.dumps(user, default=serializer.encoder_default)
+        trig += "#>> " + user_json + "\n"
+    trig += "#<<\n\n"
+
+    context = Context(name=con.context_name)
+    trig += context.turtle_context
+    trig += "#\n# Load the oldap:admin part\n#\n"
+    trig += "oldap:admin {"
+
+    trig += "\n#\n# Project info\n#\n"
+    trig += project.trig_to_str(created=project.created, modified=project.modified, indent=1)
+    trig += " .\n\n"
+
+    trig += "\n#\n# Roles info\n#\n"
+    roleQNames = Role.search(con=con, definedByProject=project.projectIri)
+    for roleQName in roleQNames:
+        role = Role.read(con=con, qname=roleQName)
+        trig += role.trig_to_str(created=role.created, modified=role.modified, indent=1)
+        trig += " .\n\n"
+
+    trig += "\n}\n\n"
+
+    project_graphs = [
+        str(context.qname2iri(Xsd_QName(project.projectShortName, "shacl"))),
+        str(context.qname2iri(Xsd_QName(project.projectShortName, "onto"))),
+        str(context.qname2iri(Xsd_QName(project.projectShortName, "lists"))),
+    ]
+    if include_data:
+        project_graphs.append(str(context.qname2iri(Xsd_QName(project.projectShortName, "data"))))
+
+    trig += export_graphs_as_trig(
+        graphdb_base="http://localhost:7200",
+        repo="oldap",
+        graph_iris=project_graphs,
+        auth=None,  # or None
+    )
+
+    with gzip.open(out, "wt", encoding="utf-8", newline="") as f:
+        f.write(trig)
+
+

oldap_tools/load_list.py

@@ -0,0 +1,39 @@
+import logging
+from pathlib import Path
+
+import typer
+from oldaplib.src.connection import Connection
+from oldaplib.src.helpers.oldaperror import OldapError
+from oldaplib.src.oldaplist_helpers import load_list_from_yaml
+from oldaplib.src.project import Project
+
+log = logging.getLogger(__name__)
+
+def load_list(project_id: str,
+              graphdb_base: str,
+              repo: str,
+              filepath: Path,
+              user: str,
+              password: str,
+              graphdb_user: str | None = None,
+              graphdb_password: str | None = None):
+
+    try:
+        connection = Connection(server=graphdb_base,
+                                repo=repo,
+                                dbuser=graphdb_user,
+                                dbpassword=graphdb_password,
+                                userId=user,
+                                credentials=password,
+                                context_name="DEFAULT")
+        project = Project.read(connection, project_id)
+        listnodes = load_list_from_yaml(con=connection,
+                                        project=project_id,
+                                        filepath=filepath)
+    except OldapError as error:
+        log.error(f"ERROR: Failed to connect to GraphDB database at '{graphdb_base}': {error}")
+        raise typer.Exit(code=1)
+    except FileNotFoundError as error:
+        log.error(f"ERROR: File {filepath} not found': {error}")
+        raise typer.Exit(code=1)
+

oldap_tools/load_project.py

@@ -0,0 +1,110 @@
+import gzip
+import json
+import logging
+from pathlib import Path
+
+import requests
+import typer
+from oldaplib.src.cachesingleton import CacheSingletonRedis
+from oldaplib.src.connection import Connection
+from oldaplib.src.helpers.oldaperror import OldapErrorAlreadyExists, OldapError, OldapErrorNotFound
+from oldaplib.src.helpers.serializer import serializer
+from oldaplib.src.user import User
+
+log = logging.getLogger(__name__)
+
+def import_trig(
+    graphdb_base: str,
+    repo: str,
+    trig_str: str,
+    auth: tuple[str, str] | None = None,
+    timeout: int = 120,
+):
+    url = f"{graphdb_base.rstrip('/')}/repositories/{repo}/statements"
+    r = requests.post(
+        url,
+        data=trig_str.encode("utf-8"),
+        headers={"Content-Type": "application/trig"},
+        auth=auth,
+        timeout=timeout,
+    )
+    if r.status_code != 200:
+        log.error(f"ERROR: Request to '{url}' failed with status code {r.status_code}")
+        raise typer.Exit(code=1)
+
+
+def import_trig_gz(
+    graphdb_base: str,
+    repo: str,
+    trig_gz: bytes,
+    auth: tuple[str, str] | None = None,
+    timeout: int = 120,
+):
+    url = f"{graphdb_base.rstrip('/')}/repositories/{repo}/statements"
+    r = requests.post(
+        url,
+        data=trig_gz,
+        headers={
+            "Content-Type": "application/trig",
+            "Content-Encoding": "gzip",
+        },
+        auth=auth,
+        timeout=timeout,
+    )
+    if r.status_code < 200 or r.status_code >= 300:
+        log.error(f"ERROR: Request to '{url}' failed with status code {r.status_code}")
+        raise typer.Exit(code=1)
+
+
+def load_project(graphdb_base: str,
+                 repo: str,
+                 inf: Path,
+                 user: str,
+                 password: str,
+                 graphdb_user: str | None = None,
+                 graphdb_password: str | None = None) -> None:
+    cache = CacheSingletonRedis()
+    cache.clear()
+
+    with open(inf, "rb") as f:
+        import_trig_gz(graphdb_base=graphdb_base,
+                       repo=repo,
+                       auth=(graphdb_user, graphdb_password) if graphdb_user and graphdb_password else None,
+                       trig_gz=f.read())
+
+    try:
+        con = Connection(server=graphdb_base,
+                         repo=repo,
+                         dbuser=graphdb_user,
+                         dbpassword=graphdb_password,
+                         userId=user,
+                         credentials=password)
+    except OldapError as e:
+        log.error(f"ERROR: Failed to connect to GraphDB database at '{graphdb_base}': {e}")
+        raise typer.Exit(code=1)
+
+    with gzip.open(inf, "rt", encoding="utf-8") as f:
+        for line in f:
+            if line.startswith('#>>'):
+                user_json = line[3:].strip()
+                user = json.loads(user_json, object_hook=serializer.make_decoder_hook(connection=con))
+                try:
+                    existing_user = User.read(con=con, userId=user.userId)
+                except OldapErrorNotFound:
+                    # user does not exist -> create it
+                    user.create(keep_dates=True)
+                    log.info(f"Created user {user.userId}")
+                else:
+                    # user exists -> update it
+                    if user.hasRole != existing_user.hasRole or user.inProject != existing_user.inProject:
+                        existing_user.delete()
+                        user.create(keep_dates=True)
+                        log.info(f"Updated (replaced) user {user.userId}")
+                    pass
+            if line.startswith('#<<'):
+                break
+    cache = CacheSingletonRedis()
+    cache.clear()
+
+
+

oldap_tools/logging.py

@@ -0,0 +1,13 @@
+import logging
+import sys
+
+def setup_logging(verbose: bool = False) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+
+    logging.basicConfig(
+        level=level,
+        format="%(levelname)s: %(message)s",
+        handlers=[
+            logging.StreamHandler(sys.stderr)
+        ],
+    )

oldap_tools-0.1.4.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.1
+Name: oldap-tools
+Version: 0.1.4
+Summary: CLI tools for OLDAP
+License: GPL-3.0-only
+Author: Lukas Rosenthaler
+Author-email: lukas.rosenthaler@unibas.ch
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: oldaplib (>=0.4.1,<0.5.0)
+Requires-Dist: rdflib (>=7.5.0,<8.0.0)
+Requires-Dist: typer (>=0.20.0,<0.21.0)
+Description-Content-Type: text/markdown
+
+[![PyPI version](https://badge.fury.io/py/oldap-tools.svg)](https://badge.fury.io/py/oldap-tools)
+[![GitHub release](https://img.shields.io/github/v/release/OMAS-IIIF/oldap-tools)](https://github.com/OMAS-IIIF/oldap-tools/releases)
+# OLDAP tools
+
+OLDAP tools is a CLI tool for managing parts of the OLDAP framework. It allows to
+
+- dump all the data of a given project to a gzipped TriG file
+- load a project from a gzipped TriG file created by oldap-tools
+- load a hierarchical list from a YAML file
+- dump a hierarchical list to a YAML file
+
+# Installation
+
+The installation is done using pip: `pip install oldap-tools`
+
+# Usage
+
+The CLI tool provides the following commands:
+
+- `oldap-tools project dump`: Dump all the data of a given project to a gzipped TriG file
+- `oldap-tools project load`: Load a project from a gzipped TriG file created by oldap-tools
+- `oldap-tools list dump`: Dump a hierarchical list to a YAML file
+- `oldap-tools list load`: Load a hierarchical list from a YAML file
+
+# Common options
+
+- `--graphdb`, `-g`: URL of the GraphDB server (default: "http://localhost:7200")
+- `--repo`, `-r`: Name of the repository (default: "oldap")
+- `--user`, `-u`: OLDAP user (*required*) which performs the operations
+- `--password` `-p`: OLDAP password (*required*)
+- `--graphdb_user`: GraphDB user (default: None). Not needed if GraphDB runs without athentification.
+- `--graphdb_password`: GraphDB password (default: None). Not needed if GraphDB runs without athentification.
+- `--verbose`, `-v`: Print more information
+
+# Command
+
+## Project dump
+
+This command dumps all the data of a given project to a gzipped TriG file. It includes user information
+of all users associated with the project. The command has the following syntax (in addition to the common options):
+
+```oldap-tools [common_options] [graphdb-options] project dump [-out <filename>] [--data | --no-data] [-verbose] <project_id>```
+
+The graphdb options see above. The other options are defined as follows:
+
+- `-out <filename>`: Name of the output file (default: "<project_id>.trig.gz")
+- `--data | --no-data`: Include or exclude the data of the project (default: include)
+- `-verbose`: Print more information
+- `<project_id>`: Project identifier (project shortname)
+
+The file is basically a dump of the project specific named graphs of the GraphDB repository.
+This are the following graphs:
+
+- `<project_id>:shacl`: Contains all the SHACL shapes of the project
+- `<project_id>:onto`: Contains all the OWL ontology information of the project
+- `<project_id>:lists`: Contains all the hierarchical lists of the project
+- `<project_id>:data`: Contains all the resources (instances) of the project
+
+The user information is stored as special comment in the TriG file and is interpreted by oldap-tools project load.
+
+## Project load
+
+This command loads a project from a gzipped TriG file created by oldap-tools. It has the following syntax
+(in addition to the common options):
+
+```oldap-tools [common_options] [graphdb-options] project load --i <filename>```
+
+The options are as follows:
+
+- `--inf`, `-i`: Name of the input file (required)
+- `-verbose`: Print more information
+
+If a user does not exist, then the user is created. If the User is already existing, then the user is replaced.
+
+*NOTE: This will change in the future in order to only update project specific permissions to the existing user.*
+
+## List dump
+
+This command dumps a hierarchical list to a YAML file. This file can be edited to add/remove or change list items.
+The command has the following syntax (in addition to the common options):
+
+```oldap-tools [common_options] list dump [-out <filename>] <project_id> <list_id>```
+
+This command generates a YAML file which can be edited and contains the list and all it nodes
+
+The options are as follows:
+
+- `-out `, `-o`: Output file
+- `<project_id>`: Project identifier (project shortname)
+- `<list_id>`: List identifier
+
+## List load
+
+This command loads a hierarchical list from a YAML file into the given project. The command has the following syntax
+(in addition to the common options):
+
+```oldap-tools [common_options] list load --inf <filename> <project_id>```
+
+The options are as follows:
+
+- `--inf`, `-i`: Name of the input file (required)
+- `<project_id>`: Project identifier (project shortname)
+
+
+

oldap_tools-0.1.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+oldap_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oldap_tools/__main__.py,sha256=0g3iknXOS9gZUcpL_trgAcuCJnZZKjdsT_xt61WOVb4,60
+oldap_tools/cli.py,sha256=R2QR1sJ9eX3TOjkoGOUER31aaTLBVeJfL73md2Bsz-g,4599
+oldap_tools/config.py,sha256=_VrFlBZG5EBeoA5HyCxxMuSM8qRPJWUN0QILOrYjKMU,275
+oldap_tools/dump_list.py,sha256=kHW-u57Pgso0cKl2R59KQLBY9J8abpRIDtX8iS6rRgs,1577
+oldap_tools/dump_project.py,sha256=0GaIVLB0nURiPJVl5_y00y3E6E0XRINFY2qWZnIpSQ0,4535
+oldap_tools/load_list.py,sha256=i4npHMRoZuPXyizAeab5qjzlIyvMEaFGiuJq3P-7xxQ,1472
+oldap_tools/load_project.py,sha256=KLfGHzIXAH2fwtTyzkmC7uozxmCs2geQp-XjBbGQXEo,3661
+oldap_tools/logging.py,sha256=qxBtN_HcUMYeSAHZVQ1YiWd5pgB-beBwEUSOv5f_KvM,305
+oldap_tools-0.1.4.dist-info/METADATA,sha256=zdYmoBWIjikFcH6ABZBidGRTmBaSYUlUjaKREkwf1Is,4891
+oldap_tools-0.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+oldap_tools-0.1.4.dist-info/entry_points.txt,sha256=3UTWo7Z79A2m4rmTMnBeQZI5BXT19VJSPIdu7pWMp2I,52
+oldap_tools-0.1.4.dist-info/RECORD,,

oldap_tools-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

oldap_tools-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+oldap-tools=oldap_tools.cli:main
+