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

qlever/commands/cache_stats.py

@@ -17,45 +17,58 @@ class CacheStatsCommand(QleverCommand):
         pass
 
     def description(self) -> str:
-        return ("Show how much of the cache is currently being used")
+        return "Show how much of the cache is currently being used"
 
     def should_have_qleverfile(self) -> bool:
         return False
 
-    def relevant_qleverfile_arguments(self) -> dict[str: list[str]]:
+    def relevant_qleverfile_arguments(self) -> dict[str : list[str]]:
         return {"server": ["host_name", "port"]}
 
     def additional_arguments(self, subparser) -> None:
-        subparser.add_argument("--server-url",
-                               help="URL of the QLever server, default is "
-                               "{host_name}:{port}")
-        subparser.add_argument("--detailed",
-                               action="store_true",
-                               default=False,
-                               help="Show detailed statistics and settings")
+        subparser.add_argument(
+            "--server-url",
+            help="URL of the QLever server, default is {host_name}:{port}",
+        )
+        subparser.add_argument(
+            "--detailed",
+            action="store_true",
+            default=False,
+            help="Show detailed statistics and settings",
+        )
 
     def execute(self, args) -> bool:
         # Construct the two curl commands.
-        server_url = (args.server_url if args.server_url
-                      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} "
-                              f"--data-urlencode \"cmd=get-settings\"")
+        server_url = (
+            args.server_url
+            if args.server_url
+            else f"{args.host_name}:{args.port}"
+        )
+        cache_stats_cmd = (
+            f'curl -s {server_url} --data-urlencode "cmd=cache-stats"'
+        )
+        cache_settings_cmd = (
+            f'curl -s {server_url} --data-urlencode "cmd=get-settings"'
+        )
 
         # Show them.
-        self.show("\n".join([cache_stats_cmd, cache_settings_cmd]),
-                  only_show=args.show)
+        self.show(
+            "\n".join([cache_stats_cmd, cache_settings_cmd]),
+            only_show=args.show,
+        )
         if args.show:
             return True
 
         # Execute them.
         try:
             cache_stats = subprocess.check_output(cache_stats_cmd, shell=True)
-            cache_settings = subprocess.check_output(cache_settings_cmd,
-                                                     shell=True)
+            cache_settings = subprocess.check_output(
+                cache_settings_cmd, shell=True
+            )
             cache_stats_dict = json.loads(cache_stats)
             cache_settings_dict = json.loads(cache_settings)
+            if isinstance(cache_settings_dict, list):
+                cache_settings_dict = cache_settings_dict[0]
         except Exception as e:
             log.error(f"Failed to get cache stats and settings: {e}")
             return False
@@ -64,27 +77,35 @@ class CacheStatsCommand(QleverCommand):
         if not args.detailed:
             cache_size = cache_settings_dict["cache-max-size"]
             if not cache_size.endswith(" GB"):
-                log.error(f"Cache size {cache_size} is not in GB, "
-                          f"QLever should return bytes instead")
+                log.error(
+                    f"Cache size {cache_size} is not in GB, "
+                    f"QLever should return bytes instead"
+                )
                 return False
             else:
                 cache_size = float(cache_size[:-3])
-            pinned_size = cache_stats_dict["pinned-size"] / 1e9
-            non_pinned_size = cache_stats_dict["non-pinned-size"] / 1e9
+            pinned_size = cache_stats_dict["cache-size-pinned"] / 1e9
+            non_pinned_size = cache_stats_dict["cache-size-unpinned"] / 1e9
             cached_size = pinned_size + non_pinned_size
             free_size = cache_size - cached_size
             if cached_size == 0:
                 log.info(f"Cache is empty, all {cache_size:.1f} GB available")
             else:
-                log.info(f"Pinned queries     : "
-                         f"{pinned_size:5.1f} GB of {cache_size:5.1f} GB"
-                         f"  [{pinned_size / cache_size:5.1%}]")
-                log.info(f"Non-pinned queries : "
-                         f"{non_pinned_size:5.1f} GB of {cache_size:5.1f} GB"
-                         f"  [{non_pinned_size / cache_size:5.1%}]")
-                log.info(f"FREE               : "
-                         f"{free_size:5.1f} GB of {cache_size:5.1f} GB"
-                         f"  [{1 - cached_size / cache_size:5.1%}]")
+                log.info(
+                    f"Pinned queries     : "
+                    f"{pinned_size:5.1f} GB of {cache_size:5.1f} GB"
+                    f"  [{pinned_size / cache_size:5.1%}]"
+                )
+                log.info(
+                    f"Non-pinned queries : "
+                    f"{non_pinned_size:5.1f} GB of {cache_size:5.1f} GB"
+                    f"  [{non_pinned_size / cache_size:5.1%}]"
+                )
+                log.info(
+                    f"FREE               : "
+                    f"{free_size:5.1f} GB of {cache_size:5.1f} GB"
+                    f"  [{1 - cached_size / cache_size:5.1%}]"
+                )
             return True
 
         # Complete version.
