qlever 0.5.21__py3-none-any.whl → 0.5.23__py3-none-any.whl

qlever/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import sys
+from importlib import import_module
 from pathlib import Path
 
 
@@ -10,9 +11,19 @@ def snake_to_camel(str):
     return "".join([w.capitalize() for w in str.replace("-", "_").split("_")])
 
 
+# Get the name of the script (without the path and without the extension).
+script_name = Path(sys.argv[0]).stem
+
+ENGINE_NAMES = {
+    "qlever": "QLever",
+    "qmdb": "MillenniumDB",
+}
+# Default engine_name = script_name without starting 'q' and capitalized
+engine_name = ENGINE_NAMES.get(script_name, script_name[1:].capitalize())
+
 # Each module in `qlever/commands` corresponds to a command. The name
 # of the command is the base name of the module file.
-package_path = Path(__file__).parent
+package_path = Path(__file__).parent.parent / script_name
 command_names = [
     Path(p).stem
     for p in package_path.glob("commands/*.py")
@@ -22,19 +33,15 @@ command_names = [
 # Dynamically load all the command classes and create an object for each.
 command_objects = {}
 for command_name in command_names:
-    module_path = f"qlever.commands.{command_name}"
-    class_name = snake_to_camel(command_name) + "Command"
+    module_path = f"{script_name}.commands.{command_name}"
     try:
-        module = __import__(module_path, fromlist=[class_name])
+        module = import_module(module_path)
     except ImportError as e:
         raise Exception(
-            f"Could not import class {class_name} from module "
-            f"{module_path} for command {command_name}: {e}"
-        )
+            f"Could not import module {module_path} for {script_name}: {e}"
+        ) from e
     # Create an object of the class and store it in the dictionary. For the
     # commands, take - instead of _.
+    class_name = snake_to_camel(command_name) + "Command"
     command_class = getattr(module, class_name)
     command_objects[command_name.replace("_", "-")] = command_class()
-
-# Get the name of the script (without the path and without the extension).
-script_name = Path(sys.argv[0]).stem

qlever/command.py

@@ -81,7 +81,7 @@ class QleverCommand(ABC):
         log.info("")
         if only_show:
             log.info(
-                'You called "qlever ... --show", therefore the command '
+                'You passed the argument "--show", therefore the command '
                 'is only shown, but not executed (omit the "--show" to '
                 "execute it)"
             )

qlever/commands/cache_stats.py

@@ -28,7 +28,7 @@ class CacheStatsCommand(QleverCommand):
     def additional_arguments(self, subparser) -> None:
         subparser.add_argument("--server-url",
                                help="URL of the QLever server, default is "
-                               "localhost:{port}")
+                               "{host_name}:{port}")
         subparser.add_argument("--detailed",
                                action="store_true",
                                default=False,
@@ -37,7 +37,7 @@ class CacheStatsCommand(QleverCommand):
     def execute(self, args) -> bool:
         # Construct the two curl commands.
         server_url = (args.server_url if args.server_url
-                      else f"localhost:{args.port}")
+                      else f"{args.host_name}:{args.port}")
         cache_stats_cmd = (f"curl -s {server_url} "
                            f"--data-urlencode \"cmd=cache-stats\"")
         cache_settings_cmd = (f"curl -s {server_url} "

qlever/commands/clear_cache.py

@@ -17,22 +17,25 @@ class ClearCacheCommand(QleverCommand):
         pass
 
     def description(self) -> str:
-        return ("Clear the query processing cache")
+        return "Clear the query processing cache"
 
     def should_have_qleverfile(self) -> bool:
         return True
 
-    def relevant_qleverfile_arguments(self) -> dict[str: list[str]]:
-        return {"server": ["port", "access_token"]}
+    def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
+        return {"server": ["host_name", "port", "access_token"]}
 
     def additional_arguments(self, subparser) -> None:
-        subparser.add_argument("--server-url",
-                               help="URL of the QLever server, default is "
-                               "localhost:{port}")
-        subparser.add_argument("--complete", action="store_true",
-                               default=False,
-                               help="Clear the cache completely, including "
-                               "the pinned queries")
+        subparser.add_argument(
+            "--server-url",
+            help="URL of the QLever server, default is {host_name}:{port}",
+        )
+        subparser.add_argument(
+            "--complete",
+            action="store_true",
+            default=False,
+            help="Clear the cache completely, including the pinned queries",
+        )
 
     def execute(self, args) -> bool:
         # Construct command line and show it.
@@ -40,22 +43,27 @@ class ClearCacheCommand(QleverCommand):
         if args.server_url:
             clear_cache_cmd += f" {args.server_url}"
         else:
-            clear_cache_cmd += f" localhost:{args.port}"
+            clear_cache_cmd += f" {args.host_name}:{args.port}"
         cmd_val = "clear-cache-complete" if args.complete else "clear-cache"
-        clear_cache_cmd += f" --data-urlencode \"cmd={cmd_val}\""
+        clear_cache_cmd += f' --data-urlencode "cmd={cmd_val}"'
         if args.complete:
-            clear_cache_cmd += (f" --data-urlencode access-token="
-                                f"\"{args.access_token}\"")
+            clear_cache_cmd += (
+                f" --data-urlencode access-token=" f'"{args.access_token}"'
+            )
         self.show(clear_cache_cmd, only_show=args.show)
         if args.show:
             return True
 
         # Execute the command.
         try:
-            clear_cache_cmd += " -w \" %{http_code}\""
-            result = subprocess.run(clear_cache_cmd, shell=True,
-                                    capture_output=True, text=True,
-                                    check=True).stdout
+            clear_cache_cmd += ' -w " %{http_code}"'
+            result = subprocess.run(
+                clear_cache_cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                check=True,
+            ).stdout
             match = re.match(r"^(.*) (\d+)$", result, re.DOTALL)
             if not match:
                 raise Exception(f"Unexpected output:\n{result}")
@@ -77,6 +85,8 @@ class ClearCacheCommand(QleverCommand):
         log.info("")
         args.detailed = False
         if not CacheStatsCommand().execute(args):
-            log.error("Clearing the cache was successful, but showing the "
-                      "cache stats failed {e}")
+            log.error(
+                "Clearing the cache was successful, but showing the "
+                "cache stats failed {e}"
+            )
         return True

qlever/commands/example_queries.py

@@ -31,7 +31,7 @@ class ExampleQueriesCommand(QleverCommand):
         return False
 
     def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
-        return {"server": ["port"], "ui": ["ui_config"]}
+        return {"server": ["host_name", "port"], "ui": ["ui_config"]}
 
     def additional_arguments(self, subparser) -> None:
         subparser.add_argument(
@@ -240,7 +240,7 @@ class ExampleQueriesCommand(QleverCommand):
         sparql_endpoint = (
             args.sparql_endpoint
             if args.sparql_endpoint
-            else f"localhost:{args.port}"
+            else f"{args.host_name}:{args.port}"
         )
         self.show(
             f"Obtain queries via: {get_queries_cmd}\n"

qlever/commands/index.py

@@ -9,6 +9,7 @@ from qlever.command import QleverCommand
 from qlever.containerize import Containerize
 from qlever.log import log
 from qlever.util import (
+    binary_exists,
     get_existing_index_files,
     get_total_file_size,
     run_command,
@@ -267,16 +268,7 @@ class IndexCommand(QleverCommand):
 
         # When running natively, check if the binary exists and works.
         if args.system == "native":
-            try:
-                run_command(f"{args.index_binary} --help")
-            except Exception as e:
-                log.error(
-                    f'Running "{args.index_binary}" failed, '
-                    f"set `--index-binary` to a different binary or "
-                    f"set `--system to a container system`"
-                )
-                log.info("")
-                log.info(f"The error message was: {e}")
+            if not binary_exists(args.index_binary, "index-binary"):
                 return False
 
         # Check if all of the input files exist.

qlever/commands/query.py

@@ -38,7 +38,7 @@ class QueryCommand(QleverCommand):
         return False
 
     def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
-        return {"server": ["port", "access_token"]}
+        return {"server": ["host_name", "port", "access_token"]}
 
     def additional_arguments(self, subparser) -> None:
         subparser.add_argument(
@@ -109,7 +109,7 @@ class QueryCommand(QleverCommand):
         sparql_endpoint = (
             args.sparql_endpoint
             if args.sparql_endpoint
-            else f"localhost:{args.port}"
+            else f"{args.host_name}:{args.port}"
         )
         curl_cmd = (
             f"curl -s {sparql_endpoint}"

qlever/commands/settings.py

@@ -32,6 +32,7 @@ class SettingsCommand(QleverCommand):
             "cache-max-num-entries",
             "cache-max-size",
             "cache-max-size-single-entry",
+            "cache-service-results",
             "default-query-timeout",
             "group-by-disable-index-scan-optimizations",
             "group-by-hash-map-enabled",

qlever/commands/start.py

@@ -10,7 +10,7 @@ from qlever.commands.stop import StopCommand
 from qlever.commands.warmup import WarmupCommand
 from qlever.containerize import Containerize
 from qlever.log import log
-from qlever.util import is_qlever_server_alive, run_command
+from qlever.util import binary_exists, is_qlever_server_alive, run_command
 
 
 # Construct the command line based on the config file.
@@ -71,22 +71,6 @@ def wrap_command_in_container(args, start_cmd) -> str:
     return start_cmd
 
 
-# When running natively, check if the binary exists and works.
-def check_binary(binary) -> bool:
-    try:
-        run_command(f"{binary} --help")
-        return True
-    except Exception as e:
-        log.error(
-            f'Running "{binary}" failed, '
-            f"set `--server-binary` to a different binary or "
-            f"set `--system to a container system`"
-        )
-        log.info("")
-        log.info(f"The error message was: {e}")
-        return False
-
-
 # Set the index description.
 def set_index_description(access_arg, port, desc) -> bool:
     curl_cmd = (
@@ -160,12 +144,6 @@ class StartCommand(QleverCommand):
         }
 
     def additional_arguments(self, subparser) -> None:
-        # subparser.add_argument("--kill-existing-with-same-name",
-        #                        action="store_true",
-        #                        default=False,
-        #                        help="If a QLever server is already running "
-        #                             "with the same name, kill it before "
-        #                             "starting a new server")
         subparser.add_argument(
             "--kill-existing-with-same-port",
             action="store_true",
@@ -226,12 +204,11 @@ class StartCommand(QleverCommand):
 
         # When running natively, check if the binary exists and works.
         if args.system == "native":
-            ret = check_binary(args.server_binary)
-            if not ret:
+            if not binary_exists(args.server_binary, "server-binary"):
                 return False
 
         # Check if a QLever server is already running on this port.
-        endpoint_url = f"http://localhost:{args.port}"
+        endpoint_url = f"http://{args.host_name}:{args.port}"
         if is_qlever_server_alive(endpoint_url):
             log.error(f"QLever server already running on {endpoint_url}")
             log.info("")

qlever/commands/stop.py

@@ -1,37 +1,25 @@
 from __future__ import annotations
-import re
-import psutil
+
 from qlever.command import QleverCommand
 from qlever.commands.status import StatusCommand
 from qlever.containerize import Containerize
 from qlever.log import log
-from qlever.util import show_process_info
-
-# try to kill the given process, return true iff it was killed successfully.
-# the process_info is used for logging.
-def stop_process(proc, pinfo):
-    try:
-        proc.kill()
-        log.info(f"Killed process {pinfo['pid']}")
-        return True
-    except Exception as e:
-        log.error(f"Could not kill process with PID "
-                  f"{pinfo['pid']} ({e}) ... try to kill it "
-                  f"manually")
-        log.info("")
-        show_process_info(proc, "", show_heading=True)
-        return False
+from qlever.util import stop_process_with_regex
 
 
-# try to stop and remove container. return True iff it was stopped
-# successfully. Gives log info accordingly.
-def stop_container(server_container):
+def stop_container(server_container: str) -> bool:
+    """
+    Try to stop and remove container. return True iff it was stopped
+    successfully. Gives log info accordingly.
+    """
     for container_system in Containerize.supported_systems():
         if Containerize.stop_and_remove_container(
-                container_system, server_container):
-            log.info(f"{container_system.capitalize()} container with "
-                     f"name \"{server_container}\" stopped "
-                     f" and removed")
+            container_system, server_container
+        ):
+            log.info(
+                f"{container_system.capitalize()} container with "
+                f'name "{server_container}" stopped and removed'
+            )
             return True
     return False
 
@@ -45,7 +33,7 @@ class StopCommand(QleverCommand):
         pass
 
     def description(self) -> str:
-        return "Stop QLever server for a given datasedataset or port"
+        return "Stop QLever server for a given dataset or port"
 
     def should_have_qleverfile(self) -> bool:
         return True
@@ -85,21 +73,9 @@ class StopCommand(QleverCommand):
         # Check if there is a process running on the server port using psutil.
         # NOTE: On MacOS, some of the proc's returned by psutil.process_iter()
         # no longer exist when we try to access them, so we just skip them.
-        stop_process_results = []
-        for proc in psutil.process_iter():
-            try:
-                pinfo = proc.as_dict(
-                    attrs=['pid', 'username', 'create_time',
-                           'memory_info', 'cmdline'])
-                cmdline = " ".join(pinfo['cmdline'])
-            except Exception as e:
-                log.debug(f"Error getting process info: {e}")
-                return False
-            if re.search(cmdline_regex, cmdline):
-                log.info(f"Found process {pinfo['pid']} from user "
-                         f"{pinfo['username']} with command line: {cmdline}")
-                log.info("")
-                stop_process_results.append(stop_process(proc, pinfo))
+        stop_process_results = stop_process_with_regex(cmdline_regex)
+        if stop_process_results is None:
+            return False
         if len(stop_process_results) > 0:
             return all(stop_process_results)
 

qlever/commands/ui.py

@@ -1,12 +1,37 @@
 from __future__ import annotations
 
-import subprocess
 from os import environ
+from pathlib import Path
+
+import yaml
 
 from qlever.command import QleverCommand
 from qlever.containerize import Containerize
 from qlever.log import log
-from qlever.util import is_port_used
+from qlever.util import is_port_used, run_command
+
+
+# Return a YAML string for the given dictionary. Format values with
+# newlines using the "|" style.
+def dict_to_yaml(dictionary):
+    # Custom representer for yaml, which uses the "|" style only for
+    # multiline strings.
+    #
+    # NOTE: We replace all `\r\n` with `\n` because otherwise the `|` style
+    # does not work as expected.
+    class MultiLineDumper(yaml.Dumper):
+        def represent_scalar(self, tag, value, style=None):
+            value = value.replace("\r\n", "\n")
+            if isinstance(value, str) and "\n" in value:
+                style = "|"
+            return super().represent_scalar(tag, value, style)
+
+    # Dump as yaml.
+    return yaml.dump(
+        dictionary,
+        sort_keys=False,
+        Dumper=MultiLineDumper,
+    )
 
 
 class UiCommand(QleverCommand):
@@ -37,7 +62,30 @@ class UiCommand(QleverCommand):
         }
 
     def additional_arguments(self, subparser) -> None:
-        pass
+        subparser.add_argument(
+            "--ui-config-file",
+            default="Qleverfile-ui.yml",
+            help="Name of the config file for the QLever UI "
+            "(default: Qleverfile-ui.yml)",
+        )
+        subparser.add_argument(
+            "--ui-db-file",
+            help="Name of the database file for the QLever UI "
+            "(default: {name}.ui-db.sqlite3)",
+        )
+        subparser.add_argument(
+            "--no-pull-latest",
+            action="store_true",
+            default=False,
+            help="Do not pull the latest image for the QLever UI "
+            "(default: pull the latest image if image name contains '/')",
+        )
+        subparser.add_argument(
+            "--stop",
+            action="store_true",
+            default=False,
+            help="Stop the running container",
+        )
 
     def execute(self, args) -> bool:
         # If QLEVER_OVERRIDE_DISABLE_UI is set, this command is disabled.
@@ -59,57 +107,161 @@ class UiCommand(QleverCommand):
                 log.info("")
 
         # Construct commands and show them.
-        server_url = f"http://{args.host_name}:{args.port}"
+        pull_latest_image = "/" in args.ui_image and not args.no_pull_latest
+        ui_config_name = args.ui_config
+        ui_db_file = args.ui_db_file or f"{args.name}.ui-db.sqlite3"
+        ui_db_file_from_image = "qleverui.sqlite3"
+        ui_config_file = args.ui_config_file
+        sparql_endpoint = f"http://{args.host_name}:{args.port}"
         ui_url = f"http://{args.host_name}:{args.ui_port}"
         pull_cmd = f"{args.ui_system} pull -q {args.ui_image}"
-        run_cmd = (
+        get_db_cmd = (
+            f"{args.ui_system} create "
+            f"--name {args.ui_container} "
+            f"{args.ui_image} "
+            f"&& {args.ui_system} cp "
+            f"{args.ui_container}:/app/db/{ui_db_file_from_image} {ui_db_file} "
+            f"&& {args.ui_system} rm -f {args.ui_container}"
+        )
+        start_ui_cmd = (
             f"{args.ui_system} run -d "
+            f"--volume $(pwd):/app/db "
+            f"--env QLEVERUI_DATABASE_URL=sqlite:////app/db/{ui_db_file} "
             f"--publish {args.ui_port}:7000 "
             f"--name {args.ui_container} "
             f"{args.ui_image}"
         )
-        exec_cmd = (
-            f"{args.ui_system} exec -it "
+        get_config_cmd = (
+            f"{args.ui_system} exec -i "
             f"{args.ui_container} "
-            f'bash -c "python manage.py configure '
-            f'{args.ui_config} {server_url}"'
+            f'bash -c "python manage.py config {ui_config_name}"'
         )
-        self.show(
-            "\n".join(
-                ["Stop running containers", pull_cmd, run_cmd, exec_cmd]
-            ),
-            only_show=args.show,
+        set_config_cmd = (
+            f"{args.ui_system} exec -i "
+            f"{args.ui_container} "
+            f'bash -c "python manage.py config {ui_config_name} '
+            f'/app/db/{ui_config_file} --hide-all-other-backends"'
         )
+        commands_to_show = []
+        if not args.stop:
+            if pull_latest_image:
+                commands_to_show.append(pull_cmd)
+            if not Path(ui_db_file).exists():
+                commands_to_show.append(get_db_cmd)
+            commands_to_show.append(start_ui_cmd)
+            if not Path(ui_config_file).exists():
+                commands_to_show.append(get_config_cmd)
+            else:
+                commands_to_show.append(set_config_cmd)
+        self.show("\n".join(commands_to_show), only_show=args.show)
         if qlever_is_running_in_container:
             return False
         if args.show:
             return True
 
         # Stop running containers.
+        was_found_and_stopped = False
         for container_system in Containerize.supported_systems():
-            Containerize.stop_and_remove_container(
+            was_found_and_stopped |= Containerize.stop_and_remove_container(
                 container_system, args.ui_container
             )
+        if was_found_and_stopped:
+            log.debug(f"Stopped and removed container `{args.ui_container}`")
+        else:
+            log.debug(f"No container with name `{args.ui_container}` found")
+        if args.stop:
+            return True
+
+        # Pull the latest image.
+        if pull_latest_image:
+            log.debug(f"Pulling image `{args.ui_image}` for QLever UI")
+            run_command(pull_cmd)
 
         # Check if the UI port is already being used.
         if is_port_used(args.ui_port):
             log.warning(
-                f"It looks like the specified port for the UI ({args.ui_port}) is already in use. You can set another port in the Qleverfile in the [ui] section with the UI_PORT variable."
+                f"It looks like port {args.ui_port} for the QLever UI "
+                f"is already in use. You can set another port in the "
+                f" Qleverfile in the [ui] section with the UI_PORT variable."
             )
 
-        # Try to start the QLever UI.
+        # Get the QLever UI database from the image, unless it already exists.
+        if Path(ui_db_file).exists():
+            log.debug(f"Found QLever UI database `{ui_db_file}`, reusing it")
+        else:
+            log.debug(f"Getting QLever UI database `{ui_db_file}` from image")
+            try:
+                run_command(get_db_cmd)
+            except Exception as e:
+                log.error(
+                    f"Failed to get {ui_db_file} from {args.ui_image} "
+                    f"({e})"
+                )
+                return False
+
+        # Start the QLever UI.
+        try:
+            log.debug(
+                f"Starting new container with name `{args.ui_container}`"
+            )
+            run_command(start_ui_cmd)
+        except Exception as e:
+            log.error(f"Failed to start container `{args.ui_container}` ({e})")
+            return False
+
+        # Check if config file with name `ui_config_file` exists. If not, try
+        # to obtain it via `get_config_cmd` and set it as default.
+        if Path(ui_config_file).exists():
+            log.info(f"Found config file `{ui_config_file}` and reusing it")
+        else:
+            try:
+                log.info(
+                    f"Get default config file `{ui_config_file}` from image "
+                    f"`{args.ui_image}` and set endpoint to `{sparql_endpoint}`"
+                )
+                config_yaml = run_command(get_config_cmd, return_output=True)
+                config_dict = yaml.safe_load(config_yaml)
+            except Exception as e:
+                log.error("")
+                log.error(
+                    f"An error occured while getting and parsing the "
+                    f"config file ({e})"
+                )
+                return False
+            try:
+                config_dict["config"]["backend"]["isDefault"] = True
+                config_dict["config"]["backend"]["baseUrl"] = sparql_endpoint
+                config_dict["config"]["backend"]["sortKey"] = 1
+                config_yaml = dict_to_yaml(config_dict)
+                with open(ui_config_file, "w") as f:
+                    f.write(config_yaml)
+            except Exception as e:
+                log.error("")
+                log.error(
+                    f"An error occured while modifying and writing the "
+                    f"config file ({e})"
+                )
+                return False
+
+        # Configure the QLever UI.
         try:
-            subprocess.run(pull_cmd, shell=True, stdout=subprocess.DEVNULL)
-            subprocess.run(run_cmd, shell=True, stdout=subprocess.DEVNULL)
-            subprocess.run(exec_cmd, shell=True, stdout=subprocess.DEVNULL)
-        except subprocess.CalledProcessError as e:
-            log.error(f"Failed to start the QLever UI ({e})")
+            run_command(set_config_cmd)
+        except Exception as e:
+            log.error(f"Failed to configure the QLever UI ({e})")
             return False
 
-        # Success.
+        # If we come this far, everything should work.
+        log.info("")
+        log.info(
+            f"The QLever UI should now be up at {ui_url}/{ui_config_name}"
+        )
+        log.info("")
+        log.debug(
+            "If you must, you can log in as QLever UI admin with "
+            'username and password "demo"'
+        )
         log.info(
-            f"The QLever UI should now be up at {ui_url} ..."
-            f"You can log in as QLever UI admin with username and "
-            f'password "demo"'
+            f"You can modify the config file at `{ui_config_file}` "
+            f"and then just run `qlever ui` again"
         )
         return True

qlever/config.py

@@ -9,7 +9,7 @@ from pathlib import Path
 import argcomplete
 from termcolor import colored
 
-from qlever import command_objects, script_name
+from qlever import command_objects, engine_name, script_name
 from qlever.log import log, log_levels
 from qlever.qleverfile import Qleverfile
 
@@ -176,11 +176,18 @@ class QleverConfig:
         # are defined in the modules in `qlever/commands`. In `__init__.py`
         # an object of each class is created and stored in `command_objects`.
         parser = argparse.ArgumentParser(
-                description=colored("This is the qlever command line tool, "
-                                    "it's all you need to work with QLever",
-                                    attrs=["bold"]))
-        parser.add_argument("--version", action="version",
-                            version=f"%(prog)s {version('qlever')}")
+            description=colored(
+                f"This is the {script_name} command line tool, "
+                f"it's all you need to work with {engine_name}",
+                attrs=["bold"],
+            )
+        )
+        if script_name == "qlever":
+            parser.add_argument(
+                "--version",
+                action="version",
+                version=f"%(prog)s {version('qlever')}",
+            )
         add_qleverfile_option(parser)
         subparsers = parser.add_subparsers(dest='command')
         subparsers.required = True

qlever/containerize.py

@@ -9,7 +9,7 @@ import subprocess
 from typing import Optional
 
 from qlever.log import log
-from qlever.util import run_command, get_random_string
+from qlever.util import get_random_string, run_command
 
 
 class ContainerizeException(Exception):
@@ -40,6 +40,7 @@ class Containerize:
         volumes: list[tuple[str, str]] = [],
         ports: list[tuple[int, int]] = [],
         working_directory: Optional[str] = None,
+        use_bash: bool = True,
     ) -> str:
         """
         Get the command to run `cmd` with the given `container_system` and the
@@ -80,11 +81,15 @@ class Containerize:
             f"{volume_options}"
             f"{port_options}"
             f"{working_directory_option}"
+            f" --name {container_name}"
             f" --init"
-            f" --entrypoint bash"
-            f" --name {container_name} {image_name}"
-            f" -c {shlex.quote(cmd)}"
         )
+        if use_bash:
+            containerized_cmd += (
+                f" --entrypoint bash {image_name} -c {shlex.quote(cmd)}"
+            )
+        else:
+            containerized_cmd += f" {image_name} {cmd}"
         return containerized_cmd
 
     @staticmethod

qlever/qlever_main.py

@@ -12,7 +12,7 @@ import traceback
 
 from termcolor import colored
 
-from qlever import command_objects
+from qlever import command_objects, script_name
 from qlever.config import ConfigException, QleverConfig
 from qlever.log import log, log_levels
 
@@ -35,9 +35,9 @@ def main():
         log.info("")
         log.info(colored(f"Command: {args.command}", attrs=["bold"]))
         log.info("")
-        commandWasSuccesful = command_object.execute(args)
+        command_successful = command_object.execute(args)
         log.info("")
-        if not commandWasSuccesful:
+        if not command_successful:
             exit(1)
     except KeyboardInterrupt:
         log.info("")
@@ -47,9 +47,14 @@ def main():
     except Exception as e:
         # Check if it's a certain kind of `AttributeError` and give a hint in
         # that case.
+        log.debug(
+            "Command failed with exception, full traceback: "
+            f"{traceback.format_exc()}"
+        )
         match_error = re.search(r"object has no attribute '(.+)'", str(e))
         match_trace = re.search(
-            r"(qlever/commands/.+\.py)\", line (\d+)", traceback.format_exc()
+            rf"({script_name}/commands/.+\.py)\", line (\d+)",
+            traceback.format_exc(),
         )
         if isinstance(e, AttributeError) and match_error and match_trace:
             attribute = match_error.group(1)

qlever/qleverfile.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import re
+import socket
 import subprocess
-from configparser import ConfigParser, ExtendedInterpolation
+from configparser import ConfigParser, ExtendedInterpolation, RawConfigParser
+from pathlib import Path
 
+from qlever import script_name
 from qlever.containerize import Containerize
 from qlever.log import log
 
@@ -298,12 +301,12 @@ class Qleverfile:
         runtime_args["index_container"] = arg(
             "--index-container",
             type=str,
-            help="The name of the container used by `qlever index`",
+            help=f"The name of the container used by `{script_name} index`",
         )
         runtime_args["server_container"] = arg(
             "--server-container",
             type=str,
-            help="The name of the container used by `qlever start`",
+            help=f"The name of the container used by `{script_name} start`",
         )
 
         ui_args["ui_port"] = arg(
@@ -400,9 +403,9 @@ class Qleverfile:
             name = config["data"]["name"]
             runtime = config["runtime"]
             if "server_container" not in runtime:
-                runtime["server_container"] = f"qlever.server.{name}"
+                runtime["server_container"] = f"{script_name}.server.{name}"
             if "index_container" not in runtime:
-                runtime["index_container"] = f"qlever.index.{name}"
+                runtime["index_container"] = f"{script_name}.index.{name}"
             if "ui_container" not in config["ui"]:
                 config["ui"]["ui_container"] = f"qlever.ui.{name}"
             index = config["index"]
@@ -414,5 +417,49 @@ class Qleverfile:
         if index.get("text_index", "none") != "none":
             server["use_text_index"] = "yes"
 
+        # Add other non-trivial default values.
+        try:
+            config["server"]["host_name"] = socket.gethostname()
+        except Exception:
+            log.warning(
+                "Could not get the hostname, using `localhost` as default"
+            )
+            pass
+
         # Return the parsed Qleverfile with the added inherited values.
         return config
+
+    @staticmethod
+    def filter(
+        qleverfile_path: Path, options_included: dict[str, list[str]]
+    ) -> RawConfigParser:
+        """
+        Given a filter criteria (key: section_header, value: list[options]),
+        return a RawConfigParser object to create a new filtered Qleverfile
+        with only the specified sections and options (selects all options if
+        list[options] is empty). Mainly to be used by non-qlever scripts for
+        the setup-config command
+        """
+        # Read the Qleverfile.
+        config = RawConfigParser()
+        config.optionxform = str  # Preserve case sensitivity of keys
+        config.read(qleverfile_path)
+
+        filtered_config = RawConfigParser()
+        filtered_config.optionxform = str
+
+        for section, desired_fields in options_included.items():
+            if config.has_section(section):
+                filtered_config.add_section(section)
+
+                # If the list is empty, copy all fields
+                if not desired_fields:
+                    for field, value in config.items(section):
+                        filtered_config.set(section, field, value)
+                else:
+                    for desired_field in desired_fields:
+                        if config.has_option(section, desired_field):
+                            value = config.get(section, desired_field)
+                            filtered_config.set(section, desired_field, value)
+
+        return filtered_config

qlever/util.py

@@ -10,7 +10,9 @@ import string
 import subprocess
 from datetime import date, datetime
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
+
+import psutil
 
 from qlever.log import log
 
@@ -33,6 +35,7 @@ def run_command(
     cmd: str,
     return_output: bool = False,
     show_output: bool = False,
+    show_stderr: bool = False,
     use_popen: bool = False,
 ) -> Optional[str | subprocess.Popen]:
     """
@@ -50,7 +53,7 @@ def run_command(
         "shell": True,
         "text": True,
         "stdout": None if show_output else subprocess.PIPE,
-        "stderr": subprocess.PIPE,
+        "stderr": None if show_stderr else subprocess.PIPE,
     }
 
     # With `Popen`, the command runs in the current shell and a process object
@@ -72,8 +75,8 @@ def run_command(
             raise Exception(result.stderr.replace("\n", " ").strip())
         else:
             raise Exception(
-                f"Command failed with exit code {result.returncode}"
-                f" but nothing written to stderr"
+                f"Command failed with exit code {result.returncode}, "
+                f" nothing written to stderr"
             )
     # Optionally, return what was written to `stdout`.
     if return_output:
@@ -242,3 +245,85 @@ def format_size(bytes, suffix="B"):
         if bytes < factor:
             return f"{bytes:.2f} {unit}{suffix}"
         bytes /= factor
+
+
+def stop_process(proc: psutil.Process, pinfo: dict[str, Any]) -> bool:
+    """
+    Try to kill the given process, return True iff it was killed
+    successfully. The process_info is used for logging.
+    """
+    try:
+        proc.kill()
+        log.info(f"Killed process {pinfo['pid']}")
+        return True
+    except Exception as e:
+        log.error(
+            f"Could not kill process with PID "
+            f"{pinfo['pid']} ({e}) ... try to kill it "
+            f"manually"
+        )
+        log.info("")
+        show_process_info(proc, "", show_heading=True)
+        return False
+
+
+def stop_process_with_regex(cmdline_regex: str) -> list[bool] | None:
+    """
+    Given a cmdline_regex for a native process, try to kill the processes that
+    match the regex and return a list of their stopped status (bool).
+    Show the matched processes as log info.
+    """
+    stop_process_results = []
+    for proc in psutil.process_iter():
+        try:
+            pinfo = proc.as_dict(
+                attrs=[
+                    "pid",
+                    "username",
+                    "create_time",
+                    "memory_info",
+                    "cmdline",
+                ]
+            )
+            cmdline = " ".join(pinfo["cmdline"])
+        except Exception as e:
+            log.debug(f"Error getting process info: {e}")
+            return None
+        if re.search(cmdline_regex, cmdline):
+            log.info(
+                f"Found process {pinfo['pid']} from user "
+                f"{pinfo['username']} with command line: {cmdline}"
+            )
+            log.info("")
+            stop_process_results.append(stop_process(proc, pinfo))
+    return stop_process_results
+
+
+def binary_exists(binary: str, cmd_arg: str) -> bool:
+    """
+    When a command is run natively, check if the binary exists on the system
+    """
+    try:
+        run_command(f"{binary} --help")
+        return True
+    except Exception as e:
+        log.error(
+            f'Running "{binary}" failed, '
+            f"set `--{cmd_arg}` to a different binary or "
+            f"set `--system to a container system`"
+        )
+        log.info("")
+        log.info(f"The error message was: {e}")
+        return False
+
+
+def is_server_alive(url: str) -> bool:
+    """
+    Check if the server is already alive at the given endpoint url
+    """
+    check_server_cmd = f"curl -s {url}"
+    try:
+        run_command(check_server_cmd)
+        return True
+    except Exception:
+        return False

{qlever-0.5.21.dist-info → qlever-0.5.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qlever
-Version: 0.5.21
+Version: 0.5.23
 Summary: Command-line tool for using the QLever graph database
 Author-email: Hannah Bast <bast@cs.uni-freiburg.de>
 License: Apache-2.0
@@ -14,6 +14,7 @@ License-File: LICENSE
 Requires-Dist: psutil
 Requires-Dist: termcolor
 Requires-Dist: argcomplete
+Requires-Dist: pyyaml
 Dynamic: license-file
 
 # QLever

{qlever-0.5.21.dist-info → qlever-0.5.23.dist-info}/RECORD

@@ -1,11 +1,11 @@
-qlever/__init__.py,sha256=GlDcYX0TzV-7nAFaBzPc1Y6cNwz0rsLJFNfLNXl9UiM,1410
-qlever/command.py,sha256=oxsMtu445OnoZ6kKRJCUbyAGbavWcu39gLor8hWuLjQ,2765
-qlever/config.py,sha256=qYPy-MQ7BwGrvKSazQWhs0lnlOFqm-d47mpZhc3fptc,10254
-qlever/containerize.py,sha256=bnHmjKIFEe-NcuAMRNnXAFjRVLcLnk9f5JspCCyhgt8,5210
+qlever/__init__.py,sha256=ZbzivHALRlzAUoFBBSbbkKFcvATBX7yVR6Q9JyEQ8ig,1631
+qlever/command.py,sha256=nI-UG1GWrZ24DxD0Ly8dvupCpsD9e3n9-eskkCMTx6c,2767
+qlever/config.py,sha256=gNw2_-jj1TjzhzqLOuUI_Dh19q_ViCiArrtrgXL2F4E,10354
+qlever/containerize.py,sha256=G1_ei9nBnYl5-7miiy0eWjb9HMnt06X21P7iU8bm6A0,5369
 qlever/log.py,sha256=WLscWV4fFF_w_uXSOfvWzhyzRM7t_61inE2ks3zf6Gw,1317
-qlever/qlever_main.py,sha256=-E4W8YdZ_teszGwXu6bQgBcH3y47TFJU8JLPIDwc_-g,2449
-qlever/qleverfile.py,sha256=DRS-SdbNoGZKAuxUQDDYmB6yKU-uNERrZRdgdRCejdw,15573
-qlever/util.py,sha256=xAK9GT8SgU3z65F1dFXazxsd60letqLQqQAZ81mdJSY,8374
+qlever/qlever_main.py,sha256=mkNeQ6UOX-cIR5dVwwS12qc0gsJh4b6yL0LTdU-8oN4,2612
+qlever/qleverfile.py,sha256=DZ--LJ4TxWqs08bKHmGQlXQW6MPyOB--r7eMKs7E59s,17449
+qlever/util.py,sha256=Gv9fE-SOZSx1Kez5z3pcukniZnDDQEKx7j9LV-iP7LM,10939
 qlever/Qleverfiles/Qleverfile.dblp,sha256=oVVPFMpKX0Lfe0HDYPuL3qYhlC-3Lz18AT2tHmJ32WE,1282
 qlever/Qleverfiles/Qleverfile.dblp-plus,sha256=TJHxp8I1P6JKJjbuAllEpB32-huuY1gH0FlenqPVJ5g,1334
 qlever/Qleverfiles/Qleverfile.dbpedia,sha256=aaNZZayE-zVePGSwPzXemkX__Ns8-kP_E7DNNKZPnqg,1160
@@ -28,26 +28,26 @@ qlever/Qleverfiles/Qleverfile.wikipathways,sha256=UFEVLrtOBiSQfibBN9xc2wDXrnWcnx
 qlever/Qleverfiles/Qleverfile.yago-4,sha256=hAS_2ZmC1zxNsKXip7t1F_iqu3CC-6O7v6HZhuFbnWY,1819
 qlever/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qlever/commands/add_text_index.py,sha256=xJ49Iq1-CszXjHDvOpllqLw1J1kCxQl7H848XD1vEz0,3820
-qlever/commands/cache_stats.py,sha256=zGPLSWDNn7dwAAt2o-2ExqHmw1FeN8i6nEQbaaqF830,4156
-qlever/commands/clear_cache.py,sha256=n52ohE1EE4M_B4kId_v8tbAlW-BGwG1K-ZYQ9QgxIJU,2974
-qlever/commands/example_queries.py,sha256=4zhvrbH8IJIKy5HB-guafY8SmLFb1OwnjELnaMD8ChI,24031
+qlever/commands/cache_stats.py,sha256=15C0iIahwPuxTvMDyB0UDmo45iBk97hWzVZkEMHjMA8,4165
+qlever/commands/clear_cache.py,sha256=kwNayV4qtgqh_Gf5SjS6WzmfgUsJ-9YhPoWYWGoNNn8,2967
+qlever/commands/example_queries.py,sha256=4oKCBYYO_uhBNGrSyAd69UA1--bPPcjp88aULaNaT-o,24051
 qlever/commands/extract_queries.py,sha256=TZBmZLz_NknU1LKbl9nPmxdb82lsPeDhTWjIo81llvA,3942
 qlever/commands/get_data.py,sha256=nHOHMjv0tSLWJDOR0ba_LK-Bk-mcGnphb8hbqcVYFhE,1411
-qlever/commands/index.py,sha256=H0FtJ4HBVH8ESPxmYzb--k3qR5M7PfE4A-QlovVTP_o,13400
+qlever/commands/index.py,sha256=NJ6hdlYEc-4AOANON3Bpl-vhgOs21HiPQnUrAE1Flfk,13055
 qlever/commands/index_stats.py,sha256=9EBo1Oq5PGjajrvWJNafJ-Wg_d90DaO5AGq9a5plSRM,11720
 qlever/commands/log.py,sha256=vLqkgtx1udnQqoUBMWB5G9rwr-l7UKrDpyFYSMuoXWw,1987
-qlever/commands/query.py,sha256=lqQR3wiDLAzxg3Da5Xim6gxkAeEexPJxldoTfB9U4H0,4588
-qlever/commands/settings.py,sha256=cpRhD6CnQmDuzGg28zO7QTASDBGR7_PT0GRGtEVgY_g,3776
+qlever/commands/query.py,sha256=IBIi1NT1n9xDobqNIXlV50ap3o958g5KHMiFJqw89z0,4608
+qlever/commands/settings.py,sha256=LpfF0jhttJsqKUh9hO4mdW3SVE3361wvb2SeQWPUB7w,3813
 qlever/commands/setup_config.py,sha256=wEy1LAunpOnqrUCbazMpt1u9HJCKgXJEMxF3zjh0jb0,3344
-qlever/commands/start.py,sha256=9Rjn8KTkAPkOkBwlFP1vE4LrrtaJW24OuPqAdQFBYTk,11695
+qlever/commands/start.py,sha256=g_5-BUiSYJjL10ae91jMA5SgI0zk4O4gPMN_BOuERmc,10854
 qlever/commands/status.py,sha256=TtnBqcdkF3zTDKft07zpVcIX7kFu7d_nOy9b6Ohh9vQ,1650
-qlever/commands/stop.py,sha256=z25gWfLA9qIJ7F3zWZa0p0oVnt61kHcsB1evjgXhKX4,4557
+qlever/commands/stop.py,sha256=5BNKArOzoJ8kYiTVAmtN81w7nQ42fkxISgsxL-qJpO0,3463
 qlever/commands/system_info.py,sha256=I84EKgMO5J8pvsTDhkVKHzsRLtPajNg9KTQN5kWjqLU,4660
-qlever/commands/ui.py,sha256=T2Sl6w9tXNpZf-Zv3A9SLmarujszTIjGOYyPfyT4sX4,3821
+qlever/commands/ui.py,sha256=32DxXXrYEO4Ou9M3azWpPHzwCsPYvWuR9hBfliVJ2WM,9762
 qlever/commands/warmup.py,sha256=kJHzS7HJo8pD2CphJuaXDj_CYP02YDo2DVM-pun3A80,1029
-qlever-0.5.21.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-qlever-0.5.21.dist-info/METADATA,sha256=uZV8sIEroOozEZgBowu22IKPLeOztE_wjCNV0S4fJSE,4630
-qlever-0.5.21.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-qlever-0.5.21.dist-info/entry_points.txt,sha256=U_1U6SFIEZ-AnNlvk2nzcL0e4jnjEpuSbxYZ_E0XpEg,51
-qlever-0.5.21.dist-info/top_level.txt,sha256=kd3zsYqiFd0--Czh5XTVkfEq6XR-XgRFW35X0v0GT-c,7
-qlever-0.5.21.dist-info/RECORD,,
+qlever-0.5.23.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+qlever-0.5.23.dist-info/METADATA,sha256=mLvI_U3eUeLxMSDSjk96eFa8HqH7Gv6grntGeVcDeJM,4652
+qlever-0.5.23.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+qlever-0.5.23.dist-info/entry_points.txt,sha256=U_1U6SFIEZ-AnNlvk2nzcL0e4jnjEpuSbxYZ_E0XpEg,51
+qlever-0.5.23.dist-info/top_level.txt,sha256=kd3zsYqiFd0--Czh5XTVkfEq6XR-XgRFW35X0v0GT-c,7
+qlever-0.5.23.dist-info/RECORD,,

{qlever-0.5.21.dist-info → qlever-0.5.23.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any