pyomnigraph 0.2.1__tar.gz → 0.2.2__tar.gz

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyomnigraph
-Version: 0.2.1
+Version: 0.2.2
 Summary: pyomnigraph: Unified Python interface for multiple graph databases (SPARQL, Neo4j, Weaviate)
 Project-URL: Home, https://github.com/WolfgangFahl/omnigraph
 Project-URL: Documentation, https://wiki.bitplan.com/index.php/omnigraph

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/docs/index.md

@@ -1,4 +1,4 @@
-# omnigraph API Documentation
+# pyomnigraph API Documentation
 
 ::: omnigraph
     options:

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/mkdocs.yml

@@ -1,4 +1,4 @@
-site_name: omnigraph API Documentation
+site_name: pyomnigraph API Documentation
 theme:
   name: material
 plugins:

pyomnigraph-0.2.2/omnigraph/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/omnigraph_cmd.py

@@ -171,7 +171,8 @@ class OmnigraphCmd(BaseCmd):
         handled = False
         if cmds:
             for cmd in cmds:
-                if cmd == "load":
+                # issue #38: upload needs the per-dataset dumps_dir just like load
+                if cmd in ("load", "upload"):
                     cmd_iterator = self.load_iterator(server)
                 else:
                     cmd_iterator = iter([None])  # Single iteration

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/omniserver.py

@@ -70,6 +70,7 @@ class OmniServer:
             "start": lambda s: ServerCmd(title("start", s), s.start),
             "status": lambda s: ServerCmd(title("status", s), s.status_info),
             "stop": lambda s: ServerCmd(title("stop", s), s.stop),
+            "upload": lambda s: ServerCmd(title("native bulk upload dumps", s), s.upload_dump_files),
             "webui": lambda s: ServerCmd(title("webui", s), s.webui),
         }
         return server_cmds

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/rdf_dataset.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass, field
 from typing import Dict, Optional
 
 from basemkit.yamlable import lod_storable
+from lodstorage.params import Params
 from lodstorage.query import Query
 from lodstorage.sparql import SPARQL
 
@@ -26,6 +27,7 @@ class RdfDataset:
     expected_solutions: Optional[int] = None  # Expected number of solutions
     select_pattern: str = "?s ?p ?o"  # Basic Graph Pattern for queries
     construct_template: Optional[str] = field(default="?s ?p ?o")
+    params: Optional[Dict[str, str]] = None  # npq parameters for {{ name }} templates (issue #36)
     prefix_sets: Optional[list] = field(default_factory=list)
     active: Optional[bool] = False
     rdf_file: Optional[str] = None  # Path to local RDF file (alternative to endpoint_url)
@@ -35,10 +37,41 @@ class RdfDataset:
     select_query: Optional[Query] = field(default=None)
     sparql: Optional[SPARQL] = field(default=None)
 
-    def __post_init__(self):
+    def apply_params(self, params_dict: Optional[Dict[str, str]] = None) -> None:
+        """
+        Apply npq parameters to select_pattern and construct_template.
+
+        {{ name }} templates are replaced with the values of the merged
+        params: the dataset's own params overridden by the given ones.
+        Substitution always starts from the raw templates, so CLI overrides
+        can be re-applied after YAML defaults. The blanket Params audit is
+        off - it rejects quoted VALUES lists (see issue #36); values stem
+        from local configuration and CLI.
+
+        Args:
+            params_dict: additional parameter values overriding self.params
         """
