kurra 0.6.0__tar.gz

kurra-0.6.0/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2023 KurrawongAI
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

kurra-0.6.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: kurra
+Version: 0.6.0
+Summary: A Python library of common code and CLI apps shared across Kurrawong projects and infrastructure.
+Author: Edmond Chuc
+Author-email: edmond@kurrawong.ai
+Requires-Python: >=3.11,<4.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: httpx (>=0.24.1,<1.0.0)
+Requires-Dist: rdflib (>=6.3.2,<8.0.0)
+Requires-Dist: rich (>=13.4.1,<14.0.0)
+Requires-Dist: typer (>=0.9.0,<1.0.0)
+Description-Content-Type: text/markdown
+
+# Kurra Python Library
+
+A Python library of RDF data manipulation functions.
+
+## CLI Features
+
+## `kurra format`
+
+Format Turtle files using RDFLib's `longturtle` format.
+
+### `kurra fuseki`
+
+A set of commands to interface with a Fuseki server.
+
+#### `kurra fuseki dataset list`
+
+Get a list of Fuseki datasets.
+
+#### `kurra fuseki dataset create`
+
+Create a new Fuseki dataset.
+
+#### `kurra fuseki upload`
+
+Upload a file or a directory of files with an RDF file extension.
+
+#### `kurra fuseki clear`
+
+Clear a named graph or clear all graphs.
+
+## Installation
+
+View the [releases](https://github.com/Kurrawong/kurrawong-python/releases) page and install using the source code (zip) link.
+
+```bash
+pip install https://github.com/Kurrawong/kurra/archive/refs/tags/0.6.0.zip
+```
+
+## Development
+
+Install the Poetry project and its dependencies.
+
+```bash
+task install
+```
+
+Format code.
+
+```bash
+task code
+```
+
+## License
+
+[BSD-3-Clause](https://opensource.org/license/bsd-3-clause/) license. See [LICENSE](LICENSE).
+

kurra-0.6.0/README.md

@@ -0,0 +1,55 @@
+# Kurra Python Library
+
+A Python library of RDF data manipulation functions.
+
+## CLI Features
+
+## `kurra format`
+
+Format Turtle files using RDFLib's `longturtle` format.
+
+### `kurra fuseki`
+
+A set of commands to interface with a Fuseki server.
+
+#### `kurra fuseki dataset list`
+
+Get a list of Fuseki datasets.
+
+#### `kurra fuseki dataset create`
+
+Create a new Fuseki dataset.
+
+#### `kurra fuseki upload`
+
+Upload a file or a directory of files with an RDF file extension.
+
+#### `kurra fuseki clear`
+
+Clear a named graph or clear all graphs.
+
+## Installation
+
+View the [releases](https://github.com/Kurrawong/kurrawong-python/releases) page and install using the source code (zip) link.
+
+```bash
+pip install https://github.com/Kurrawong/kurra/archive/refs/tags/0.6.0.zip
+```
+
+## Development
+
+Install the Poetry project and its dependencies.
+
+```bash
+task install
+```
+
+Format code.
+
+```bash
+task code
+```
+
+## License
+
+[BSD-3-Clause](https://opensource.org/license/bsd-3-clause/) license. See [LICENSE](LICENSE).

kurra-0.6.0/kurra/__init__.py

@@ -0,0 +1,3 @@
+from pathlib import Path
+
+__version__ = [v for v in open(Path(__file__).parent.parent.resolve() / "pyproject.toml").readlines() if v.startswith("version")][0].split('"')[1]

kurra-0.6.0/kurra/cli/__init__.py

@@ -0,0 +1,8 @@
+from kurra.cli.app import app
+from kurra.cli.commands.format import app as format_app
+from kurra.cli.commands.version import app as version_app
+from kurra.cli.commands.fuseki.app import app as fuseki_app
+
+app.add_typer(fuseki_app)
+app.add_typer(format_app)
+app.add_typer(version_app)

kurra-0.6.0/kurra/cli/app.py

@@ -0,0 +1,3 @@
+import typer
+
+app = typer.Typer()

kurra-0.6.0/kurra/cli/commands/format.py

@@ -0,0 +1,31 @@
+import sys
+
+import typer
+
+from kurra.format import FailOnChangeError, format_rdf, RDF_FILE_SUFFIXES
+
+app = typer.Typer()
+
+
+@app.command(name="format", help="Format Turtle files using the longturtle format.")
+def format_command(
+    file_or_dir: str = typer.Argument(
+        ..., help="The file or directory of RDF files to be formatted"
+    ),
+    check: bool = typer.Option(
+        False, help="Check whether files will be formatted without applying the effect."
+    ),
+    output_format: str = typer.Option(
+        "longturtle",
+        help=f"Indicate the output RDF format. Available are {list(RDF_FILE_SUFFIXES.keys())}.",
+    ),
+    output_filename: str = typer.Option(
+        None,
+        help="the name of the file you want to write the reformatted content to",
+    ),
+) -> None:
+    try:
+        format_rdf(file_or_dir, check, output_format, output_filename)
+    except FailOnChangeError as err:
+        print(err)
+        sys.exit(1)

kurra-0.6.0/kurra/cli/commands/fuseki/app.py

@@ -0,0 +1,7 @@
+import typer
+
+from .dataset import app as dataset_app
+
+app = typer.Typer()
+
+app.add_typer(dataset_app, name="dataset", help="Fuseki Dataset commands.")

kurra-0.6.0/kurra/cli/commands/fuseki/clear.py

@@ -0,0 +1,39 @@
+import httpx
+import typer
+from typing_extensions import Annotated
+
+from kurra.cli.commands.fuseki.app import app
+from kurra.cli.console import console
+from kurra.fuseki import clear_graph
+
+
+@app.command(name="clear", help="Clear graph in the Fuseki dataset.")
+def clear_command(
+    named_graph: str = typer.Argument(
+        ..., help="Named graph. If 'all' is supplied, it will remove all named graphs."
+    ),
+    fuseki_url: str = typer.Argument(
+        ..., help="Fuseki base URL. E.g. http://localhost:3030"
+    ),
+    username: Annotated[
+        str, typer.Option("--username", "-u", help="Fuseki username.")
+    ] = None,
+    password: Annotated[
+        str, typer.Option("--password", "-p", help="Fuseki password.")
+    ] = None,
+    timeout: Annotated[
+        int, typer.Option("--timeout", "-t", help="Timeout per request")
+    ] = 60,
+):
+    auth = (
+        (username, password) if username is not None and password is not None else None
+    )
+
+    with httpx.Client(auth=auth, timeout=timeout) as client:
+        try:
+            clear_graph(fuseki_url, client, named_graph)
+        except Exception as err:
+            console.print(
+                f"[bold red]ERROR[/bold red] Failed to run clear command with '{named_graph}' at {fuseki_url}."
+            )
+            raise err

kurra-0.6.0/kurra/cli/commands/fuseki/dataset.py

@@ -0,0 +1,70 @@
+from typing import Annotated
+
+import httpx
+import typer
+
+from kurra.cli.console import console
+from kurra.fuseki import dataset_create, dataset_list
+
+app = typer.Typer()
+
+
+@app.command(name="list", help="Get a list of Fuseki datasets.")
+def dataset_list_command(
+    fuseki_url: str = typer.Argument(
+        ..., help="Fuseki base URL. E.g. http://localhost:3030"
+    ),
+    username: Annotated[
+        str, typer.Option("--username", "-u", help="Fuseki username.")
+    ] = None,
+    password: Annotated[
+        str, typer.Option("--password", "-p", help="Fuseki password.")
+    ] = None,
+    timeout: Annotated[
+        int, typer.Option("--timeout", "-t", help="Timeout per request")
+    ] = 60,
+) -> None:
+    auth = (
+        (username, password) if username is not None and password is not None else None
+    )
+
+    with httpx.Client(auth=auth, timeout=timeout) as client:
+        try:
+            result = dataset_list(fuseki_url, client)
+            console.print(result)
+        except Exception as err:
+            console.print(
+                f"[bold red]ERROR[/bold red] Failed to list Fuseki datasets at {fuseki_url}."
+            )
+            raise err
+
+
+@app.command(name="create", help="Create a new Fuseki dataset.")
+def dataset_create_command(
+    fuseki_url: str = typer.Argument(
+        ..., help="Fuseki base URL. E.g. http://localhost:3030"
+    ),
+    dataset_name: str = typer.Argument(..., help="Fuseki dataset name"),
+    username: Annotated[
+        str, typer.Option("--username", "-u", help="Fuseki username.")
+    ] = None,
+    password: Annotated[
+        str, typer.Option("--password", "-p", help="Fuseki password.")
+    ] = None,
+    timeout: Annotated[
+        int, typer.Option("--timeout", "-t", help="Timeout per request")
+    ] = 60,
+) -> None:
+    auth = (
+        (username, password) if username is not None and password is not None else None
+    )
+
+    with httpx.Client(auth=auth, timeout=timeout) as client:
+        try:
+            result = dataset_create(fuseki_url, client, dataset_name)
+            console.print(result)
+        except Exception as err:
+            console.print(
+                f"[bold red]ERROR[/bold red] Failed to create Fuseki dataset {dataset_name} at {fuseki_url}."
+            )
+            raise err

kurra-0.6.0/kurra/cli/commands/fuseki/upload.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+
+import httpx
+import typer
+from rich.progress import track
+from typing_extensions import Annotated
+
+from kurra.cli.commands.fuseki.app import app
+from kurra.cli.console import console
+from kurra.fuseki import suffix_map, upload
+
+
+@app.command(name="upload", help="Upload files to a Fuseki dataset.")
+def upload_command(
+    path: Path = typer.Argument(
+        ..., help="The path of a file or directory to be uploaded."
+    ),
+    fuseki_url: str = typer.Argument(
+        ..., help="Fuseki dataset URL. E.g. http://localhost:3030/ds"
+    ),
+    username: Annotated[
+        str, typer.Option("--username", "-u", help="Fuseki username.")
+    ] = None,
+    password: Annotated[
+        str, typer.Option("--password", "-p", help="Fuseki password.")
+    ] = None,
+    timeout: Annotated[
+        int, typer.Option("--timeout", "-t", help="Timeout per request")
+    ] = 60,
+) -> None:
+    """Upload a file or a directory of files with an RDF file extension.
+
+    File extensions: [.nt, .nq, .ttl, .trig, .json, .jsonld, .xml]
+
+    Files are uploaded into their own named graph in the format:
+    <urn:file:{file.name}>
+    E.g. <urn:file:example.ttl>
+    """
+    files = []
+
+    if path.is_file():
+        files.append(path)
+    else:
+        files += path.glob("**/*")
+
+    auth = (
+        (username, password) if username is not None and password is not None else None
+    )
+
+    files = list(filter(lambda f: f.suffix in suffix_map.keys(), files))
+
+    with httpx.Client(auth=auth, timeout=timeout) as client:
+        for file in track(files, description=f"Uploading {len(files)} files..."):
+            try:
+                upload(fuseki_url, file, client, f"urn:file:{file.name}")
+            except Exception as err:
+                console.print(
+                    f"[bold red]ERROR[/bold red] Failed to upload file {file}."
+                )
+                raise err

kurra-0.6.0/kurra/cli/commands/version.py

@@ -0,0 +1,31 @@
+import typer
+from typing_extensions import Annotated
+
+from kurra.cli import app as main_app
+from kurra import __version__
+from kurra.cli.console import console
+
+app = typer.Typer()
+
+
+@app.command(name="version", help="Show the version of the kurra CLI app.")
+def version_command():
+    console.print(f"kurra version {__version__}")
+
+
+def version_callback(value: bool):
+    if value:
+        from kurra.cli.commands import version
+
+        version.version_command()
+        raise typer.Exit()
+
+
+@main_app.callback(invoke_without_command=True)
+def main(
+    version: Annotated[
+        bool, typer.Option("--version", callback=version_callback, is_eager=True)
+    ] = False,
+):
+    """Main callback for the CLI app."""
+    pass

kurra-0.6.0/kurra/cli/console.py

@@ -0,0 +1,3 @@
+from rich.console import Console
+
+console = Console()

kurra-0.6.0/kurra/format.py

@@ -0,0 +1,194 @@
+from pathlib import Path
+from typing import Tuple, Literal, Union, Optional
+
+from rdflib import Graph, URIRef, Dataset
+from kurra.utils import guess_format_from_data, load_graph
+
+KNOWN_RDF_FORMATS = Literal["turtle", "longturtle", "xml", "n-triples", "json-ld"]
+RDF_FILE_SUFFIXES = {
+    "turtle": ".ttl",
+    "longturtle": ".ttl",
+    "xml": ".rdf",
+    "n-triples": ".nt",
+    "json-ld": ".jsonld",
+}
+
+
+class FailOnChangeError(Exception):
+    """
+    This exception is raised when running format and the
+    check bool is set to true and the file has resulted in a change.
+    """
+
+
+def get_topbraid_metadata(content: str) -> str:
+    """Get the TopBraid Composer metadata at the top of an ontology file."""
+    lines = content.split("\n")
+    comments = []
+    for line in lines:
+        if line.startswith("#"):
+            comments.append(line)
+        else:
+            break
+
+    if comments:
+        return "\n".join(comments) + "\n"
+    else:
+        return ""
+
+
+def do_format(
+    content: str, output_format: KNOWN_RDF_FORMATS = "longturtle"
+) -> Tuple[str, bool]:
+    metadata = get_topbraid_metadata(content)
+
+    graph = Graph()
+    graph.parse(data=content, format=guess_format_from_data(content))
+    new_content = graph.serialize(format=output_format)
+    new_content = metadata + new_content
+    changed = content != new_content
+    return new_content, changed
+
+
+def format_file(
+    file: Path,
+    check: bool = False,
+    output_format: KNOWN_RDF_FORMATS = "longturtle",
+    output_filename: Path = None,
+) -> bool:
+    if not file.is_file():
+        raise ValueError(f"{file} is not a file.")
+
+    path = Path(file).resolve()
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {path.absolute()}")
+
+    if output_filename is None:
+        output_filename = path.with_suffix(RDF_FILE_SUFFIXES[output_format])
+
+    Path(output_filename).touch(exist_ok=True)
+
+    with open(path, "r", encoding="utf-8") as fread:
+        content = fread.read()
+
+        content, changed = do_format(content, output_format)
+        if changed:
+            if check:
+                raise FailOnChangeError(
+                    f"The file {path} contains changes that can be formatted."
+                )
+            else:
+                print(f"The file {path} has been formatted.")
+
+            # Didn't fail and file has changed, so write to file.
+            with open(output_filename, "w", encoding="utf-8") as fwrite:
+                fwrite.write(content)
+
+    return changed
+
+
+def format_rdf(
+    path: Path,
+    check: bool,
+    output_format: KNOWN_RDF_FORMATS = "longturtle",
+    output_filename: Path = None,
+) -> None:
+    path = Path(path).resolve()
+
+    if path.is_dir():
+        files = list(path.glob("**/*.ttl"))
+
+        changed_files = []
+
+        for file in files:
+            try:
+                changed = format_file(file, check, output_format=output_format)
+                if changed:
+                    changed_files.append(file)
+            except FailOnChangeError as err:
+                print(err)
+                changed_files.append(file)
+
+        if check and changed_files:
+            if changed_files:
+                raise FailOnChangeError(
+                    f"{len(changed_files)} out of {len(files)} files will change."
+                )
+            else:
+                print(
+                    f"{len(changed_files)} out of {len(files)} files will change.",
+                )
+        else:
+            print(
+                f"{len(changed_files)} out of {len(files)} files changed.",
+            )
+    else:
+        # single file reformatting
+        if bool(output_filename) and output_format is not None:
+            print("output_filename:")
+            print(output_filename)
+            output_filename = Path(output_filename)
+            output_filename = output_filename.resolve().with_suffix(
+                RDF_FILE_SUFFIXES[output_format]
+            )
+
+        print(output_filename)
+
+        try:
+            format_file(
+                path,
+                check,
+                output_format=output_format,
+                output_filename=output_filename,
+            )
+        except FailOnChangeError as err:
+            print(err)
+
+
+def make_dataset(
+    path_str_or_graph: Union[Path, str, Graph], graph_iri: Union[str, URIRef]
+) -> Dataset:
+    """Returns a given Graph, or string or file of triples, as a Dataset, with the supplied graph IRI"""
+
+    # TODO: make a Dataset from a Graph or Datatset
+    # - override option to replace existing graph
+    # - set default union graph
+    # - set default graph
+    if not isinstance(graph_iri, URIRef):
+        graph_iri = URIRef(graph_iri)
+
+    g = load_graph(path_str_or_graph)
+
+    d = Dataset()
+    for s, p, o in g:
+        d.add((s, p, o, graph_iri))
+
+    return d
+
+
+def export_quads(
+    path_str_or_dataset: Union[Path, str, Dataset], destination: Optional[Path] = None
+) -> bool | str:
+    """Exports a given Dataset, or quads in trig format or a quads file specified by a path, either as
+    quads to a string, if no destination is given, or a file, if one is"""
+    if isinstance(path_str_or_dataset, Path):
+        d = Dataset()
+        d.print(str(path_str_or_dataset))
+    elif isinstance(path_str_or_dataset, str):
+        d = Dataset()
+        d.parse(data=path_str_or_dataset, format="trig")
+    else:  # Dataset
+        d = path_str_or_dataset
+
+    if destination is not None:
+        if Path(destination).is_file():
+            d2 = Dataset()
+            d2.parse(destination)
+            d3 = d + d2
+            d3.serialize(format="trig", destination=destination)
+        else:
+            d.serialize(format="trig", destination=destination)
+
+        return True
+    else:
+        return d.serialize(format="trig")

kurra-0.6.0/kurra/fuseki.py

@@ -0,0 +1,171 @@
+import json
+from pathlib import Path
+from typing import Union
+from textwrap import dedent
+from rdflib import Graph
+
+import httpx
+
+from kurra.utils import guess_format_from_data, load_graph
+
+suffix_map = {
+    ".nt": "application/n-triples",
+    ".nq": "application/n-quads",
+    ".ttl": "text/turtle",
+    ".trig": "application/trig",
+    ".json": "application/ld+json",
+    ".jsonld": "application/ld+json",
+    ".xml": "application/rdf+xml",
+}
+
+
+def _guess_query_is_update(query: str) -> bool:
+    if any(x in query for x in ["DROP", "INSERT", "DELETE"]):
+        return True
+    else:
+        return False
+
+
+def _guess_return_type_for_sparql_query(query: str) -> str:
+    if any(x in query for x in ["SELECT", "INSERT", "ASK"]):
+        return "application/sparql-results+json"
+    elif "CONSTRUCT" in query:
+        return "text/turtle"
+    else:
+        return "application/sparql-results+json"
+
+
+def upload(
+    url: str,
+    file_or_str_or_graph: Union[Path, str, Graph],
+    graph_name: str = None,
+    append: bool = False,
+    http_client: httpx.Client = None,
+) -> None:
+    """This function uploads a file to a Fuseki server using the Graph Store Protocol.
+
+    It will upload it into a graph named graph_name (an IRI). If no graph_name is given, it will be uploaded into
+    the Fuseki default graph.
+
+    By default, it will replace all content in the Named Graph or default graph. If append is set to True, it will
+    add it to existing content in the graph_name Named Graph.
+
+    An httpx Client may be supplied for efficient client reuse, else each call to this function will recreate a new
+    Client."""
+
+    close_http_client = False
+    if http_client is None:
+        http_client = httpx.Client()
+        close_http_client = True
+
+    params = {"graph": graph_name} if graph_name else "default"
+
+    data = load_graph(file_or_str_or_graph).serialize(format="longturtle")
+    headers = {"content-type": "text/turtle"}
+
+    if append:
+        response = http_client.post(url, params=params, headers=headers, content=data)
+    else:
+        response = http_client.put(url, params=params, headers=headers, content=data)
+
+    status_code = response.status_code
+
+    if status_code != 200 and status_code != 201 and status_code != 204:
+        message = (
+            str(file_or_str_or_graph)
+            if isinstance(file_or_str_or_graph, Path)
+            else "content"
+        )
+        raise RuntimeError(
+            f"Received status code {status_code} for file {message} at url {url}. Message: {response.text}"
+        )
+
+    if close_http_client:
+        http_client.close()
+
+
+def dataset_list(
+    url: str,
+    http_client: httpx.Client,
+) -> str:
+    headers = {"accept": "application/json"}
+    response = http_client.get(f"{url}/$/datasets", headers=headers)
+    status_code = response.status_code
+
+    if status_code != 200:
+        raise RuntimeError(
+            f"Received status code {status_code}. Message: {response.text}"
+        )
+
+    return json.dumps(response.json(), indent=2)
+
+
+def dataset_create(
+    url: str, http_client: httpx.Client, dataset_name: str, dataset_type: str = "tdb2"
+) -> str:
+    data = {"dbName": dataset_name, "dbType": dataset_type}
+    response = http_client.post(f"{url}/$/datasets", data=data)
+    status_code = response.status_code
+
+    if response.status_code != 200 and response.status_code != 201:
+        raise RuntimeError(
+            f"Received status code {status_code}. Message: {response.text}"
+        )
+
+    return f"Dataset {dataset_name} created at {url}."
+
+
+def clear_graph(url: str, http_client: httpx.Client, named_graph: str):
+    query = "CLEAR ALL" if named_graph == "all" else f"CLEAR GRAPH <{named_graph}>"
+    headers = {"content-type": "application/sparql-update"}
+    response = http_client.post(url, headers=headers, content=query)
+    status_code = response.status_code
+
+    if status_code != 204:
+        raise RuntimeError(
+            f"Received status code {status_code}. Message: {response.text}"
+        )
+
+
+def query(
+    sparql_endpoint: str,
+    query: str,
+    http_client: httpx.Client = None,
+    return_python: bool = False,
+    return_bindings_only: bool = False,
+):
+    """Poses a SPARQL query to the Fuseki server."""
+
+    if http_client is None:
+        http_client = httpx.Client()
+
+    if query is None:
+        raise ValueError("You must supply a query")
+
+    if _guess_query_is_update(query):
+        headers = {"Content-Type": "application/sparql-update"}
+    else:
+        headers = {"Content-Type": "application/sparql-query"}
+
+    headers["Accept"] = _guess_return_type_for_sparql_query(query)
+
+    response = http_client.post(
+        sparql_endpoint,
+        headers=headers,
+        content=query,
+    )
+
+    status_code = response.status_code
+
+    if status_code != 200 and status_code != 201 and status_code != 204:
+        raise RuntimeError(f"ERROR {status_code}: {response.text}")
+
+    match (return_python, return_bindings_only):
+        case (True, True):
+            return response.json()["results"]["bindings"]
+        case (True, False):
+            return response.json()
+        case (False, True):
+            return dedent(response.text.split('"bindings": [')[1].split("]")[0])
+        case _:
+            return response.text

kurra-0.6.0/kurra/utils.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+from typing import Union
+from rdflib import Graph
+
+
+def guess_format_from_data(rdf: str):
+    if rdf is not None:
+        rdf = rdf.strip()
+        if rdf.startswith("PREFIX") or rdf.startswith("@prefix"):
+            return "text/turtle"
+        elif rdf.startswith("{") or rdf.startswith("["):
+            return "application/ld+json"
+        elif rdf.startswith("<?xml") or rdf.startswith("<rdf"):
+            return "application/rdf+xml"
+        else:
+            return "application/n-triples"
+    else:
+        return None
+
+
+def load_graph(file_or_str_or_graph: Union[Path, str, Graph]):
+    if isinstance(file_or_str_or_graph, Path):
+        return Graph().parse(str(file_or_str_or_graph))
+
+    elif isinstance(file_or_str_or_graph, Graph):
+        return file_or_str_or_graph
+
+    else:  # str (data)
+        return Graph().parse(
+            data=file_or_str_or_graph,
+            format=guess_format_from_data(file_or_str_or_graph),
+        )

kurra-0.6.0/pyproject.toml

@@ -0,0 +1,33 @@
+[tool.poetry]
+name = "kurra"
+version = "0.6.0"
+description = "A Python library of common code and CLI apps shared across Kurrawong projects and infrastructure."
+authors = ["Edmond Chuc <edmond@kurrawong.ai>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = ">=3.11,<4.0.0"
+httpx = ">=0.24.1,<1.0.0"
+rdflib = ">=6.3.2,<8.0.0"
+typer = ">=0.9.0,<1.0.0"
+rich = ">=13.4.1,<14.0.0"
+
+
+[tool.poetry.group.dev.dependencies]
+black = "^23.3.0"
+pytest = "^7.3.1"
+ruff = "^0.0.272"
+testcontainers = "^4.9.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+kurra = 'kurra.cli:app'
+
+[tool.ruff]
+select = [
+    "I001",
+    "I002"
+]