qlever 0.5.15__py3-none-any.whl → 0.5.17__py3-none-any.whl

qlever/commands/example_queries.py

@@ -51,13 +51,15 @@ class ExampleQueriesCommand(QleverCommand):
         subparser.add_argument(
             "--get-queries-cmd",
             type=str,
-            help="Command to get example queries as TSV " "(description, query)",
+            help="Command to get example queries as TSV "
+            "(description, query)",
         )
         subparser.add_argument(
             "--query-ids",
             type=str,
             default="1-$",
-            help="Query IDs as comma-separated list of " "ranges (e.g., 1-5,7,12-$)",
+            help="Query IDs as comma-separated list of "
+            "ranges (e.g., 1-5,7,12-$)",
         )
         subparser.add_argument(
             "--query-regex",
@@ -68,7 +70,7 @@ class ExampleQueriesCommand(QleverCommand):
         subparser.add_argument(
             "--download-or-count",
             choices=["download", "count"],
-            default="count",
+            default="download",
             help="Whether to download the full result "
             "or just compute the size of the result",
         )
@@ -88,10 +90,14 @@ class ExampleQueriesCommand(QleverCommand):
                 "text/tab-separated-values",
                 "text/csv",
                 "application/sparql-results+json",
+                "application/qlever-results+json",
                 "text/turtle",
+                "AUTO",
             ],
             default="application/sparql-results+json",
-            help="Accept header for the SPARQL query",
+            help="Accept header for the SPARQL query; AUTO means "
+            "`text/turtle` for CONSTRUCT AND DESCRIBE queries, "
+            "`application/sparql-results+json` for all others",
         )
         subparser.add_argument(
             "--clear-cache",
@@ -117,6 +123,13 @@ class ExampleQueriesCommand(QleverCommand):
             default=14,
             help="Width for printing the result size",
         )
+        subparser.add_argument(
+            "--add-query-type-to-description",
+            action="store_true",
+            default=False,
+            help="Add the query type (SELECT, ASK, CONSTRUCT, DESCRIBE, "
+            "UNKNOWN) to the description",
+        )
         subparser.add_argument(
             "--show-query",
             choices=["always", "never", "on-error"],
@@ -130,19 +143,35 @@ class ExampleQueriesCommand(QleverCommand):
             help="When showing the query, also show the prefixes",
         )
 
-    def pretty_print_query(self, query: str, show_prefixes: bool) -> None:
-        remove_prefixes_cmd = " | sed '/^PREFIX /Id'" if not show_prefixes else ""
+    def pretty_printed_query(self, query: str, show_prefixes: bool) -> str:
+        remove_prefixes_cmd = (
+            " | sed '/^PREFIX /Id'" if not show_prefixes else ""
+        )
         pretty_print_query_cmd = (
             f"echo {shlex.quote(query)}"
             f" | docker run -i --rm sparqling/sparql-formatter"
             f"{remove_prefixes_cmd} | grep -v '^$'"
         )
         try:
-            query_pp = run_command(pretty_print_query_cmd, return_output=True)
-            log.info(colored(query_pp.rstrip(), "cyan"))
-        except Exception as e:
-            log.error(f"Failed to pretty-print query: {e}")
-            log.info(colored(query.rstrip(), "cyan"))
+            query_pretty_printed = run_command(
+                pretty_print_query_cmd, return_output=True
+            )
+            return query_pretty_printed.rstrip()
+        except Exception:
+            log.error(
+                "Failed to pretty-print query, "
+                "returning original query: {e}"
+            )
+            return query.rstrip()
+
+    def sparql_query_type(self, query: str) -> str:
+        match = re.search(
+            r"(SELECT|ASK|CONSTRUCT|DESCRIBE)\s", query, re.IGNORECASE
+        )
+        if match:
+            return match.group(1).upper()
+        else:
+            return "UNKNOWN"
 
     def execute(self, args) -> bool:
         # We can't have both `--remove-offset-and-limit` and `--limit`.
@@ -150,8 +179,13 @@ class ExampleQueriesCommand(QleverCommand):
             log.error("Cannot have both --remove-offset-and-limit and --limit")
             return False
 