-        Generate count_query and construct_pattern from select_pattern.
-        Only initialize SPARQL-related fields if endpoint_url is provided.
+        # preserve the raw templates on first call
+        if not hasattr(self, "raw_templates"):
+            self.raw_templates = {
+                "select_pattern": self.select_pattern,
+                "construct_template": self.construct_template,
+            }
+        merged = dict(self.params) if self.params else {}
+        if params_dict:
+            merged.update(params_dict)
+        if merged:
+            for attr, raw_template in self.raw_templates.items():
+                if raw_template:
+                    params = Params(raw_template, with_audit=False)
+                    if params.has_params:
+                        params.set(merged)
+                        setattr(self, attr, params.apply_parameters())
+
+    def build_queries(self) -> None:
+        """
+        (Re)build count_query and select_query from the current select_pattern.
+        Only initializes SPARQL-related fields if endpoint_url is provided.
         """
         if self.endpoint_url:
             self.count_query = Query(
@@ -55,6 +88,13 @@ class RdfDataset:
             )
             self.sparql = SPARQL(self.endpoint_url)
 
+    def __post_init__(self):
+        """
+        Apply npq params and generate the queries from select_pattern.
+        """
+        self.apply_params()
+        self.build_queries()
+
     @property
     def full_name(self):
         ds_id = self.id or "?"
@@ -69,6 +109,8 @@ class RdfDataset:
             Number of solutions available from the count query
         """
         count = self.sparql.getValue(self.count_query.query, "count")
+        # issue #37: getValue returns the raw literal which may be a str
+        count = int(count)
         return count
 
     def getTryItUrl(self, database: str = "blazegraph") -> str:

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/rdfdump_cmd.py

@@ -10,6 +10,8 @@ import os
 import webbrowser
 from argparse import ArgumentParser, Namespace
 
+from basemkit.argparse_action import StoreDictKeyPair
+
 from omnigraph.basecmd import BaseCmd
 from omnigraph.rdf_dataset import RdfDataset, RdfDatasets
 from omnigraph.rdfdump import RdfDumpDownloader
@@ -61,6 +63,13 @@ class RdfDumpCmd(BaseCmd):
             default=None,
             help="Maximum number of solutions/triples to download (uses dataset expected_solutions if not specified)",
         )
+        parser.add_argument(
+            "--param",
+            action=StoreDictKeyPair,
+            dest="params",
+            metavar="KEY=VALUE,KEY=VALUE...",
+            help="npq parameter values overriding the dataset's params (issue #36)",
+        )
         parser.add_argument("--no-progress", action="store_true", help="Disable progress bar")
         parser.add_argument("--output-path", default=".", help="Path for dump files")
         parser.add_argument("--tryit", action="store_true", help="open the try it! URL [default: %(default)s]")
@@ -97,6 +106,11 @@ class RdfDumpCmd(BaseCmd):
         """
         super().handle_args(args)
         datasets = self.datasets
+        if getattr(args, "params", None):
+            # apply CLI npq parameter overrides and rebuild the queries
+            for dataset in datasets.values():
+                dataset.apply_params(args.params)
+                dataset.build_queries()
         if self.args.about:
             self.about()
 

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/resources/examples/datasets.yaml

@@ -65,4 +65,40 @@ datasets:
         ?pName ?p4Name ?o4Name
     # Optional dataset description
     description: "W2306 postal code coordinates"
-    active: false
+    active: false
+  papers_of_my_network_wikidata:
+    # npq (named parameterized query) example - issue #36
+    # ORCID is the join key; {{ orcids }} is the VALUES scaling knob;
+    # endpoint is late-bound - own copy answers completely and fastest,
+    # see the endpoint matrix in the issue
+    name: "Papers of my network (wikidata)"
+    base_url: "https://qlever-api.wikidata.dbis.rwth-aachen.de"
+    endpoint_url: "https://qlever-api.wikidata.dbis.rwth-aachen.de/"
+    database: "qlever"
+    select_pattern: |
+      VALUES ?orcid { {{ orcids }} }
+      ?author <http://www.wikidata.org/prop/direct/P496> ?orcid .
+      ?work <http://www.wikidata.org/prop/direct/P50> ?author .
+      ?work ?p ?o
+    construct_template: "?work ?p ?o"
+    params:
+      orcids: '"0000-0002-0821-6995" "0000-0003-2533-6363" "0000-0001-9879-3827" "0000-0001-6324-7164"'
+    description: "Papers authored by the co-author network, seeded by ORCIDs"
+    active: false
+  papers_of_my_network_dblp:
+    # npq companion - same {{ orcids }} param drives the dblp graph
+    name: "Papers of my network (dblp)"
+    base_url: "https://sparql.dblp.org"
+    endpoint_url: "https://sparql.dblp.org/sparql"
+    database: "qlever"
+    select_pattern: |
+      VALUES ?orcid { {{ orcids }} }
+      BIND(IRI(CONCAT("https://orcid.org/", ?orcid)) AS ?orcid_uri)
+      ?author <https://dblp.org/rdf/schema#orcid> ?orcid_uri .
+      ?paper <https://dblp.org/rdf/schema#authoredBy> ?author .
+      ?paper ?p ?o
+    construct_template: "?paper ?p ?o"
+    params:
+      orcids: '"0000-0002-0821-6995" "0000-0003-2533-6363" "0000-0001-9879-3827" "0000-0001-6324-7164"'
+    description: "Papers authored by the co-author network in dblp, same ORCID seed"
+    active: false

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/servers/blazegraph.py

