pyomnigraph 0.0.3__py3-none-any.whl

omnigraph/__init__.py

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

omnigraph/blazegraph.py

@@ -0,0 +1,229 @@
+from dataclasses import dataclass
+import glob
+from pathlib import Path
+import re
+
+from omnigraph.persistent_log import Log
+from omnigraph.shell import Shell
+from omnigraph.sparql_server import ServerConfig, SparqlServer, ServerEnv
+from tqdm import tqdm
+
+
+@dataclass
+class BlazegraphConfig(ServerConfig):
+    """
+    Blazegraph configuration
+    """
+
+    def __post_init__(self):
+        super().__post_init__()
+        blazegraph_base = f"{self.base_url}/bigdata"
+        self.status_url = f"{blazegraph_base}/status"
+        self.sparql_url = f"{blazegraph_base}/namespace/kb/sparql"
+        self.dataloader_url = f"{blazegraph_base}/dataloader"
+        self.docker_run_command = f"docker run -d --name {self.container_name} -p {self.port}:8080 {self.image}"
+
+
+class Blazegraph(SparqlServer):
+    """
+    Dockerized Blazegraph SPARQL server
+    """
+
+    def __init__(
+        self,
+        config: ServerConfig,
+        env: ServerEnv
+    ):
+        """
+        Initialize the Blazegraph manager.
+
+        Args:
+            config: Server configuration
+            env: Server environment (includes log, shell, debug, verbose)
+        """
+        super().__init__(config=config, env=env)
+        self.dataloader_url = f"{self.config.base_url}/dataloader"
+
+    def status(self) -> dict:
+        """
+        Get Blazegraph status information.
+
+        Returns:
+            Dictionary with status information, empty dict if error
+        """
+        status_dict = {}
+
+        result = self._make_request("GET", self.config.status_url, timeout=2)
+
+        if result["success"]:
+            status_dict["status"] = "ready"
+            html_content = result["content"]
+            name_value_pattern = r'(?:<span id="(?P<name1>[^"]+)">(?P<value1>[^<]+)</span[^>]*>|&#47;(?P<name2>[^=]+)=(?P<value2>[^\s&#]+))'
+            matches = re.finditer(name_value_pattern, html_content, re.DOTALL)
+
+            for match in matches:
+                for name_group, value_group in {
+                    "name1": "value1",
+                    "name2": "value2",
+                }.items():
+                    name = match.group(name_group)
+                    if name:
+                        value = match.group(value_group)
+                        sanitized_value = value.replace("</p", "").replace("&#47;", "/")
+                        sanitized_name = name.replace("-", "_").replace("/", "_")
+                        sanitized_name = sanitized_name.replace("&#47;", "/")
+                        if not sanitized_name.startswith("/"):
+                            status_dict[sanitized_name] = sanitized_value
+                        break
+        else:
+            if result.get("error"):
+                status_dict["status"] = f"error: {result['error']}"
+            else:
+                status_dict["status"] = f"status_code: {result['status_code']}"
+
+        return status_dict
+
+    def load_file(self, filepath: str) -> bool:
+        """
+        Load a single RDF file into Blazegraph.
+
+        Args:
+            filepath: Path to RDF file
+
+        Returns:
+            True if loaded successfully
+        """
+        load_success = False
+        try:
+            with open(filepath, "rb") as f:
+                result = self._make_request(
+                    "POST",
+                    self.config.sparql_url,
+                    headers={"Content-Type": "text/turtle"},
+                    data=f.read(),
+                    timeout=300,
+                )
+
+            if result["success"]:
+                self.log.log("✅", self.name, f"Loaded {filepath}")
+                load_success = True
+            else:
+                error_msg = result.get("error", f"HTTP {result['status_code']}")
+                self.log.log("❌", self.name, f"Failed to load {filepath}: {error_msg}")
+                load_success = False
+
+        except Exception as e:
+            self.log.log("❌", self.name, f"Exception loading {filepath}: {e}")
+            load_success = False
+
+        return load_success
+
+    def load_files_bulk(self, file_list: list) -> bool:
+        """
+        Load multiple files using Blazegraph's bulk loader REST API.
+
+        Args:
+            file_list: List of file paths to load
+
+        Returns:
+            True if loaded successfully
+        """
+        bulk_load_success = False
+
+        if not file_list:
+            bulk_load_success = False
+        else:
+            # Convert to absolute paths
+            abs_paths = [str(Path(f).absolute()) for f in file_list]
+
+            properties = f"""<?xml version="1.0" encoding="UTF-8"?>
+            <properties>
+                <entry key="format">turtle</entry>
+                <entry key="quiet">false</entry>
+                <entry key="verbose">1</entry>
+                <entry key="namespace">kb</entry>
+                <entry key="fileOrDirs">{','.join(abs_paths)}</entry>
+            </properties>"""
+
+            result = self._make_request(
+                "POST",
+                self.dataloader_url,
+                headers={"Content-Type": "application/xml"},
+                data=properties,
+                timeout=3600,
+            )
+
+            if result["success"]:
+                self.log.log("✅", self.container_name, f"Bulk loaded {len(file_list)} files")
+                bulk_load_success = True
+            else:
+                error_msg = result.get("error", f"HTTP {result['status_code']}")
+                self.log.log("❌", self.container_name, f"Bulk load failed: {error_msg}")
+                bulk_load_success = False
+
+        return bulk_load_success
+
+    def load_dump_files(self, file_pattern: str = "dump_*.ttl", use_bulk: bool = True) -> 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 = sorted(glob.glob(file_pattern))
+        loaded_count = 0
+
+        if not files:
+            self.log.log(
+                "⚠️",
+                self.container_name,
+                f"No files found matching pattern: {file_pattern}",
+            )
+            loaded_count = 0
+        else:
+            self.log.log("✅", self.container_name, f"Found {len(files)} files to load")
+
+            if use_bulk:
+                bulk_result = self.load_files_bulk(files)
+                loaded_count = len(files) if bulk_result else 0
+            else:
+                loaded_count = 0
+                for filepath in tqdm(files, desc="Loading files"):
+                    file_result = self.load_file(filepath)
+                    if file_result:
+                        loaded_count += 1
+                    else:
+                        self.log.log("❌", self.container_name, f"Failed to load: {filepath}")
+
+        return loaded_count
+
+    def test_geosparql(self) -> bool:
+        """
+        Test if GeoSPARQL functions work.
+
+        Returns:
+            True if GeoSPARQL is available
+        """
+        test_query = """
+        PREFIX geo: <http://www.opengis.net/ont/geosparql#>
+        PREFIX geof: <http://www.opengis.net/def/function/geosparql/>
+
+        SELECT * WHERE {
+            BIND(geof:distance("POINT(0 0)"^^geo:wktLiteral, "POINT(1 1)"^^geo:wktLiteral) AS ?dist)
+        } LIMIT 1
+        """
+
+        result = self._make_request(
+            "POST",
+            self.sparql_url,
+            data={"query": test_query},
+            headers={"Accept": "application/sparql-results+json"},
+            timeout=10,
+        )
+
+        geosparql_available = result["success"]
+        return geosparql_available