-        # If `args.accept` is `application/sparql-results+json`, we need `jq`.
-        if args.accept == "application/sparql-results+json":
+        # If `args.accept` is `application/sparql-results+json` or
+        # `application/qlever-results+json` or `AUTO`, we need `jq`.
+        if (
+            args.accept == "application/sparql-results+json"
+            or args.accept == "application/qlever-results+json"
+            or args.accept == "AUTO"
+        ):
             try:
                 subprocess.run(
                     "jq --version",
@@ -174,8 +208,9 @@ class ExampleQueriesCommand(QleverCommand):
             return False
 
         # Clear cache only works for QLever.
-        is_qlever = not args.sparql_endpoint or args.sparql_endpoint.startswith(
-            "https://qlever"
+        is_qlever = (
+            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")
@@ -193,7 +228,9 @@ class ExampleQueriesCommand(QleverCommand):
         if args.query_regex:
             get_queries_cmd += f" | grep -Pi {shlex.quote(args.query_regex)}"
         sparql_endpoint = (
-            args.sparql_endpoint if args.sparql_endpoint else f"localhost:{args.port}"
+            args.sparql_endpoint
+            if args.sparql_endpoint
+            else f"localhost:{args.port}"
         )
         self.show(
             f"Obtain queries via: {get_queries_cmd}\n"
@@ -211,7 +248,9 @@ class ExampleQueriesCommand(QleverCommand):
 
         # Get the example queries.
         try:
-            example_query_lines = run_command(get_queries_cmd, return_output=True)
+            example_query_lines = run_command(
+                get_queries_cmd, return_output=True
+            )
             if len(example_query_lines) == 0:
                 log.error("No example queries matching the criteria found")
                 return False
@@ -220,6 +259,12 @@ class ExampleQueriesCommand(QleverCommand):
             log.error(f"Failed to get example queries: {e}")
             return False
 
+        # We want the width of the query description to be an uneven number (in
+        # case we have to truncated it, in which case we want to have a " ... "
+        # in the middle).
+        width_query_description_half = args.width_query_description // 2
+        width_query_description = 2 * width_query_description_half + 1
+
         # Launch the queries one after the other and for each print: the
         # description, the result size (number of rows), and the query
         # processing time (seconds).
@@ -227,13 +272,16 @@ class ExampleQueriesCommand(QleverCommand):
         result_sizes = []
         num_failed = 0
         for example_query_line in example_query_lines:
-            # Parse description and query.
+            # Parse description and query, and determine query type.
             description, query = example_query_line.split("\t")
             if len(query) == 0:
                 log.error("Could not parse description and query, line is:")
                 log.info("")
                 log.info(example_query_line)
                 return False
+            query_type = self.sparql_query_type(query)
+            if args.add_query_type_to_description or args.accept == "AUTO":
+                description = f"{description} [{query_type}]"
 
             # Clear the cache.
             if args.clear_cache == "yes":
@@ -267,7 +315,9 @@ class ExampleQueriesCommand(QleverCommand):
             # Count query.
             if args.download_or_count == "count":
                 # First find out if there is a FROM clause.
-                regex_from_clause = re.compile(r"\s*FROM\s+<[^>]+>\s*", re.IGNORECASE)
+                regex_from_clause = re.compile(
+                    r"\s*FROM\s+<[^>]+>\s*", re.IGNORECASE
+                )
                 match_from_clause = re.search(regex_from_clause, query)
                 from_clause = " "
                 if match_from_clause:
@@ -296,24 +346,39 @@ class ExampleQueriesCommand(QleverCommand):
             query = re.sub(r"\s*\.\s*\}", " }", query)
             if args.show_query == "always":
                 log.info("")
-                self.pretty_print_query(query, args.show_prefixes)
+                log.info(
+                    colored(
+                        self.pretty_printed_query(query, args.show_prefixes),
+                        "cyan",
+                    )
+                )
+
+            # Accept header. For "AUTO", use `text/turtle` for CONSTRUCT
+            # queries and `application/sparql-results+json` for all others.
+            accept_header = args.accept
+            if accept_header == "AUTO":
+                if query_type == "CONSTRUCT" or query_type == "DESCRIBE":
+                    accept_header = "text/turtle"
+                else:
+                    accept_header = "application/sparql-results+json"
 
             # Launch query.
             try:
                 curl_cmd = (
                     f"curl -s {sparql_endpoint}"
                     f' -w "HTTP code: %{{http_code}}\\n"'
-                    f' -H "Accept: {args.accept}"'
+                    f' -H "Accept: {accept_header}"'
                     f" --data-urlencode query={shlex.quote(query)}"
                 )
                 log.debug(curl_cmd)
                 result_file = (
-                    f"qlever.example_queries.result." f"{abs(hash(curl_cmd))}.tmp"
+                    f"qlever.example_queries.result."
+                    f"{abs(hash(curl_cmd))}.tmp"
                 )
                 start_time = time.time()
                 http_code = run_curl_command(
                     sparql_endpoint,
-                    headers={"Accept": args.accept},
+                    headers={"Accept": accept_header},
                     params={"query": query},
                     result_file=result_file,
                 ).strip()
@@ -323,7 +388,9 @@ class ExampleQueriesCommand(QleverCommand):
                 else:
                     error_msg = {
                         "short": f"HTTP code: {http_code}",
-                        "long": re.sub(r"\s+", " ", Path(result_file).read_text()),
+                        "long": re.sub(
+                            r"\s+", " ", Path(result_file).read_text()
+                        ),
                     }
             except Exception as e:
                 if args.log_level == "DEBUG":
@@ -336,8 +403,12 @@ 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:
-                # CASE 0: Rhe result is empty despite a 200 HTTP code.
-                if Path(result_file).stat().st_size == 0:
+                # 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 (
+                    not query_type == "CONSTRUCT"
+                    and not query_type == "DESCRIBE"
+                ):
                     result_size = 0
                     error_msg = {
                         "short": "Empty result",
@@ -347,7 +418,7 @@ class ExampleQueriesCommand(QleverCommand):
 
                 # CASE 1: Just counting the size of the result (TSV or JSON).
                 elif args.download_or_count == "count":
-                    if args.accept == "text/tab-separated-values":
+                    if accept_header == "text/tab-separated-values":
                         result_size = run_command(
                             f"sed 1d {result_file}", return_output=True
                         )
@@ -370,21 +441,28 @@ class ExampleQueriesCommand(QleverCommand):
                 # CASE 2: Downloading the full result (TSV, CSV, Turtle, JSON).
                 else:
                     if (
-                        args.accept == "text/tab-separated-values"
-                        or args.accept == "text/csv"
+                        accept_header == "text/tab-separated-values"
+                        or accept_header == "text/csv"
                     ):
                         result_size = run_command(
                             f"sed 1d {result_file} | wc -l", return_output=True
                         )
-                    elif args.accept == "text/turtle":
+                    elif accept_header == "text/turtle":
                         result_size = run_command(
-                            f"sed '1d;/^@prefix/d;/^\\s*$/d' " f"{result_file} | wc -l",
+                            f"sed '1d;/^@prefix/d;/^\\s*$/d' "
+                            f"{result_file} | wc -l",
+                            return_output=True,
+                        )
+                    elif accept_header == "application/qlever-results+json":
+                        result_size = run_command(
+                            f'jq -r ".resultsize" {result_file}',
                             return_output=True,
                         )
                     else:
                         try:
                             result_size = run_command(
-                                f'jq -r ".results.bindings | length"' f" {result_file}",
+                                f'jq -r ".results.bindings | length"'
+                                f" {result_file}",
                                 return_output=True,
                             )
                         except Exception as e:
@@ -398,13 +476,16 @@ class ExampleQueriesCommand(QleverCommand):
                 Path(result_file).unlink(missing_ok=True)
 
             # Print description, time, result in tabular form.
-            if len(description) > args.width_query_description:
-                description = description[: args.width_query_description - 3]
-                description += "..."
+            if len(description) > width_query_description:
+                description = (
+                    description[: width_query_description_half - 2]
+                    + " ... "
+                    + description[-width_query_description_half + 2 :]
+                )
             if error_msg is None:
                 result_size = int(result_size)
                 log.info(
-                    f"{description:<{args.width_query_description}}  "
+                    f"{description:<{width_query_description}}  "
                     f"{time_seconds:6.2f} s  "
                     f"{result_size:>{args.width_result_size},}"
                 )
@@ -419,18 +500,28 @@ class ExampleQueriesCommand(QleverCommand):
                     and args.show_query != "on-error"
                 ):
                     error_msg["long"] = (
-                        error_msg["long"][: args.width_error_message - 3] + "..."
+                        error_msg["long"][: args.width_error_message - 3]
+                        + "..."
                     )
-                seperator_short_long = "\n" if args.show_query == "on-error" else "  "
+                seperator_short_long = (
+                    "\n" if args.show_query == "on-error" else "  "
+                )
                 log.info(
-                    f"{description:<{args.width_query_description}}    "
+                    f"{description:<{width_query_description}}    "
                     f"{colored('FAILED   ', 'red')}"
                     f"{colored(error_msg['short'], 'red'):>{args.width_result_size}}"
                     f"{seperator_short_long}"
                     f"{colored(error_msg['long'], 'red')}"
                 )
                 if args.show_query == "on-error":
-                    self.pretty_print_query(query, args.show_prefixes)
+                    log.info(
+                        colored(
+                            self.pretty_printed_query(
+                                query, args.show_prefixes
+                            ),
+                            "cyan",
+                        )
+                    )
                     log.info("")
 
         # Check that each query has a time and a result size, or it failed.
@@ -450,19 +541,19 @@ class ExampleQueriesCommand(QleverCommand):
             description = f"TOTAL   for {n} {query_or_queries}"
             log.info("")
             log.info(
-                f"{description:<{args.width_query_description}}  "
+                f"{description:<{width_query_description}}  "
                 f"{total_query_time:6.2f} s  "
                 f"{total_result_size:>14,}"
             )
             description = f"AVERAGE for {n} {query_or_queries}"
             log.info(
-                f"{description:<{args.width_query_description}}  "
+                f"{description:<{width_query_description}}  "
                 f"{average_query_time:6.2f} s  "
                 f"{average_result_size:>14,}"
             )
             description = f"MEDIAN  for {n} {query_or_queries}"
             log.info(
-                f"{description:<{args.width_query_description}}  "
+                f"{description:<{width_query_description}}  "
                 f"{median_query_time:6.2f} s  "
                 f"{median_result_size:>14,}"
             )
@@ -476,7 +567,7 @@ class ExampleQueriesCommand(QleverCommand):
                 num_failed_string += "  [all]"
             log.info(
                 colored(
-                    f"{description:<{args.width_query_description}}  "
+                    f"{description:<{width_query_description}}  "
                     f"{num_failed:>24}",
                     "red",
                 )

qlever/commands/extract_queries.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import re
+
+from qlever.command import QleverCommand
+from qlever.log import log
+
+
+class ExtractQueriesCommand(QleverCommand):
+    """
+    Class for executing the `extract-queries` command.
+    """
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return "Extract all SPARQL queries from the server log"
+
+    def should_have_qleverfile(self) -> bool:
+        return True
+
+    def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
+        return {"data": ["name"]}
+
+    def additional_arguments(self, subparser) -> None:
+        subparser.add_argument(
+            "--description-base",
+            type=str,
+            default="Log extract",
+            help="Base name for the query descriptions"
+            " (default: `Log extract`)",
+        )
+        subparser.add_argument(
+            "--log-file",
+            type=str,
+            help="Name of the log file to extract queries from"
+            " (default: `<name>.server-log.txt`)",
+        )
+        subparser.add_argument(
+            "--output-file",
+            type=str,
+            default="log-queries.txt",
+            help="Output file for the extracted queries (default: `log-queries.txt`)",
+        )
+
+    def execute(self, args) -> bool:
+        # Show what the command does.
+        if args.log_file is not None:
+            log_file_name = args.log_file
+        else:
+            log_file_name = f"{args.name}.server-log.txt"
+        self.show(
+            f"Extract SPARQL queries from `{log_file_name}`"
+            f" and write them to `{args.output_file}`",
+            only_show=args.show,
+        )
+        if args.show:
+            return True
+
+        # Regex for log entries of the form
+        # 2025-01-14 04:47:44.950 - INFO
+        log_line_regex = (
+            r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}) - [A-Z]+:"
+        )
+
+        # Read the log file line by line.
+        log_file = open(log_file_name, "r")
+        queries_file = open(args.output_file, "w")
+        query = None
+        description_base = args.description_base
+        description_base_count = {}
+        tsv_line_short_width = 150
+        for line in log_file:
+            # An "Alive check" message contains a tag, which we use as the base
+            # name of the query description.
+            alive_check_regex = r"Alive check with message \"(.*)\""
+            match = re.search(alive_check_regex, line)
+            if match:
+                description_base = match.group(1)
+                continue
+
+            # A new query in the log.
+            if "Processing the following SPARQL query" in line:
+                query = []
+                query_index = (
+                    description_base_count.get(description_base, 0) + 1
+                )
+                description_base_count[description_base] = query_index
+                continue
+            # If we have started a query: extend until we meet the next log
+            # line, then push the query. Remove comments.
+            if query is not None:
+                if not re.match(log_line_regex, line):
+                    if not re.match(r"^\s*#", line):
+                        line = re.sub(r" #.*", "", line)
+                        query.append(line)
+                else:
+                    query = re.sub(r"\s+", " ", "\n".join(query)).strip()
+                    description = f"{description_base}, Query #{query_index}"
+                    tsv_line = f"{description}\t{query}"
+                    tsv_line_short = (
+                        tsv_line
+                        if len(tsv_line) < tsv_line_short_width
+                        else tsv_line[:tsv_line_short_width] + "..."
+                    )
+                    log.info(tsv_line_short)
+                    print(tsv_line, file=queries_file)
+                    query = None
+
+        log_file.close()
+        queries_file.close()
+        return True

qlever/commands/index.py

@@ -147,7 +147,7 @@ class IndexCommand(QleverCommand):
                 raise self.InvalidInputJson(
                     f"Element {i} in `MULTI_INPUT_JSON` must only contain "
                     "the keys `format`, `graph`, and `parallel`. Contains "
-                    "extra keys {extra_keys}.",
+                    f"extra keys {extra_keys}.",
                     input_spec,
                 )
             # Add the command-line options for this input stream. We use

qlever/commands/settings.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import json
+
+from termcolor import colored
+
+from qlever.command import QleverCommand
+from qlever.log import log
+from qlever.util import run_command
+
+
+class SettingsCommand(QleverCommand):
+    """
+    Class for executing the `settings` command.
+    """
+
+    def __init__(self):
+        pass
+
+    def description(self) -> str:
+        return "Show or set server settings (after `qlever start`)"
+
+    def should_have_qleverfile(self) -> bool:
+        return True
+
+    def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
+        return {"server": ["port", "host_name", "access_token"]}
+
+    def additional_arguments(self, subparser) -> None:
+        all_keys = [
+            "always-multiply-unions",
+            "cache-max-num-entries",
+            "cache-max-size",
+            "cache-max-size-single-entry",
+            "default-query-timeout",
+            "group-by-disable-index-scan-optimizations",
+            "group-by-hash-map-enabled",
+            "lazy-index-scan-max-size-materialization",
+            "lazy-index-scan-num-threads",
+            "lazy-index-scan-queue-size",
+            "lazy-result-max-cache-size",
+            "query-planning-budget",
+            "service-max-value-rows",
+            "sort-estimate-cancellation-factor",
+            "throw-on-unbound-variables",
+            "use-binsearch-transitive-path",
+        ]
+        subparser.add_argument(
+            "runtime_parameter",
+            nargs="?",
+            help="Set the given runtime parameter (key=value)"
+            "; if no argument is given, show all settings",
+        ).completer = lambda **kwargs: [f"{key}=" for key in all_keys]
+        subparser.add_argument(
+            "--endpoint_url",
+            type=str,
+            help="An arbitrary endpoint URL "
+            "(overriding the one in the Qleverfile)",
+        )
+
+    def execute(self, args) -> bool:
+        # Get endpoint URL from command line or Qleverfile.
+        if args.endpoint_url:
+            endpoint_url = args.endpoint_url
+        else:
+            endpoint_url = f"http://{args.host_name}:{args.port}"
+
+        # Construct the `curl` command for getting or setting.
+        if args.runtime_parameter:
+            try:
+                parameter_key, parameter_value = args.runtime_parameter.split(
+                    "="
+                )
+            except ValueError:
+                log.error("Runtime parameter must be given as `key=value`")
+                return False
+
+            curl_cmd = (
+                f"curl -s {endpoint_url}"
+                f' --data-urlencode "{parameter_key}={parameter_value}"'
+                f' --data-urlencode "access-token={args.access_token}"'
+            )
+        else:
+            curl_cmd = (
+                f"curl -s {endpoint_url}" f" --data-urlencode cmd=get-settings"
+            )
+            parameter_key, parameter_value = None, None
+        self.show(curl_cmd, only_show=args.show)
+        if args.show:
+            return True
+
+        # Execute the `curl` command. Note that the `get-settings` command
+        # returns all settings in both scencarios (that is, also when setting a
+        # parameter).
+        try:
+            settings_json = run_command(curl_cmd, return_output=True)
+            settings_dict = json.loads(settings_json)
+        except Exception as e:
+            log.error(f"setting command failed: {e}")
+            return False
+        for key, value in settings_dict.items():
+            print(
+                colored(
+                    f"{key:<45}: {value}",
+                    "blue"
+                    if parameter_key and key == parameter_key
+                    else None,
+                )
+            )
+        return True

qlever/commands/start.py

@@ -13,6 +13,110 @@ from qlever.log import log
 from qlever.util import is_qlever_server_alive, run_command
 
 
+# Construct the command line based on the config file.
+def construct_command(args) -> str:
+    start_cmd = (
+        f"{args.server_binary}"
+        f" -i {args.name}"
+        f" -j {args.num_threads}"
+        f" -p {args.port}"
+        f" -m {args.memory_for_queries}"
+        f" -c {args.cache_max_size}"
+        f" -e {args.cache_max_size_single_entry}"
+        f" -k {args.cache_max_num_entries}"
+    )
+
+    if args.timeout:
+        start_cmd += f" -s {args.timeout}"
+    if args.access_token:
+        start_cmd += f" -a {args.access_token}"
+    if args.only_pso_and_pos_permutations:
+        start_cmd += " --only-pso-and-pos-permutations"
+    if not args.use_patterns:
+        start_cmd += " --no-patterns"
+    if args.use_text_index == "yes":
+        start_cmd += " -t"
+    start_cmd += f" > {args.name}.server-log.txt 2>&1"
+    return start_cmd
+
+
+# Kill existing server on the same port. Trust that StopCommand() works?
+# Maybe return StopCommand().execute(args) and handle it with a try except?
+def kill_existing_server(args) -> bool:
+    args.cmdline_regex = f"^ServerMain.* -p {args.port}"
+    args.no_containers = True
+    if not StopCommand().execute(args):
+        log.error("Stopping the existing server failed")
+        return False
+    log.info("")
+    return True
+
+
+# Run the command in a container
+def wrap_command_in_container(args, start_cmd) -> str:
+    if not args.server_container:
+        args.server_container = f"qlever.server.{args.name}"
+    start_cmd = Containerize().containerize_command(
+        start_cmd,
+        args.system,
+        "run -d --restart=unless-stopped",
+        args.image,
+        args.server_container,
+        volumes=[("$(pwd)", "/index")],
+        ports=[(args.port, args.port)],
+        working_directory="/index",
+    )
+    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 = (
+        f"curl -Gs http://localhost:{port}/api"
+        f' --data-urlencode "index-description={desc}"'
+        f" {access_arg} > /dev/null"
+    )
+    log.debug(curl_cmd)
+    try:
+        run_command(curl_cmd)
+    except Exception as e:
+        log.error(f"Setting the index description failed ({e})")
+        return False
+    return True
+
+
+# Set the text description.
+def set_text_description(access_arg, port, text_desc) -> bool:
+    curl_cmd = (
+        f"curl -Gs http://localhost:{port}/api"
+        f' --data-urlencode "text-description={text_desc}"'
+        f" {access_arg} > /dev/null"
+    )
+    log.debug(curl_cmd)
+    try:
+        run_command(curl_cmd)
+    except Exception as e:
+        log.error(f"Setting the text description failed ({e})")
+        return False
+    return True
+
+
 class StartCommand(QleverCommand):
     """
     Class for executing the `start` command.
@@ -22,22 +126,35 @@ class StartCommand(QleverCommand):
         pass
 
     def description(self) -> str:
-        return ("Start the QLever server (requires that you have built "
-                "an index with `qlever index` before)")
+        return (
+            "Start the QLever server (requires that you have built "
+            "an index with `qlever index` before)"
+        )
 
     def should_have_qleverfile(self) -> bool:
         return True
 
-    def relevant_qleverfile_arguments(self) -> dict[str: list[str]]:
-        return {"data": ["name", "description", "text_description"],
-                "server": ["server_binary", "host_name", "port",
-                           "access_token", "memory_for_queries",
-                           "cache_max_size", "cache_max_size_single_entry",
-                           "cache_max_num_entries", "num_threads",
-                           "timeout", "only_pso_and_pos_permutations",
-                           "use_patterns", "use_text_index",
-                           "warmup_cmd"],
-                "runtime": ["system", "image", "server_container"]}
+    def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
+        return {
+            "data": ["name", "description", "text_description"],
+            "server": [
+                "server_binary",
+                "host_name",
+                "port",
+                "access_token",
+                "memory_for_queries",
+                "cache_max_size",
+                "cache_max_size_single_entry",
+                "cache_max_num_entries",
+                "num_threads",
+                "timeout",
+                "only_pso_and_pos_permutations",
+                "use_patterns",
+                "use_text_index",
+                "warmup_cmd",
+            ],
+            "runtime": ["system", "image", "server_container"],
+        }
 
     def additional_arguments(self, subparser) -> None:
         # subparser.add_argument("--kill-existing-with-same-name",
@@ -46,16 +163,27 @@ class StartCommand(QleverCommand):
         #                        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",
-                               default=False,
-                               help="If a QLever server is already running "
-                                    "on the same port, kill it before "
-                                    "starting a new server")
-        subparser.add_argument("--no-warmup",
-                               action="store_true",
-                               default=False,
-                               help="Do not execute the warmup command")
+        subparser.add_argument(
+            "--kill-existing-with-same-port",
+            action="store_true",
+            default=False,
+            help="If a QLever server is already running "
+            "on the same port, kill it before "
+            "starting a new server",
+        )
+        subparser.add_argument(
+            "--no-warmup",
+            action="store_true",
+            default=False,
+            help="Do not execute the warmup command",
+        )
+        subparser.add_argument(
+            "--run-in-foreground",
+            action="store_true",
+            default=False,
+            help="Run the server in the foreground "
+            "(default: run in the background with `nohup`)",
+        )
 
     def execute(self, args) -> bool:
         # Kill existing server with the same name if so desired.
@@ -70,47 +198,21 @@ class StartCommand(QleverCommand):
 
         # Kill existing server on the same port if so desired.
         if args.kill_existing_with_same_port:
-            args.cmdline_regex = f"^ServerMain.* -p {args.port}"
-            args.no_containers = True
-            if not StopCommand().execute(args):
-                log.error("Stopping the existing server failed")
+            if args.kill_existing_with_same_port and not kill_existing_server(
+                args
+            ):
                 return False
-            log.info("")
 
         # Construct the command line based on the config file.
-        start_cmd = (f"{args.server_binary}"
-                     f" -i {args.name}"
-                     f" -j {args.num_threads}"
-                     f" -p {args.port}"
-                     f" -m {args.memory_for_queries}"
-                     f" -c {args.cache_max_size}"
-                     f" -e {args.cache_max_size_single_entry}"
-                     f" -k {args.cache_max_num_entries}")
-        if args.timeout:
-            start_cmd += f" -s {args.timeout}"
-        if args.access_token:
-            start_cmd += f" -a {args.access_token}"
-        if args.only_pso_and_pos_permutations:
-            start_cmd += " --only-pso-and-pos-permutations"
-        if not args.use_patterns:
-            start_cmd += " --no-patterns"
-        if args.use_text_index == "yes":
-            start_cmd += " -t"
-        start_cmd += f" > {args.name}.server-log.txt 2>&1"
+        start_cmd = construct_command(args)
 
         # Run the command in a container (if so desired). Otherwise run with
-        # `nohup` so that it keeps running after the shell is closed.
+        # `nohup` so that it keeps running after the shell is closed. With
+        # `--run-in-foreground`, run the server in the foreground.
         if args.system in Containerize.supported_systems():
-            if not args.server_container:
-                args.server_container = f"qlever.server.{args.name}"
-            start_cmd = Containerize().containerize_command(
-                    start_cmd,
-                    args.system, "run -d --restart=unless-stopped",
-                    args.image,
-                    args.server_container,
-                    volumes=[("$(pwd)", "/index")],
-                    ports=[(args.port, args.port)],
-                    working_directory="/index")
+            start_cmd = wrap_command_in_container(args, start_cmd)
+        elif args.run_in_foreground:
+            start_cmd = f"{start_cmd}"
         else:
             start_cmd = f"nohup {start_cmd} &"
 
@@ -121,35 +223,32 @@ class StartCommand(QleverCommand):
 
         # When running natively, check if the binary exists and works.
         if args.system == "native":
-            try:
-                run_command(f"{args.server_binary} --help")
-            except Exception as e:
-                log.error(f"Running \"{args.server_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}")
+            ret = check_binary(args.server_binary)
+            if not ret:
                 return False
 
         # Check if a QLever server is already running on this port.
-        port = args.port
-        if is_qlever_server_alive(port):
-            log.error(f"QLever server already running on port {port}")
+        endpoint_url = f"http://localhost:{args.port}"
+        if is_qlever_server_alive(endpoint_url):
+            log.error(f"QLever server already running on {endpoint_url}")
             log.info("")
-            log.info("To kill the existing server, use `qlever stop` "
-                     "or `qlever start` with option "
-                     "--kill-existing-with-same-port`")
+            log.info(
+                "To kill the existing server, use `qlever stop` "
+                "or `qlever start` with option "
+                "--kill-existing-with-same-port`"
+            )
 
             # Show output of status command.
-            args.cmdline_regex = f"^ServerMain.* -p *{port}"
+            args.cmdline_regex = f"^ServerMain.* -p *{args.port}"
             log.info("")
             StatusCommand().execute(args)
-
             return False
 
         # Remove already existing container.
-        if args.system in Containerize.supported_systems() \
-                and args.kill_existing_with_same_port:
+        if (
+            args.system in Containerize.supported_systems()
+            and args.kill_existing_with_same_port
+        ):
             try:
                 run_command(f"{args.system} rm -f {args.server_container}")
             except Exception as e:
@@ -166,7 +265,10 @@ class StartCommand(QleverCommand):
 
         # Execute the command line.
         try:
-            run_command(start_cmd)
+            process = run_command(
+                start_cmd,
+                use_popen=args.run_in_foreground,
+            )
         except Exception as e:
             log.error(f"Starting the QLever server failed ({e})")
             return False
@@ -174,41 +276,40 @@ class StartCommand(QleverCommand):
         # Tail the server log until the server is ready (note that the `exec`
         # is important to make sure that the tail process is killed and not
         # just the bash process).
-        log.info(f"Follow {args.name}.server-log.txt until the server is ready"
-                 f" (Ctrl-C stops following the log, but not the server)")
+        if args.run_in_foreground:
+            log.info(
+                f"Follow {args.name}.server-log.txt as long as the server is"
+                f" running (Ctrl-C stops the server)"
+            )
+        else:
+            log.info(
+                f"Follow {args.name}.server-log.txt until the server is ready"
+                f" (Ctrl-C stops following the log, but NOT the server)"
+            )
         log.info("")
         tail_cmd = f"exec tail -f {args.name}.server-log.txt"
         tail_proc = subprocess.Popen(tail_cmd, shell=True)
-        while not is_qlever_server_alive(port):
+        while not is_qlever_server_alive(endpoint_url):
             time.sleep(1)
 
-        # Set the access token if specified.
-        access_arg = f"--data-urlencode \"access-token={args.access_token}\""
+        # Set the description for the index and text.
+        access_arg = f'--data-urlencode "access-token={args.access_token}"'
         if args.description:
-            desc = args.description
-            curl_cmd = (f"curl -Gs http://localhost:{port}/api"
-                        f" --data-urlencode \"index-description={desc}\""
-                        f" {access_arg} > /dev/null")
-            log.debug(curl_cmd)
-            try:
-                run_command(curl_cmd)
-            except Exception as e:
-                log.error(f"Setting the index description failed ({e})")
+            ret = set_index_description(
+                access_arg, args.port, args.description
+            )
+            if not ret:
                 return False
         if args.text_description:
-            text_desc = args.text_description
-            curl_cmd = (f"curl -Gs http://localhost:{port}/api"
-                        f" --data-urlencode \"text-description={text_desc}\""
-                        f" {access_arg} > /dev/null")
-            log.debug(curl_cmd)
-            try:
-                run_command(curl_cmd)
-            except Exception as e:
-                log.error(f"Setting the text description failed ({e})")
+            ret = set_text_description(
+                access_arg, args.port, args.text_description
+            )
+            if not ret:
                 return False
 
         # Kill the tail process. NOTE: `tail_proc.kill()` does not work.
-        tail_proc.terminate()
+        if not args.run_in_foreground:
+            tail_proc.terminate()
 
         # Execute the warmup command.
         if args.warmup_cmd and not args.no_warmup:
@@ -218,8 +319,18 @@ class StartCommand(QleverCommand):
                 return False
 
         # Show cache stats.
-        log.info("")
-        args.detailed = False
-        args.server_url = None
-        CacheStatsCommand().execute(args)
+        if not args.run_in_foreground:
+            log.info("")
+            args.detailed = False
+            args.server_url = None
+            CacheStatsCommand().execute(args)
+
+        # With `--run-in-foreground`, wait until the server is stopped.
+        if args.run_in_foreground:
+            try:
+                process.wait()
+            except KeyboardInterrupt:
+                process.terminate()
+            tail_proc.terminate()
+
         return True

qlever/commands/stop.py

@@ -1,15 +1,40 @@
 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
+
+
+# try to stop and remove container. return True iff it was stopped
+# successfully. Gives log info accordingly.
+def stop_container(server_container):
+    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")
+            return True
+    return False
+
 
 class StopCommand(QleverCommand):
     """
@@ -20,7 +45,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 datasedataset or port"
 
     def should_have_qleverfile(self) -> bool:
         return True
@@ -54,46 +79,34 @@ class StopCommand(QleverCommand):
         # First check if there is container running and if yes, stop and remove
         # it (unless the user has specified `--no-containers`).
         if not args.no_containers:
-            for container_system in Containerize.supported_systems():
-                if Containerize.stop_and_remove_container(
-                        container_system, args.server_container):
-                    log.info(f"{container_system.capitalize()} container with "
-                             f"name \"{args.server_container}\" stopped "
-                             f" and removed")
-                    return True
+            if stop_container(args.server_container):
+                return True
 
         # 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'])
+                    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("")
-                try:
-                    proc.kill()
-                    log.info(f"Killed process {pinfo['pid']}")
-                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
-                return True
+                stop_process_results.append(stop_process(proc, pinfo))
+        if len(stop_process_results) > 0:
+            return all(stop_process_results)
 
         # If no matching process found, show a message and the output of the
         # status command.
         message = "No matching process found" if args.no_containers else \
-                  "No matching process or container found"
+            "No matching process or container found"
         log.error(message)
         args.cmdline_regex = "^ServerMain.* -i [^ ]*"
         log.info("")

qlever/util.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import errno
 import re
 import secrets
-import socket
 import shlex
 import shutil
+import socket
 import string
 import subprocess
 from datetime import date, datetime
@@ -30,8 +30,11 @@ def get_total_file_size(patterns: list[str]) -> int:
 
 
 def run_command(
-    cmd: str, return_output: bool = False, show_output: bool = False
-) -> Optional[str]:
+    cmd: str,
+    return_output: bool = False,
+    show_output: bool = False,
+    use_popen: bool = False,
+) -> Optional[str | subprocess.Popen]:
     """
     Run the given command and throw an exception if the exit code is non-zero.
     If `return_output` is `True`, return what the command wrote to `stdout`.
@@ -41,6 +44,7 @@ def run_command(
 
     TODO: Find the executable for `bash` in `__init__.py`.
     """
+
     subprocess_args = {
         "executable": shutil.which("bash"),
         "shell": True,
@@ -48,17 +52,21 @@ def run_command(
         "stdout": None if show_output else subprocess.PIPE,
         "stderr": subprocess.PIPE,
     }
+
+    # With `Popen`, the command runs in the current shell and a process object
+    # is returned (which can be used, e.g., to kill the process).
+    if use_popen:
+        if return_output:
+            raise Exception("Cannot return output if `use_popen` is `True`")
+        return subprocess.Popen(f"set -o pipefail; {cmd}", **subprocess_args)
+
+    # With `run`, the command runs in a subshell and the output is captured.
     result = subprocess.run(f"set -o pipefail; {cmd}", **subprocess_args)
+
     # If the exit code is non-zero, throw an exception. If something was
     # written to `stderr`, use that as the exception message. Otherwise, use a
     # generic message (which is also what `subprocess.run` does with
     # `check=True`).
-    # log.debug(f"Command `{cmd}` returned the following result")
-    # log.debug("")
-    # log.debug(f"exit code: {result.returncode}")
-    # log.debug(f"stdout: {result.stdout}")
-    # log.debug(f"stderr: {result.stderr}")
-    # log.debug("")
     if result.returncode != 0:
         if len(result.stderr) > 0:
             raise Exception(result.stderr.replace("\n", " ").strip())
@@ -99,7 +107,11 @@ def run_curl_command(
         )
     )
     result = subprocess.run(
-        curl_cmd, shell=True, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        curl_cmd,
+        shell=True,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
     )
     # Case 1: An error occurred, raise an exception.
     if result.returncode != 0:
@@ -120,18 +132,23 @@ def run_curl_command(
     return result.stdout
 
 
-def is_qlever_server_alive(port: str) -> bool:
+def is_qlever_server_alive(endpoint_url: str) -> bool:
     """
     Helper function that checks if a QLever server is running on the given
-    port.
+    endpoint. Return `True` if the server is alive, `False` otherwise.
     """
 
-    message = "from the qlever script".replace(" ", "%20")
-    curl_cmd = f"curl -s http://localhost:{port}/ping?msg={message}"
-    exit_code = subprocess.call(
-        curl_cmd, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    message = "from the `qlever` CLI"
+    curl_cmd = (
+        f"curl -s {endpoint_url}/ping"
+        f" --data-urlencode msg={shlex.quote(message)}"
     )
-    return exit_code == 0
+    log.debug(curl_cmd)
+    try:
+        run_command(curl_cmd)
+        return True
+    except Exception:
+        return False
 
 
 def get_existing_index_files(basename: str) -> list[str]:

{qlever-0.5.15.dist-info → qlever-0.5.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: qlever
-Version: 0.5.15
+Version: 0.5.17
 Summary: Script for using the QLever SPARQL engine.
 Author-email: Hannah Bast <bast@cs.uni-freiburg.de>
 License: Apache-2.0

{qlever-0.5.15.dist-info → qlever-0.5.17.dist-info}/RECORD

@@ -6,7 +6,7 @@ qlever/log.py,sha256=2O_RvFymnu_dB10ErBTAOsI8bgjORfdD0tE3USH-siM,1315
 qlever/qlever_main.py,sha256=-E4W8YdZ_teszGwXu6bQgBcH3y47TFJU8JLPIDwc_-g,2449
 qlever/qlever_old.py,sha256=X-JxmepFKYeFgSLLp0TRDNqXSxDwIbc8_0Xstiems8c,62026
 qlever/qleverfile.py,sha256=lygAjI5_wV_e-JoIGIqVTdd4yyvApzZiSlqSsmdlJpU,14529
-qlever/util.py,sha256=qLxBRyHPT2VTj0xcOCFcP6HV-Lm-g-64QpvOc4V0_a8,8029
+qlever/util.py,sha256=xAK9GT8SgU3z65F1dFXazxsd60letqLQqQAZ81mdJSY,8374
 qlever/Qleverfiles/Qleverfile.dblp,sha256=RaTJrabloAdaHwSl5V7Ws9phWyM_oXPSeZpKodZXA6c,1256
 qlever/Qleverfiles/Qleverfile.dblp-plus,sha256=TJHxp8I1P6JKJjbuAllEpB32-huuY1gH0FlenqPVJ5g,1334
 qlever/Qleverfiles/Qleverfile.dbpedia,sha256=aaNZZayE-zVePGSwPzXemkX__Ns8-kP_E7DNNKZPnqg,1160
@@ -31,22 +31,24 @@ qlever/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qlever/commands/add_text_index.py,sha256=cvBhX5rooRAXsn1Oput6b0B10w-MGMfS4ZPAhDfm7OQ,3669
 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=g5s9nPDj9SmvLYF_sexESDJxl7YzM9cAbNqPVU5-wZg,19526
+qlever/commands/example_queries.py,sha256=8a7ViBkWP32UqC9-0vhmjo4mc6ZMfjnPlwzVthiHnPk,22792
+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=02o_-EFwxyCOY7Pl49O1tVvMQELWTb5tCwdmSlNgM8w,12777
+qlever/commands/index.py,sha256=__vDlHnSkKNVqBAPZv2dzC5FYSI4QivOvjDHubFU35Q,12778
 qlever/commands/index_stats.py,sha256=9EBo1Oq5PGjajrvWJNafJ-Wg_d90DaO5AGq9a5plSRM,11720
 qlever/commands/log.py,sha256=vLqkgtx1udnQqoUBMWB5G9rwr-l7UKrDpyFYSMuoXWw,1987
 qlever/commands/query.py,sha256=vu6vTeTqtKhuKbv_wzloHvbJFj_2GTHPIfDpQfrc8FE,3603
+qlever/commands/settings.py,sha256=lyI_mdRMp3zv3RQ-tU2g2ZivfMD0r0R6ODf0VH9aVBk,3742
 qlever/commands/setup_config.py,sha256=wEy1LAunpOnqrUCbazMpt1u9HJCKgXJEMxF3zjh0jb0,3344
-qlever/commands/start.py,sha256=TdAulZqkTv9W0QBPwQqg-ixYI3iHMpZ1SHHvFRO_jbs,9524
+qlever/commands/start.py,sha256=gtYKB1sgc5SwY0DA3IMnowXMqXccHA2cOYZ71dgey5k,11589
 qlever/commands/status.py,sha256=TtnBqcdkF3zTDKft07zpVcIX7kFu7d_nOy9b6Ohh9vQ,1650
-qlever/commands/stop.py,sha256=AVafaoNb1JYmhulZ9_Bvq5gKcxBekb-S1QQRjBFo_-k,4160
+qlever/commands/stop.py,sha256=z25gWfLA9qIJ7F3zWZa0p0oVnt61kHcsB1evjgXhKX4,4557
 qlever/commands/system_info.py,sha256=Y3DtUJAlnh6uSvIVoToE10G7SStu-L5NbalIXvBB6D0,4614
 qlever/commands/ui.py,sha256=Ppo6YXA8JXNDPvC5D5duKGMPyhRvXfc1CaoSwjL-jBg,3644
 qlever/commands/warmup.py,sha256=kJHzS7HJo8pD2CphJuaXDj_CYP02YDo2DVM-pun3A80,1029
-qlever-0.5.15.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-qlever-0.5.15.dist-info/METADATA,sha256=A9M3q3eqWpFdUBOgKMNiPE8LnR5u78LCHJqCIZaQAfY,4583
-qlever-0.5.15.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-qlever-0.5.15.dist-info/entry_points.txt,sha256=U_gbYYi0wwdsn884eb0XoOXfvhACOsxhlO330dZ9bi0,87
-qlever-0.5.15.dist-info/top_level.txt,sha256=kd3zsYqiFd0--Czh5XTVkfEq6XR-XgRFW35X0v0GT-c,7
-qlever-0.5.15.dist-info/RECORD,,
+qlever-0.5.17.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+qlever-0.5.17.dist-info/METADATA,sha256=lQ-9nEtPrTwq2umXW5yylTGjB_zDHpvnF8yaP0dlyXo,4583
+qlever-0.5.17.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+qlever-0.5.17.dist-info/entry_points.txt,sha256=U_gbYYi0wwdsn884eb0XoOXfvhACOsxhlO330dZ9bi0,87
+qlever-0.5.17.dist-info/top_level.txt,sha256=kd3zsYqiFd0--Czh5XTVkfEq6XR-XgRFW35X0v0GT-c,7
+qlever-0.5.17.dist-info/RECORD,,

{qlever-0.5.15.dist-info → qlever-0.5.17.dist-info}/WHEEL

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