@@ -8,6 +8,8 @@ from dataclasses import dataclass
 from pathlib import Path
 import re
 import os
+import shutil
+
 from omnigraph.server_config import ServerLifecycleState, ServerStatus
 from omnigraph.sparql_server import ServerConfig, ServerEnv, SparqlServer
 
@@ -94,6 +96,68 @@ class Blazegraph(SparqlServer):
             rwstore_path.write_text(props)
 
 
+    def get_dataloader_xml(self, container_path: str) -> str:
+        """
+        Build the DataLoader servlet properties XML for the given
+        container-side file or directory path.
+
+        Args:
+            container_path: path as seen inside the container (mounted /data)
+
+        Returns:
+            the properties XML document
+        """
+        xml = f"""<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
+<properties>
+  <entry key="namespace">{self.config.dataset}</entry>
+  <entry key="propertyFile">/RWStore.properties</entry>
+  <entry key="fileOrDirs">{container_path}</entry>
+  <entry key="-durableQueues">true</entry>
+</properties>"""
+        return xml
+
+    def upload_dump_files(self, file_pattern: str = None) -> int:
+        """
+        Bulk-load dump files via Blazegraph's REST DataLoader servlet, which
+        reads the files from the server's own filesystem (the mounted /data
+        directory) instead of pushing them through HTTP request bodies.
+
+        Args:
+            file_pattern: Glob pattern for dump files
+
+        Returns:
+            Number of files loaded successfully
+        """
+        container_name = self.config.container_name
+        files = self.get_dump_files(file_pattern)
+        loaded_count = 0
+        if not files:
+            self.log.log("⚠️", container_name, f"No dump files found for pattern: {file_pattern}")
+        else:
+            # stage the dumps under data_dir so the container sees them at /data/dumps
+            stage_dir = Path(self.config.base_data_dir) / "dumps"
+            stage_dir.mkdir(parents=True, exist_ok=True)
+            for file in files:
+                target = stage_dir / file.name
+                if not target.exists():
+                    shutil.copy2(file, target)
+            xml = self.get_dataloader_xml("/data/dumps")
+            response = self.make_request(
+                "POST",
+                self.config.dataloader_url,
+                headers={"Content-Type": "application/xml"},
+                data=xml,
+                timeout=self.config.upload_timeout,
+            )
+            if response.success:
+                loaded_count = len(files)
+                self.log.log("✅", container_name, f"DataLoader loaded {loaded_count} file(s)")
+            else:
+                error_msg = str(response.error) if response.error else f"HTTP {response.response.status_code}"
+                self.log.log("❌", container_name, f"DataLoader failed: {error_msg}")
+        return loaded_count
+
     def status(self) -> ServerStatus:
         """
         Get server status information.

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/servers/jena.py

@@ -7,6 +7,8 @@ Apache Jena SPARQL support
 """
 
 from dataclasses import dataclass
