qlever 0.5.20__py3-none-any.whl → 0.5.22__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(
@@ -103,8 +103,8 @@ class ExampleQueriesCommand(QleverCommand):
         subparser.add_argument(
             "--clear-cache",
             choices=["yes", "no"],
-            default="yes",
-            help="Clear the cache before each query",
+            default="no",
+            help="Clear the cache before each query (only works for QLever)",
         )
         subparser.add_argument(
             "--width-query-description",
@@ -213,9 +213,18 @@ class ExampleQueriesCommand(QleverCommand):
             not args.sparql_endpoint
             or args.sparql_endpoint.startswith("https://qlever")
         )
-        if args.clear_cache == "yes" and not is_qlever:
-            log.warning("Clearing the cache only works for QLever")
-            args.clear_cache = "no"
+        if args.clear_cache == "yes":
+            if is_qlever:
+                log.warning(
+                    "Clearing the cache before each query"
+                    " (only works for QLever)"
+                )
+            else:
+                log.warning(
+                    "Clearing the cache only works for QLever"
+                    ", option `--clear-cache` is ignored"
+                )
+                args.clear_cache = "no"
 
         # Show what the command will do.
         get_queries_cmd = (
@@ -231,14 +240,12 @@ 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"
             f"SPARQL endpoint: {sparql_endpoint}\n"
             f"Accept header: {args.accept}\n"
-            f"Clear cache before each query:"
-            f" {args.clear_cache.upper()}\n"
             f"Download result for each query or just count:"
             f" {args.download_or_count.upper()}"
             + (f" with LIMIT {args.limit}" if args.limit else ""),
@@ -404,6 +411,7 @@ class ExampleQueriesCommand(QleverCommand):
             # Get result size (via the command line, in order to avoid loading
             # a potentially large JSON file into Python, which is slow).
             if error_msg is None:
+                single_int_result = None
                 # CASE 0: The result is empty despite a 200 HTTP code (not a
                 # problem for CONSTRUCT and DESCRIBE queries).
                 if Path(result_file).stat().st_size == 0 and (
@@ -461,16 +469,29 @@ class ExampleQueriesCommand(QleverCommand):
                         )
                     else:
                         try:
-                            result_size = run_command(
-                                f'jq -r ".results.bindings | length"'
-                                f" {result_file}",
-                                return_output=True,
+                            result_size = int(
+                                run_command(
+                                    f'jq -r ".results.bindings | length"'
+                                    f" {result_file}",
+                                    return_output=True,
+                                ).rstrip()
                             )
                         except Exception as e:
                             error_msg = {
                                 "short": "Malformed JSON",
                                 "long": re.sub(r"\s+", " ", str(e)),
                             }
+                        if result_size == 1:
+                            try:
+                                single_int_result = int(
+                                    run_command(
+                                        f'jq -e -r ".results.bindings[0][] | .value"'
+                                        f" {result_file}",
+                                        return_output=True,
+                                    ).rstrip()
+                                )
+                            except Exception:
+                                pass
 
             # Remove the result file (unless in debug mode).
             if args.log_level != "DEBUG":
@@ -485,10 +506,16 @@ class ExampleQueriesCommand(QleverCommand):
                 )
             if error_msg is None:
                 result_size = int(result_size)
+                single_int_result = (
+                    f"   [single int result: {single_int_result:,}]"
+                    if single_int_result is not None
+                    else ""
+                )
                 log.info(
                     f"{description:<{width_query_description}}  "
                     f"{time_seconds:6.2f} s  "
                     f"{result_size:>{args.width_result_size},}"
+                    f"{single_int_result}"
                 )
                 query_times.append(time_seconds)
                 result_sizes.append(result_size)

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.
@@ -30,6 +30,8 @@ def construct_command(args) -> str:
         start_cmd += f" -s {args.timeout}"
     if args.access_token:
         start_cmd += f" -a {args.access_token}"
+    if args.persist_updates:
+        start_cmd += " --persist-updates"
     if args.only_pso_and_pos_permutations:
         start_cmd += " --only-pso-and-pos-permutations"
     if not args.use_patterns:
@@ -69,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 = (
@@ -148,6 +134,7 @@ class StartCommand(QleverCommand):
                 "cache_max_num_entries",
                 "num_threads",
                 "timeout",
+                "persist_updates",
                 "only_pso_and_pos_permutations",
                 "use_patterns",
                 "use_text_index",
@@ -157,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",
@@ -223,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)