omnigraph/jena.py

@@ -0,0 +1,100 @@
+"""
+Created on 2025-05-28
+
+Apache Jena SPARQL support
+
+@author: wf
+"""
+
+from dataclasses import dataclass
+
+from omnigraph.persistent_log import Log
+from omnigraph.shell import Shell
+from omnigraph.sparql_server import ServerConfig
+
+
+@dataclass
+class JenaConfig(ServerConfig):
+    """
+    Jena Fuseki configuration
+    """
+
+    dataset: str = "ds"
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.status_url = f"{self.base_url}/$/ping"
+        self.sparql_url = f"{self.base_url}/{self.dataset}/sparql"
+        self.update_url = f"{self.base_url}/{self.dataset}/update"
+        self.upload_url = f"{self.base_url}/{self.dataset}/data"
+        self.docker_run_command = (
+            f"docker run -d --name {self.container_name} -p {self.port}:3030 -e ADMIN_PASSWORD=admin {self.image}"
+        )
+
+
+def __init__(
+    self,
+    config: ServerConfig,
+    log: Log = None,
+    shell: Shell = None,
+    debug: bool = False,
+):
+    """
+    Initialize the Jena Fuseki manager.
+
+    Args:
+        config: Jena server configuration
+        log: Log instance for logging
+        shell: Shell instance for Docker commands
+        debug: Enable debug output
+    """
+    super().__init__(config=config, log=log, shell=shell, debug=debug)
+    self.dataset = getattr(config, "dataset", "ds")
+    self.update_url = f"{self.config.base_url}/{self.dataset}/update"
+    self.upload_url = f"{self.config.base_url}/{self.dataset}/data"
+
+
+from omnigraph.sparql_server import SparqlServer
+
+
+class Jena(SparqlServer):
+    """
+    Dockerized Apache Jena Fuseki SPARQL server
+    """
+
+    def __init__(
+        self,
+        config: ServerConfig,
+        log: Log = None,
+        shell: Shell = None,
+        debug: bool = False,
+    ):
+        """
+        Initialize the Jena Fuseki manager.
+
+        Args:
+            config: Jena server configuration
+            log: Log instance for logging
+            shell: Shell instance for Docker commands
+            debug: Enable debug output
+        """
+        super().__init__(config=config, log=log, shell=shell, debug=debug)
+        self.dataset = getattr(config, "dataset", "ds")
+        self.update_url = f"{self.config.base_url}/{self.dataset}/update"
+        self.upload_url = f"{self.config.base_url}/{self.dataset}/data"
+
+    def status(self) -> dict:
+        """
+        Get Jena Fuseki status information.
+
+        Returns:
+            Dictionary with status information, empty dict if error
+        """
+        result = self._make_request("GET", self.config.status_url, timeout=2)
+
+        if result["success"]:
+            status = {"status": "ready"}
+        else:
+            error_msg = result.get("error", f"status_code: {result['status_code']}")
+            status = {"status": f"error: {error_msg}"}
+        return status