+from pathlib import Path
+from typing import List
 
 from omnigraph.server_config import ServerLifecycleState, ServerStatus
 from omnigraph.sparql_server import ServerConfig, ServerEnv, SparqlServer
@@ -96,7 +98,65 @@ class Jena(SparqlServer):
         Returns:
             Tuple of (response, exception)
         """
-        result,error=self.execute_update_query_with_post(update_query)
-        return result,error
+        result, error = self.execute_update_query_with_post(update_query)
+        return result, error
+
+    def get_tdbloader_command(self, files: List[Path]) -> str:
+        """
+        Build the tdb2.tdbloader docker command for the given dump files.
+
+        The loader classes ship inside fuseki-server.jar, so the server's own
+        image is reused with an overridden entrypoint. The TDB2 dataset is
+        single-writer - the server must be stopped while the loader runs.
+
+        Args:
+            files: dump files to load (from the dumps directory)
+
+        Returns:
+            the docker run command string
+        """
+        loc = f"/fuseki/databases/{self.config.dataset}"
+        dumps_dir = Path(self.config.dumps_dir)
+        file_args = " ".join(f"/dumps/{file.name}" for file in files)
+        command = (
+            f"docker run --rm {self.config.docker_user_flag} --entrypoint java "
+            f"-v {self.config.base_data_dir}:/fuseki "
+            f"-v {dumps_dir}:/dumps "
+            f"{self.config.image} "
+            f"-cp /jena-fuseki/fuseki-server.jar tdb2.tdbloader "
+            f"--loc {loc} {file_args}"
+        )
+        return command
+
+    def upload_dump_files(self, file_pattern: str = None) -> int:
+        """
+        Bulk-load dump files with tdb2.tdbloader directly into the TDB2
+        database files - the native path for the file-backed store, avoiding
+        the HTTP single-POST transaction that faults the mmap'd node table
+        (issue #25).
+
+        Args:
+            file_pattern: Glob pattern for dump files
+
+        Returns:
+            Number of files loaded successfully
+        """
+        container_name = self.config.container_name
+        files = self.get_dump_files(file_pattern)
+        loaded_count = 0
+        if not files:
+            self.log.log("⚠️", container_name, f"No dump files found for pattern: {file_pattern}")
+        else:
+            self.stop()
+            loader_cmd = self.get_tdbloader_command(files)
+            shell_result = self.run_shell_command(
+                loader_cmd,
+                success_msg=f"tdb2.tdbloader loaded {len(files)} file(s)",
+                error_msg="tdb2.tdbloader failed",
+            )
+            if shell_result.success:
+                loaded_count = len(files)
+            self.start()
+        return loaded_count
 
 

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/servers/qlever.py

@@ -5,6 +5,7 @@ Created on 2025-05-28
 """
 
 import os
+import shutil
 from configparser import ConfigParser, ExtendedInterpolation
 from dataclasses import dataclass
 from pathlib import Path
@@ -238,6 +239,71 @@ class QLever(SparqlServer):
 
         return None
 
+    def get_index_commands(self, files: List[Path]) -> List[str]:
+        """
+        Build the qlever CLI commands to (re)index the given dump files.
+
+        QLever loads bulk data by building its index from files - there is no
+        native HTTP bulk-write path; the SPARQL INSERT route is only suitable
+        for small increments.
+
+        Args:
+            files: dump files staged in the data directory
+
+        Returns:
+            list of shell commands to run in the data directory
+        """
+        commands = [
+            "qlever stop",
+            "qlever index --overwrite-existing",
+            f"qlever start --server-container {self.config.container_name}",
+        ]
+        return commands
+
+    def upload_dump_files(self, file_pattern: str = None) -> int:
+        """
+        Bulk-load dump files by rebuilding the QLever index from them -
+        the native path; the turtle-to-INSERT conversion of upload_request
+        is unsuitable for bulk data.
+
+        Args:
+            file_pattern: Glob pattern for dump files
+
+        Returns:
+            Number of files loaded successfully
+        """
+        container_name = self.config.container_name
+        files = self.get_dump_files(file_pattern)
+        loaded_count = 0
+        if not files:
+            self.log.log("⚠️", container_name, f"No dump files found for pattern: {file_pattern}")
+            return loaded_count
+        data_dir = Path(self.config.data_dir)
+        qleverfile_path = data_dir / "Qleverfile"
+        qlever_file = QLeverfile.ofFile(qleverfile_path)
+        if qlever_file is None:
+            self.log.log("❌", container_name, f"no Qleverfile in {data_dir} - run start (setup-config) first")
+            return loaded_count
+        # stage the dumps in the data directory and register them as input files
+        for file in files:
+            target = data_dir / file.name
+            if not target.exists():
+                shutil.copy2(file, target)
+        input_files = " ".join(file.name for file in files)
+        qlever_file.set("index", "INPUT_FILES", input_files)
+        qlever_file.save()
+        ok = True
+        for command in self.get_index_commands(files):
+            shell_result = self.run_shell_command(f"cd {data_dir};{command}")
+            if not shell_result.success:
+                self.log.log("❌", container_name, f"failed: {command}")
+                ok = False
+                break
+        if ok:
+            loaded_count = len(files)
+            self.log.log("✅", container_name, f"index rebuilt from {loaded_count} file(s)")
+        return loaded_count
+
     def upload_request(self, file_content: bytes) -> Response:
         """Upload request for QLever using SPARQL INSERT statements."""
         turtle_data = file_content.decode("utf-8")

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/omnigraph/sparql_server.py

@@ -687,21 +687,52 @@ class SparqlServer:
 
         return load_success
 
-    def load_dump_files(self, file_pattern: str = None) -> int:
+    def get_dump_files(self, file_pattern: str = None) -> List[Path]:
         """
-        Load all dump files matching pattern.
+        Get the dump files matching the given pattern.
 
         Args:
             file_pattern: Glob pattern for dump files
-            use_bulk: Use bulk loader if True, individual files if False
 
         Returns:
-            Number of files loaded successfully
+            sorted list of matching dump file paths
         """
         dump_path: Path = Path(self.config.dumps_dir)
         if file_pattern is None:
             file_pattern = f"*{self.rdf_format.extension}"
         files = sorted(dump_path.glob(file_pattern))
+        return files
+
+    def upload_dump_files(self, file_pattern: str = None) -> int:
+        """
+        Bulk-upload all dump files matching pattern using the server's
+        native bulk load mechanism.
+
+        Subclasses override this with their native loader (e.g. Jena
+        tdb2.tdbloader, Blazegraph REST DataLoader, QLever index build);
+        the default falls back to the HTTP load path.
+
+        Args:
+            file_pattern: Glob pattern for dump files
+
+        Returns:
+            Number of files loaded successfully
+        """
+        loaded_count = self.load_dump_files(file_pattern)
+        return loaded_count
+
+    def load_dump_files(self, file_pattern: str = None) -> int:
+        """
+        Load all dump files matching pattern.
+
+        Args:
+            file_pattern: Glob pattern for dump files
+            use_bulk: Use bulk loader if True, individual files if False
+
+        Returns:
+            Number of files loaded successfully
+        """
+        files = self.get_dump_files(file_pattern)
         loaded_count = 0
         container_name = self.config.container_name
 

{pyomnigraph-0.2.1 → pyomnigraph-0.2.2}/scripts/quickstart

@@ -35,6 +35,7 @@ usage: $0 [options]
   --triplestore <name>  Triple store to use (default: blazegraph)
   --download            Download dataset (for big external datasets)
   --url <url>           Download URL (default: auto-generated from dataset name)
+  -q|--query <query>    Query name with optional @params (e.g., "count" or "search@term=Berlin")
   --no-webui            Don't open web UI after loading
   -h|--help             Show this help message
 
@@ -49,11 +50,13 @@ See https://wiki.bitplan.com/index.php/Pyomnigraph#Quickstart for more info.
 Examples:
   $0
   $0 --dataset gov_full --triplestore jena
-  $0 --dataset gov_full --download --url https://example.com/gov_full.tar.gz
+  $0 --dataset gov_full --download -q "count"
+  $0 -q "Triplestores"
 EOF
   exit 1
 }
 
