qlever 0.2.5__py3-none-any.whl → 0.5.41__py3-none-any.whl

qlever/util.py

@@ -0,0 +1,330 @@
+from __future__ import annotations
+
+import errno
+import re
+import secrets
+import shlex
+import shutil
+import socket
+import string
+import subprocess
+from datetime import date, datetime
+from pathlib import Path
+from typing import Any, Optional
+
+import psutil
+
+from qlever.log import log
+
+
+def get_total_file_size(patterns: list[str]) -> int:
+    """
+    Helper function that gets the total size of all files mathing the given
+    patterns in bytes.
+    """
+
+    total_size = 0
+    search_dir = Path.cwd()
+    for pattern in patterns:
+        for file in search_dir.glob(pattern):
+            total_size += file.stat().st_size
+    return total_size
+
+
+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]:
+    """
+    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`.
+
+    NOTE: The `set -o pipefail` ensures that the exit code of the command is
+    non-zero if any part of the pipeline fails (not just the last part).
+
+    TODO: Find the executable for `bash` in `__init__.py`.
+    """
+
+    subprocess_args = {
+        "executable": shutil.which("bash"),
+        "shell": True,
+        "text": True,
+        "stdout": None if show_output else subprocess.PIPE,
+        "stderr": None if show_stderr else 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`).
+    if result.returncode != 0:
+        if len(result.stderr) > 0:
+            raise Exception(result.stderr.replace("\n", " ").strip())
+        else:
+            raise Exception(
+                f"Command failed with exit code {result.returncode}, "
+                f" nothing written to stderr (stdout: {result.stdout})"
+            )
+    # Optionally, return what was written to `stdout`.
+    if return_output:
+        return result.stdout
+
+
+def run_curl_command(
+    url: str,
+    headers: dict[str, str] = {},
+    params: dict[str, str] = {},
+    result_file: Optional[str] = None,
+) -> str:
+    """
+    Run `curl` with the given `url`, `headers`, and `params`. If `result_file`
+    is `None`, return the output, otherwise, write the output to the given file
+    and return the HTTP code. If the `curl` command fails, throw an exception.
+
+    """
+    # Construct and run the `curl` command.
+    default_result_file = "/tmp/qlever.curl.result"
+    actual_result_file = result_file if result_file else default_result_file
+    curl_cmd = (
+        f'curl -Ls -o "{actual_result_file}"'
+        f' -w "%{{http_code}}\n" {url}'
+        + "".join([f' -H "{key}: {value}"' for key, value in headers.items()])
+        + "".join(
+            [
+                f" --data-urlencode {key}={shlex.quote(value)}"
+                for key, value in params.items()
+            ]
+        )
+    )
+    result = subprocess.run(
+        curl_cmd,
+        shell=True,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    # Case 1: An error occurred, raise an exception.
+    if result.returncode != 0:
+        if len(result.stderr) > 0:
+            raise Exception(result.stderr)
+        else:
+            raise Exception(
+                f"curl command failed with exit code "
+                f"{result.returncode}, stderr is empty"
+            )
+    # Case 2: Return output (read from `default_result_file`).
+    if result_file is None:
+        result_file_path = Path(default_result_file)
+        result = result_file_path.read_text()
+        result_file_path.unlink()
+        return result
+    # Case 3: Return HTTP code.
+    return result.stdout
+
+
+def is_qlever_server_alive(endpoint_url: str) -> bool:
+    """
+    Helper function that checks if a QLever server is running on the given
+    endpoint. Return `True` if the server is alive, `False` otherwise.
+    """
+
+    message = "from the `qlever` CLI"
+    curl_cmd = (
+        f"curl -s {endpoint_url}/ping"
+        f" --data-urlencode msg={shlex.quote(message)}"
+    )
+    log.debug(curl_cmd)
+    try:
+        run_command(curl_cmd)
+        return True
+    except Exception:
+        return False
+
+
+def get_existing_index_files(basename: str) -> list[str]:
+    """
+    Helper function that returns a list of all index files for `basename` in
+    the current working directory.
+    """
+    existing_index_files = []
+    existing_index_files.extend(Path.cwd().glob(f"{basename}.index.*"))
+    existing_index_files.extend(Path.cwd().glob(f"{basename}.text.*"))
+    existing_index_files.extend(Path.cwd().glob(f"{basename}.vocabulary.*"))
+    existing_index_files.extend(Path.cwd().glob(f"{basename}.meta-data.json"))
+    existing_index_files.extend(Path.cwd().glob(f"{basename}.prefixes"))
+    # Return only the file names, not the full paths.
+    return [path.name for path in existing_index_files]
+
+
+def show_process_info(psutil_process, cmdline_regex, show_heading=True):
+    """
+    Helper function that shows information about a process if information
+    about the process can be retrieved and the command line matches the
+    given regex (in which case the function returns `True`). The heading is
+    only shown if `show_heading` is `True` and the function returns `True`.
+    """
+
+    # Helper function that shows a line of the process table.
+    def show_table_line(pid, user, start_time, rss, cmdline):
+        log.info(f"{pid:<8} {user:<8} {start_time:>5}  {rss:>5} {cmdline}")
+
+    try:
+        pinfo = psutil_process.as_dict(
+            attrs=["pid", "username", "create_time", "memory_info", "cmdline"]
+        )
+        # Note: pinfo[`cmdline`] is `None` if the process is a zombie.
+        cmdline = " ".join(pinfo["cmdline"] or [])
+        if len(cmdline) == 0 or not re.search(cmdline_regex, cmdline):
+            return False
+        pid = pinfo["pid"]
+        user = pinfo["username"] if pinfo["username"] else ""
+        start_time = datetime.fromtimestamp(pinfo["create_time"])
+        if start_time.date() == date.today():
+            start_time = start_time.strftime("%H:%M")
+        else:
+            start_time = start_time.strftime("%b%d")
+        rss = f"{pinfo['memory_info'].rss / 1e9:.0f}G"
+        if show_heading:
+            show_table_line("PID", "USER", "START", "RSS", "COMMAND")
+        show_table_line(pid, user, start_time, rss, cmdline)
+        return True
+    except Exception as e:
+        log.error(f"Could not get process info: {e}")
+        return False
+
+
+def get_random_string(length: int) -> str:
+    """
+    Helper function that returns a randomly chosen string of the given
+    length. Take the current time as seed.
+    """
+    characters = string.ascii_letters + string.digits
+    return "".join(secrets.choice(characters) for _ in range(length))
+
+
+def is_port_used(port: int) -> bool:
+    """
+    Try to bind to the port on all interfaces to check if the port is already in use.
+    If the port is already in use, `socket.bind` will raise an `OSError` with errno EADDRINUSE.
+    """
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        # Ensure that the port is not blocked after the check.
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(("", port))
+        sock.close()
+        return False
+    except OSError as err:
+        if err.errno != errno.EADDRINUSE:
+            log.warning(f"Failed to determine if port is used: {err}")
+        return True
+
+
+def format_size(bytes, suffix="B"):
+    """
+    Scale bytes to its proper format
+    e.g:
+        1253656 => '1.20MB'
+        1253656678 => '1.17GB'
+    """
+    factor = 1024
+    for unit in ["", "K", "M", "G", "T", "P"]:
+        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:
+            # For some processes (e.g., zombies), getting info may fail.
+            log.debug(f"Error getting process info: {e}")
+            continue
+        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.41.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: qlever
+Version: 0.5.41
+Summary: Command-line tool for using the QLever graph database
+Author-email: Hannah Bast <bast@cs.uni-freiburg.de>
+License-Expression: Apache-2.0
+Project-URL: homepage, https://github.com/ad-freiburg/qlever
+Project-URL: documentation, https://docs.qlever.dev
+Project-URL: repository, https://github.com/ad-freiburg/qlever.git
+Project-URL: bugtracker, https://github.com/ad-freiburg/qlever/issues
+Keywords: Graph database,Triplestore,Knowledge graphs,SPARQL,RDF
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil
+Requires-Dist: termcolor
+Requires-Dist: argcomplete
+Requires-Dist: pyyaml
+Requires-Dist: rdflib
+Requires-Dist: requests-sse
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# QLever
+
+This repository provides a self-documenting and easy-to-use command-line tool
+for QLever (pronounced "Clever"), a graph database implementing the
+[RDF](https://www.w3.org/TR/rdf11-concepts/) and
+[SPARQL](https://www.w3.org/TR/sparql11-overview/) standards. 
+For a detailed description of what QLever is and what it can do, see 
+[here](https://github.com/ad-freiburg/qlever).
+
+# Installation
+
+Simply do `pip install qlever` and make sure that the directory where `pip`
+installs the package is in your `PATH`. Typically, `pip` will warn you when
+that is not the case and tell you what to do. If you encounter an "Externally
+managed Environment" error, try `pipx` instead of `pip`.
+
+Type `qlever` without arguments to check that the installation worked. When
+using it for the first time, you will see a warning at the top with
+instructions on how to enable autocompletion. Do it, it makes using `qlever`
+so much easier (`pip` cannot do that for you automatically, sorry).
+
+# Usage
+
+Create an empty directory, with a name corresponding to the dataset you want to
+work with. For the following example, take `olympics`. Go to that directory
+and do the following.
+
+```
+qlever setup-config olympics   # Get Qleverfile (config file) for this dataset
+qlever get-data                # Download the dataset
+qlever index                   # Build index data structures for this dataset
+qlever start                   # Start a QLever server using that index
+qlever query                   # Launch an example query
+qlever ui                      # Launch the QLever UI
+```
+
+This will create a SPARQL endpoint for the [120 Years of
+Olympics](https://github.com/wallscope/olympics-rdf) dataset. It is a great
+dataset for getting started because it is small, but not trivial (around 2
+million triples), and the downloading and indexing should only take a few
+seconds.
+
+Each command will also show you the command line it uses. That way you can
+learn, on the side, how QLever works internally. If you just want to know the
+command line for a particular command, without executing it, you can append
+`--show` like this:
+
+```
+qlever index --show
+```
+
+There are many more commands and options, see `qlever --help` for general help,
+`qlever <command> --help` for help on a specific command, or just use the
+autocompletion.
+
+# Use on macOS and Windows
+
+By default, `qlever` uses [QLever's official Docker
+image](https://hub.docker.com/r/adfreiburg/qlever). In principle, that image
+runs on Linux, macOS, and Windows. On Linux, Docker runs natively
+and incurs only a relatively small overhead regarding performance and RAM
+consumption. On macOS and Windows, Docker runs in a virtual machine, which
+incurs a significant and sometimes unpredictable overhead. For example, `qlever
+index` might abort prematurely (without a proper error message) because the
+virtual machine runs out of RAM.
+
+For optimal performance, compile QLever from source on your machine. For Linux,
+this is relatively straightforward: just follow the `RUN` instructions in the
+[Dockerfile](https://github.com/ad-freiburg/qlever/blob/master/Dockerfile). For
+macOS, this is more complicated, see [this
+workflow](https://github.com/ad-freiburg/qlever/blob/master/.github/workflows/macos.yml).
+
+# Use with your own dataset
+
+To use QLever with your own dataset, you need a `Qleverfile`, like in the
+example above. The easiest way to write a `Qleverfile` is to get one of the
+existing ones (using `qlever setup-config ...` as explained above) and then
+change it according to your needs (the variable names should be
+self-explanatory). Pick one for a dataset that is similar to yours and when in
+doubt, pick `olympics`.
+
+# For developers
+
+The (Python) code for the script is in the `*.py` files in `src/qlever`. The
+preconfigured Qleverfiles are in `src/qlever/Qleverfiles`.
+
+If you want to make changes to the script, or add new commands, do as follows:
+
+```
+git clone https://github.com/ad-freiburg/qlever-control
+cd qlever-control
+pip install -e .
+```
+
+Then you can use `qlever` just as if you had installed it via `pip install
+qlever`. Note that you don't have to rerun `pip install -e .` when you modify
+any of the `*.py` files and not even when you add new commands in
+`src/qlever/commands`. The exceutable created by `pip` simply links and refers
+to the files in your working copy.
+
+If you have bug fixes or new useful features or commands, please open a pull
+request. If you have questions or suggestions, please open an issue.

qlever-0.5.41.dist-info/RECORD

@@ -0,0 +1,59 @@
+qlever/__init__.py,sha256=ZbzivHALRlzAUoFBBSbbkKFcvATBX7yVR6Q9JyEQ8ig,1631
+qlever/command.py,sha256=QTg1SOiVc8_v0RYxwu74dv9FhVJs85RKMfAZuklEw6o,2766
+qlever/config.py,sha256=gNw2_-jj1TjzhzqLOuUI_Dh19q_ViCiArrtrgXL2F4E,10354
+qlever/containerize.py,sha256=QK2CylUnbZ0r-YCCnJMjxupE5ZBIlQZmS1Vn0-3PiI4,5496
+qlever/log.py,sha256=WLscWV4fFF_w_uXSOfvWzhyzRM7t_61inE2ks3zf6Gw,1317
+qlever/qlever_main.py,sha256=QlVXq7azyuAG0QhH_pER2fdZL8el2mG0I6d9r0dGgOA,2593
+qlever/qleverfile.py,sha256=hNn_tmJxlLWrkp7pl9hOaKkVRVLO22bZUh9MfSklng4,20083
+qlever/util.py,sha256=86v5tyoPoCiWqWOu8pLB7M2GwQO251hhbKF2cN0-vCY,11036
+qlever/Qleverfiles/Qleverfile.dblp,sha256=y4AyUg8Dk2NHV972aeqnj77GZzWbgwV-zRD1qcdwhQE,1246
+qlever/Qleverfiles/Qleverfile.dblp-plus,sha256=TJHxp8I1P6JKJjbuAllEpB32-huuY1gH0FlenqPVJ5g,1334
+qlever/Qleverfiles/Qleverfile.dbpedia,sha256=aaNZZayE-zVePGSwPzXemkX__Ns8-kP_E7DNNKZPnqg,1160
+qlever/Qleverfiles/Qleverfile.default,sha256=Kj-J1Kkv8PWN7wuMdZU6DUUlEuBIcSNysJCE-R63we8,2407
+qlever/Qleverfiles/Qleverfile.dnb,sha256=43w_CVi00yf7FHdDvBtHHQR3yU1d-JCNnD_uxYZJOvk,1803
+qlever/Qleverfiles/Qleverfile.fbeasy,sha256=CYmbxRnb4OFAagwoVfciyFR_26G-Ohk1ObBL6duSfuE,936
+qlever/Qleverfiles/Qleverfile.freebase,sha256=Kol5ffUjJ5cXIWRxdY-SotOG1kGm82gZ3S8OV4BnrJA,1036
+qlever/Qleverfiles/Qleverfile.imdb,sha256=iEzJuDU1AaC7-EZYfocaoEb32VH-QvbBiXhnzwWmGaQ,1756
+qlever/Qleverfiles/Qleverfile.ohm-planet,sha256=Cr0MI0mSDnfaDI1iDyKhA2wO4XjdMmewlUc4Ge4Gc5c,2735
+qlever/Qleverfiles/Qleverfile.olympics,sha256=5w9BOFwEBhdSzPz-0LRxwhv-7Gj6xbF539HOXr3cqD0,1088
+qlever/Qleverfiles/Qleverfile.orkg,sha256=Uizz-RhlSeExgfckWztewa4l_v3zMN8IR7NaGYKrqt4,937
+qlever/Qleverfiles/Qleverfile.osm-country,sha256=4Y2zCetMSxfRa23LPv-uYXJHMtIhl8lwOSbZgU_eIQc,1843
+qlever/Qleverfiles/Qleverfile.osm-planet,sha256=fbP0y_OAx1-eOAA1PaEjaDwL-5QIrctBDJnxh_1D084,1758
+qlever/Qleverfiles/Qleverfile.osm-planet-from-pbf,sha256=62IGpXkw0RyLyi0boyf2W3LEh3o_QtRM8o15QV1OPL4,2207
+qlever/Qleverfiles/Qleverfile.pubchem,sha256=7RvCNJXxxyuhVpzaHVY03Rsoeml3cTkkKeonp9fiHek,14474
+qlever/Qleverfiles/Qleverfile.scientists,sha256=9eZ2c6P9a3E3VHa3RR7LdOQbF4k3oyyrn56Z3u4LZYs,1164
+qlever/Qleverfiles/Qleverfile.uniprot,sha256=s27n8yoNlQsIOO-vqgBkvmTn-s-dq7_wYthReAo57f0,6273
+qlever/Qleverfiles/Qleverfile.vvz,sha256=cLzm85erKoFCDllH5eFcSi35MdR6Tahj1MgtvGRxanM,922
+qlever/Qleverfiles/Qleverfile.wikidata,sha256=KLal5FjAzcEU0aqUDC5muFunm_Lti8is4RGu4IOQuMg,2061
+qlever/Qleverfiles/Qleverfile.wikipathways,sha256=GENI4KYtrn_4M9mnGnfGPNkKy_lAPfO2LwnzbOx3fCE,1982
+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=8Ri9e2cfJmsWLjD-iEB5jkbm4toEME0bccMJJkyx_sU,3819
+qlever/commands/benchmark_queries.py,sha256=znT4pCCtvSgyXNWOEBJcRZ6lR_4zUDG4YphvUyzM2Zw,39204
+qlever/commands/cache_stats.py,sha256=7JL1P4SX0F8xyN5VTiOSG5E1reCcM1rPaQsqllHuFTM,4366
+qlever/commands/clear_cache.py,sha256=R0jRn_76A7dvyQyWgHld0THoYbohiVVEFAjBjOV3Uy4,2807
+qlever/commands/extract_queries.py,sha256=1l59ipbNNJIesOXQOf3b8xWYu4-tPP73dHl2qP8LR48,4281
+qlever/commands/get_data.py,sha256=nHOHMjv0tSLWJDOR0ba_LK-Bk-mcGnphb8hbqcVYFhE,1411
+qlever/commands/index.py,sha256=IOvT8GqrBXcb5JPQ82359Mf1cD5EgzTQoRro-3w5HRw,13395
+qlever/commands/index_stats.py,sha256=qNbDMogB83Ni5fGXPOZQO9VZQ_x2096vFyCCJ0jEuYw,11719
+qlever/commands/log.py,sha256=vLqkgtx1udnQqoUBMWB5G9rwr-l7UKrDpyFYSMuoXWw,1987
+qlever/commands/materialized_view.py,sha256=F9caIEfQbjDm2U-5iKelUiRkb8MceAesJiB2_zG6Mko,3523
+qlever/commands/query.py,sha256=QJpr_sxNL03OBXq9LIPiuhMoSVamgz-RF9uevbQ61QM,4652
+qlever/commands/rebuild_index.py,sha256=Iow3If0xhOQ2GYfRLuX5dXS5sk8wPdTicS_XTWjL_hk,6496
+qlever/commands/reset_updates.py,sha256=uJvfKPCbgp-9247Ievyb292nR1VvOcaAIcVM-EalP7o,1879
+qlever/commands/settings.py,sha256=YBob1LiYTSHTIZ6vIQcWc7hIWImP60HQCoacJu8XY2M,4001
+qlever/commands/setup_config.py,sha256=mFO-GWPBOI47IS4W4v56NSdA5SEncEHG2vZjG9lP6_4,3343
+qlever/commands/start.py,sha256=Moi1zbACmCxr3Fj3DzrEn-2W6dxB10GR0t7snIksgEo,11613
+qlever/commands/status.py,sha256=TtnBqcdkF3zTDKft07zpVcIX7kFu7d_nOy9b6Ohh9vQ,1650
+qlever/commands/stop.py,sha256=5BNKArOzoJ8kYiTVAmtN81w7nQ42fkxISgsxL-qJpO0,3463
+qlever/commands/system_info.py,sha256=16HMl-MSQITfesuupuRE7gajVcahhCxeA7NCOaKCiKk,4659
+qlever/commands/ui.py,sha256=QRSN-aO5jfG_97hz8lvo1x-SYWx_56zr78kVx6P8DWU,9810
+qlever/commands/update.py,sha256=9EAPuUct5gQvwEimpBsqxefYWVUezufAa90jzClAE7Q,2710
+qlever/commands/update_wikidata.py,sha256=VpYdgLetlNXk-FUTBV_evnw2hW00PQTzHEaI-1eKS-0,53540
+qlever/commands/warmup.py,sha256=kJHzS7HJo8pD2CphJuaXDj_CYP02YDo2DVM-pun3A80,1029
+qlever-0.5.41.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+qlever-0.5.41.dist-info/METADATA,sha256=g6rZUghOc1_4SesMiCvSEByeELZ-i0GPZIkYFrNuHhc,5373
+qlever-0.5.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qlever-0.5.41.dist-info/entry_points.txt,sha256=U_1U6SFIEZ-AnNlvk2nzcL0e4jnjEpuSbxYZ_E0XpEg,51
+qlever-0.5.41.dist-info/top_level.txt,sha256=kd3zsYqiFd0--Czh5XTVkfEq6XR-XgRFW35X0v0GT-c,7
+qlever-0.5.41.dist-info/RECORD,,

{qlever-0.2.5.dist-info → qlever-0.5.41.dist-info}/WHEEL

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

qlever-0.5.41.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qlever = qlever.qlever_main:main

qlever-0.5.41.dist-info/top_level.txt

@@ -0,0 +1 @@
+qlever