@@ -96,6 +117,7 @@ class CacheStatsCommand(QleverCommand):
                 if re.match(r"^\d+\.\d+$", value):
                     value = "{:.2f}".format(float(value))
                 log.info(f"{key.ljust(max_key_len)} : {value}")
+
         show_dict_as_table(cache_stats_dict.items())
         log.info("")
         show_dict_as_table(cache_settings_dict.items())

qlever/commands/index.py

@@ -36,9 +36,11 @@ class IndexCommand(QleverCommand):
             "index": [
                 "input_files",
                 "cat_input_files",
+                "encode_as_id",
                 "multi_input_json",
                 "parallel_parsing",
                 "settings_json",
+                "vocabulary_type",
                 "index_binary",
                 "only_pso_and_pos_permutations",
                 "ulimit",
@@ -184,6 +186,7 @@ class IndexCommand(QleverCommand):
             index_cmd = (
                 f"{args.cat_input_files} | {args.index_binary}"
                 f" -i {args.name} -s {args.name}.settings.json"
+                f" --vocabulary-type {args.vocabulary_type}"
                 f" -F {args.format} -f -"
             )
             if args.parallel_parsing:
@@ -199,6 +202,7 @@ class IndexCommand(QleverCommand):
             index_cmd = (
                 f"{args.index_binary}"
                 f" -i {args.name} -s {args.name}.settings.json"
+                f" --vocabulary-type {args.vocabulary_type}"
                 f" {input_options}"
             )
         else:
@@ -212,6 +216,8 @@ class IndexCommand(QleverCommand):
             return False
 
         # Add remaining options.
+        if args.encode_as_id:
+            index_cmd += f" --encode-as-id {args.encode_as_id}"
         if args.only_pso_and_pos_permutations:
             index_cmd += " --only-pso-and-pos-permutations --no-patterns"
         if not args.use_patterns:

qlever/commands/query.py

@@ -72,6 +72,7 @@ class QueryCommand(QleverCommand):
                 "application/sparql-results+json",
                 "application/sparql-results+xml",
                 "application/qlever-results+json",
+                "application/octet-stream",
             ],
             default="text/tab-separated-values",
             help="Accept header for the SPARQL query",
@@ -94,7 +95,7 @@ class QueryCommand(QleverCommand):
         if args.pin_to_cache:
             args.accept = "application/qlever-results+json"
             curl_cmd_additions = (
-                f" --data pinresult=true --data send=0"
+                f" --data pin-result=true --data send=0"
                 f" --data access-token="
                 f"{shlex.quote(args.access_token)}"
                 f" | jq .resultsize | numfmt --grouping"

qlever/commands/settings.py

@@ -34,6 +34,8 @@ class SettingsCommand(QleverCommand):
             "cache-max-size-single-entry",
             "cache-service-results",
             "default-query-timeout",
+            "division-by-zero-is-undef",
+            "enable-prefilter-on-index-scans",
             "group-by-disable-index-scan-optimizations",
             "group-by-hash-map-enabled",
             "lazy-index-scan-max-size-materialization",
@@ -44,6 +46,9 @@ class SettingsCommand(QleverCommand):
             "request-body-limit",
             "service-max-value-rows",
             "sort-estimate-cancellation-factor",
+            "spatial-join-prefilter-max-size",
+            "spatial-join-max-num-threads",
+            "syntax-test-mode",
             "throw-on-unbound-variables",
             "use-binsearch-transitive-path",
         ]
@@ -97,6 +102,8 @@ class SettingsCommand(QleverCommand):
         try:
             settings_json = run_command(curl_cmd, return_output=True)
             settings_dict = json.loads(settings_json)
+            if isinstance(settings_dict, list):
+                settings_dict = settings_dict[0]
         except Exception as e:
             log.error(f"setting command failed: {e}")
             return False

qlever/commands/ui.py

@@ -13,13 +13,16 @@ 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 dict_to_yaml(dictionary: dict) -> str:
+    """
+    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.SafeDumper):
         def represent_scalar(self, tag, value, style=None):
             value = value.replace("\r\n", "\n")
             if isinstance(value, str) and "\n" in value:
@@ -30,6 +33,7 @@ def dict_to_yaml(dictionary):
     return yaml.dump(
         dictionary,
         sort_keys=False,
+        allow_unicode=True,
         Dumper=MultiLineDumper,
     )