+
 #
 # download_dataset - download the dataset if not cached
 # $1: l_tar_file - path to tar file
@@ -112,15 +115,15 @@ load_dataset() {
   local l_dataset="$2"
   action "Loading $l_dataset dataset into $l_triplestore"
   omnigraph -s "$l_triplestore" --cmd load --datasets "$l_dataset" || error "Failed to load dataset"
+  success "$l_dataset loaded"
 }
 
 #
-# open_webui - open the web UI
+# open_webui - open the web UI with optional query
 # $1: l_triplestore - name of triplestore
 #
 open_webui() {
   local l_triplestore="$1"
-  success "Done! Opening web UI"
   omnigraph -s "$l_triplestore" --cmd webui
 }
 

pyomnigraph-0.2.2/tests/test_rdf_dataset_params.py

@@ -0,0 +1,58 @@
+"""
+Created on 2026-07-22
+
+Tests for npq (named parameterized query) support in RdfDataset - issue #36.
+
+@author: wf
+"""
+
+from omnigraph.ominigraph_paths import OmnigraphPaths
+from omnigraph.rdf_dataset import RdfDataset, RdfDatasets
+from tests.basetest import Basetest
+
+
+class TestRdfDatasetParams(Basetest):
+    """
+    test npq parameter support in RdfDataset
+    """
+
+    def setUp(self, debug=False, profile=True):
+        Basetest.setUp(self, debug=debug, profile=profile)
+        self.ogp = OmnigraphPaths()
+        self.datasets_yaml_path = self.ogp.examples_dir / "datasets.yaml"
+
+    def get_npq_dataset(self, orcids: str = '"0000-0002-0821-6995"') -> RdfDataset:
+        """create an npq test dataset with the given orcids param"""
+        dataset = RdfDataset(
+            name="npq-test",
+            endpoint_url="https://example.org/sparql",
+            select_pattern="VALUES ?orcid { {{ orcids }} } ?author ?p ?orcid",
+            construct_template="?author ?p ?orcid",
+            params={"orcids": orcids},
+        )
+        return dataset
+
+    def test_params_applied_from_yaml_defaults(self):
+        """dataset params are substituted into the query templates"""
+        dataset = self.get_npq_dataset()
+        self.assertNotIn("{{", dataset.select_pattern)
+        self.assertIn('VALUES ?orcid { "0000-0002-0821-6995" }', dataset.select_pattern)
+        self.assertIn('"0000-0002-0821-6995"', dataset.count_query.query)
+
+    def test_params_cli_override(self):
+        """apply_params re-applies from raw templates so overrides work"""
+        dataset = self.get_npq_dataset()
+        dataset.apply_params({"orcids": '"0000-0001-6324-7164"'})
+        dataset.build_queries()
+        self.assertIn('"0000-0001-6324-7164"', dataset.select_pattern)
+        self.assertNotIn("0000-0002-0821-6995", dataset.select_pattern)
+        self.assertIn('"0000-0001-6324-7164"', dataset.count_query.query)
+
+    def test_example_npq_datasets(self):
+        """the papers_of_my_network example datasets resolve their params"""
+        datasets = RdfDatasets.ofYaml(str(self.datasets_yaml_path))
+        for ds_id in ["papers_of_my_network_wikidata", "papers_of_my_network_dblp"]:
+            dataset = datasets.datasets.get(ds_id)
+            self.assertIsNotNone(dataset, ds_id)
+            self.assertNotIn("{{", dataset.select_pattern)
+            self.assertIn("0000-0002-0821-6995", dataset.select_pattern)