omnigraph/ominigraph_paths.py

@@ -0,0 +1,22 @@
+"""
+Created on 27.05.2025
+
+@author: wf
+"""
+
+from pathlib import Path
+
+
+class OmnigraphPaths:
+    """
+    Omnigraph Default Paths
+    """
+
+    def __init__(self):
+        """
+        constructor
+        """
+        self.home_dir = Path.home()
+        self.omnigraph_dir = self.home_dir / ".omnigraph"
+        self.omnigraph_dir.mkdir(exist_ok=True)
+        self.examples_dir = (Path(__file__).parent / "resources" / "examples").resolve()

omnigraph/omnigraph_cmd.py

@@ -0,0 +1,220 @@
+"""
+Created on 2025-05-28
+
+@author: wf
+"""
+from argparse import ArgumentParser, RawDescriptionHelpFormatter, Namespace
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Dict, List
+import webbrowser
+
+from omnigraph.ominigraph_paths import OmnigraphPaths
+from omnigraph.omniserver import OmniServer
+from omnigraph.sparql_server import SparqlServer, ServerEnv
+from omnigraph.version import Version
+
+
+@dataclass
+class ServerCmd:
+    """
+    Command wrapper for server operations.
+    """
+
+    def __init__(self, title: str, func: Callable):
+        """
+        Initialize server command.
+
+        Args:
+            title: Description of the command
+            func: Function to execute
+        """
+        self.title = title
+        self.func = func
+
+    def run(self, verbose: bool = True) -> any:
+        """
+        Execute the server command.
+
+        Args:
+            verbose: Whether to print result
+
+        Returns:
+            Result from function execution
+        """
+        result = self.func()
+        if verbose:
+            print(f"{self.title}: {result}")
+        return result
+
+class OmnigraphCmd:
+    """
+    Command line interface for omnigraph.
+    """
+
+    def __init__(self):
+        """
+        Initialize command line interface.
+        """
+        self.ogp = OmnigraphPaths()
+        self.default_yaml_path = self.ogp.examples_dir / "servers.yaml"
+        self.version = Version()
+        self.program_version_message = f"{self.version.name} {self.version.version}"
+        self.parser = self.getArgParser()
+
+    def getArgParser(self, description: str = None, version_msg=None) -> ArgumentParser:
+        """
+        Setup command line argument parser
+
+        Args:
+            description(str): the description
+            version_msg(str): the version message
+
+        Returns:
+            ArgumentParser: the argument parser
+        """
+        if description is None:
+            description = self.version.description
+        if version_msg is None:
+            version_msg = self.program_version_message
+
+        parser = ArgumentParser(
+            description=description, formatter_class=RawDescriptionHelpFormatter
+        )
+        parser.add_argument(
+            "-a",
+            "--about",
+            help="show about info [default: %(default)s]",
+            action="store_true",
+        )
+        parser.add_argument(
+            "-c","--config",
+            type=str,
+            default=str(self.default_yaml_path),
+            help="Path to server configuration YAML file [default: %(default)s]"
+        )
+        parser.add_argument(
+            "--cmd",
+            nargs="+",
+            help="commands to execute on servers: start, stop, status"
+        )
+        parser.add_argument(
+            "-d",
+            "--debug",
+            action="store_true",
+            help="show debug info [default: %(default)s]",
+        )
+        parser.add_argument(
+            "-l",
+            "--list-servers",
+            action="store_true",
+            help="List available servers [default: %(default)s]"
+        )
+        parser.add_argument(
+            "-s","--servers",
+            nargs="+",
+            default=["blazegraph"],
+            help="servers: servers to work with - all is an alias for all servers [default: %(default)s]"
+        )
+        parser.add_argument(
+            "-v",
+            "--verbose",
+            action="store_true",
+            help="show verbose output [default: %(default)s]",
+        )
+        parser.add_argument("-V", "--version", action="version", version=version_msg)
+        return parser
+
+    def getServers(self) -> Dict[str, SparqlServer]:
+        """
+        Get the servers to work with.
+
+        Returns:
+            Dictionary of active servers
+        """
+        servers = {}
+        server_names = self.args.servers
+        if "all" in server_names:
+            server_names = list(self.all_servers.keys())
+        for server_name in server_names:
+            server = self.all_servers.get(server_name)
+            if server:
+                servers[server_name] = server
+        return servers
+
+    def run_cmds(self, server: SparqlServer, cmds: List[str]) -> bool:
+        """
+        Run commands on a server.
+
+        Args:
+            server: Server instance
+            cmds: List of commands to execute
+
+        Returns:
+            True if any commands were handled
+        """
+        handled=False
+        s_cmds = {
+            "start": ServerCmd(title=f"start {server.name}", func=server.start),
+            "stop": ServerCmd(title=f"stop {server.name}", func=server.stop),
+            "status": ServerCmd(title=f"status {server.name}", func=server.status)
+        }
+        if cmds:
+            for cmd in cmds:
+                s_cmd=s_cmds.get(cmd)
+                if s_cmd:
+                    s_cmd.run()
+                    handled=True
+                else:
+                    print(f"unsupported command {cmd}")
+        return handled
+
+
+    def handle_args(self,args:Namespace) -> bool:
+        """
+        Handle command line arguments.
+
+        Returns:
+            bool: True if arguments were handled, False otherwise
+            args: Namespace
+        """
+        self.args=args
+        handled = False
+        self.all_servers={}
+        if Path(self.args.config).exists():
+            env=ServerEnv(debug=args.debug,verbose=args.verbose)
+            omni_server=OmniServer(env=env)
+            self.all_servers = omni_server.servers(args.config)
+        else:
+            print(f"Config file not found: {args.config}")
+
+        if args.about:
+            print(self.program_version_message)
+            print(f"{len(self.servers)} servers configured")
+            print(f"see {self.version.doc_url}")
+            webbrowser.open(self.version.doc_url)
+            handled = True
+
+        if self.args.list_servers:
+            print("Available servers:")
+            for name, server in self.servers.items():
+                print(f"  {name}: {server.config.server}")
+            handled = True
+
+        self.servers=self.getServers()
+        for server in self.servers.values():
+            handled=handled or self.run_cmds(server,cmds=args.cmd)
+
+        return handled
+
+def main():
+    """
+    Main entry point for command line interface.
+    """
+    cmd = OmnigraphCmd()
+    args = cmd.parser.parse_args()
+    cmd.handle_args(args)
+
+
+if __name__ == "__main__":
+    main()