pyomnigraph-0.2.2/tests/test_upload.py

@@ -0,0 +1,98 @@
+"""
+Created on 2026-07-22
+
+Tests for the upload command - native per-server bulk load (issue #27,
+root cause fix for issue #25).
+
+@author: wf
+"""
+
+import tempfile
+from pathlib import Path
+
+from omnigraph.ominigraph_paths import OmnigraphPaths
+from omnigraph.omniserver import OmniServer
+from omnigraph.sparql_server import ServerEnv
+from tests.basetest import Basetest
+
+
+class TestUpload(Basetest):
+    """
+    test the native bulk upload command
+    """
+
+    def setUp(self, debug=False, profile=True):
+        """
+        setUp the test environment
+        """
+        Basetest.setUp(self, debug=debug, profile=profile)
+        self.ogp = OmnigraphPaths()
+        self.servers_yaml_path = self.ogp.examples_dir / "servers.yaml"
+        self.env = ServerEnv(debug=self.debug)
+        self.omni_server = OmniServer(env=self.env)
+        self.servers_dict = self.omni_server.servers(self.servers_yaml_path, filter_active=False)
+        # dumps_dir is normally set per dataset by the load/upload command
+        self.dumps_dir = tempfile.mkdtemp(prefix="omnigraph-dumps-")
+        for server in self.servers_dict.values():
+            server.config.dumps_dir = self.dumps_dir
+
+    def test_upload_command_registered(self):
+        """
+        the upload command must be available in the server command registry
+        """
+        server_cmds = self.omni_server.get_server_commands()
+        self.assertIn("upload", server_cmds)
+
+    def test_jena_tdbloader_command(self):
+        """
+        Jena builds a tdb2.tdbloader docker command against the TDB2 location
+        """
+        jena = self.servers_dict.get("jena")
+        self.assertIsNotNone(jena)
+        dumps_dir = jena.config.dumps_dir
+        files = [Path(dumps_dir) / "test1.ttl", Path(dumps_dir) / "test2.ttl"]
+        command = jena.get_tdbloader_command(files)
+        if self.debug:
+            print(command)
+        self.assertIn("tdb2.tdbloader", command)
+        self.assertIn("--entrypoint java", command)
+        self.assertIn(f"--loc /fuseki/databases/{jena.config.dataset}", command)
+        self.assertIn(jena.config.image, command)
+        self.assertIn("/dumps/test1.ttl", command)
+        self.assertIn("/dumps/test2.ttl", command)
+
+    def test_blazegraph_dataloader_xml(self):
+        """
+        Blazegraph builds a DataLoader servlet properties XML
+        """
+        blazegraph = self.servers_dict.get("blazegraph")
+        self.assertIsNotNone(blazegraph)
+        xml = blazegraph.get_dataloader_xml("/data/dumps")
+        if self.debug:
+            print(xml)
+        self.assertIn('<entry key="namespace">kb</entry>', xml)
+        self.assertIn('<entry key="fileOrDirs">/data/dumps</entry>', xml)
+        self.assertIn('<entry key="propertyFile">/RWStore.properties</entry>', xml)
+        self.assertIn("dataloader", blazegraph.config.dataloader_url)
+
+    def test_qlever_index_commands(self):
+        """
+        QLever rebuilds its index via the qlever CLI instead of INSERT statements
+        """
+        qlever = self.servers_dict.get("qlever")
+        self.assertIsNotNone(qlever)
+        commands = qlever.get_index_commands([])
+        if self.debug:
+            print(commands)
+        self.assertTrue(any("qlever index" in command for command in commands))
+        self.assertTrue(any("qlever start" in command for command in commands))
+
+    def test_upload_fallback_no_files(self):
+        """
+        the base upload falls back to the HTTP path; with no dump files
+        matching it must report zero loads without contacting any server
+        """
+        oxigraph = self.servers_dict.get("oxigraph")
+        self.assertIsNotNone(oxigraph)
+        loaded_count = oxigraph.upload_dump_files("*.does-not-exist")
+        self.assertEqual(0, loaded_count)

pyomnigraph-0.2.1/omnigraph/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.1"