omnigraph/omniserver.py

@@ -0,0 +1,72 @@
+"""
+Created on 2025-05-28
+
+@author: wf
+"""
+
+from dataclasses import asdict
+from pathlib import Path
+from typing import Dict
+
+from omnigraph.blazegraph import Blazegraph, BlazegraphConfig
+from omnigraph.jena import Jena, JenaConfig
+from omnigraph.qlever import QLever, QLeverConfig
+from omnigraph.sparql_server import ServerEnv,ServerConfig, ServerConfigs, SparqlServer
+
+
+class OmniServer:
+    """
+    Factory class for creating and managing SPARQL server instances.
+    """
+
+    def __init__(self,env:ServerEnv):
+        """
+        constructor
+        """
+        self.env=env
+
+    def server4Config(self, config: ServerConfig) -> SparqlServer:
+        """
+        Create a SparqlServer instance based on server type in config.
+
+        Args:
+            config: ServerConfig with server type and settings
+
+        Returns:
+            SparqlServer instance of appropriate type
+        """
+        server_instance = None
+        config_dict = asdict(config)
+
+        if config.server == "blazegraph":
+            blazegraph_config = BlazegraphConfig(**config_dict)
+            server_instance = Blazegraph(config=blazegraph_config,env=self.env)
+        elif config.server == "qlever":
+            qlever_config = QLeverConfig(**config_dict)
+            server_instance = QLever(config=qlever_config,env=self.env)
+        elif config.server == "jena":
+            jena_config = JenaConfig(**config_dict)
+            server_instance = Jena(config=jena_config,env=self.env)
+
+        return server_instance
+
+    def servers(self, yaml_path: Path) -> Dict[str, SparqlServer]:
+        """
+        Load active servers from YAML configuration.
+
+        Args:
+            yaml_path: Path to YAML configuration file
+
+        Returns:
+            Dictionary mapping server names to SparqlServer instances
+        """
+        server_configs = ServerConfigs.ofYaml(yaml_path)
+        servers_dict = {}
+
+        for server_name, config in server_configs.servers.items():
+            if config.active:
+                server_instance = self.server4Config(config)
+                if server_instance:
+                    servers_dict[server_name] = server_instance
+
+        return servers_dict