PythiaLabelGenerator 1.0.0__py3-none-any.whl

labelgenerator/main.py

@@ -0,0 +1,176 @@
+import argparse
+import pathlib
+import shutil
+import sys
+import time
+
+from labelgenerator import __version__
+from labelgenerator.label import compute_label
+from labelgenerator.logger import (
+    SCRIPT_START,
+    get_header,
+    log_runtime_information,
+    logger,
+)
+
+DEFAULT_RAXMLNG_EXE = (
+    pathlib.Path(shutil.which("raxml-ng")) if shutil.which("raxml-ng") else None
+)
+
+DEFAULT_IQTREE_EXE = (
+    pathlib.Path(shutil.which("iqtree2")) if shutil.which("iqtree2") else None
+)
+
+
+def _parse_cli():
+    parser = argparse.ArgumentParser(
+        description="Generate the ground truth difficulty for the given MSA."
+    )
+    parser.add_argument(
+        "-m",
+        "--msa",
+        type=str,
+        required=True,
+        help="Multiple Sequence Alignment to compute the ground truth difficulty for. "
+        "Must be in either phylip or fasta format.",
+    )
+
+    parser.add_argument(
+        "-r",
+        "--raxmlng",
+        type=str,
+        default=DEFAULT_RAXMLNG_EXE,
+        required=DEFAULT_RAXMLNG_EXE is None,
+        help="Path to the binary of RAxML-NG. For install instructions see https://github.com/amkozlov/raxml-ng."
+        "(default: 'raxml-ng' if in $PATH, otherwise this option is mandatory).",
+    )
+
+    parser.add_argument(
+        "-i",
+        "--iqtree",
+        type=str,
+        default=DEFAULT_IQTREE_EXE,
+        required=DEFAULT_IQTREE_EXE is None,
+        help="Path to the binary of IQ-TREE2. For install instructions see http://www.iqtree.org."
+        "(default: 'iqtree2' if in $PATH, otherwise this option is mandatory).",
+    )
+
+    parser.add_argument(
+        "-t",
+        "--threads",
+        type=int,
+        required=False,
+        help="Number of threads to use for the RAxML-NG tree inference and IQ-TREE statistical tests (default: autoconfig in RAxML-NG and IQ-TREE).",
+    )
+
+    parser.add_argument(
+        "-s",
+        "--seed",
+        type=int,
+        default=0,
+        required=False,
+        help="Seed for the RAxML-NG tree inference (default: 0).",
+    )
+
+    parser.add_argument(
+        "-p",
+        "--prefix",
+        type=str,
+        required=False,
+        help="Prefix of the RAxML-NG and IQ-TREE log and result files (default: MSA file name).",
+    )
+
+    parser.add_argument(
+        "--model",
+        type=str,
+        required=False,
+        help="Model to use for the RAxML-NG tree inference (default: 'GTR+G' for DNA, 'LG+G' for AA, "
+        "and 'MULTIx_GTR' for morphological data).",
+    )
+
+    parser.add_argument(
+        "--ntrees",
+        type=int,
+        required=False,
+        default=100,
+        help="Number of ML trees to infer (default: 100)",
+    )
+
+    parser.add_argument(
+        "--redo",
+        action="store_true",
+        help="Redo all computations, even if the results already exist.",
+    )
+
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=__version__,
+        help="Print the version number and exit.",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    logger.info(get_header())
+    args = _parse_cli()
+
+    msa_file = pathlib.Path(args.msa)
+    prefix = pathlib.Path(args.prefix) if args.prefix else msa_file
+
+    log_file = pathlib.Path(f"{prefix}.labelGen.log")
+    logger.add(log_file, format="{message}")
+    log_file.write_text(get_header() + "\n")
+
+    logger.info(
+        f"LabelGenerator was called at {time.strftime('%d-%b-%Y %H:%M:%S')} as follows:\n"
+    )
+    logger.info(" ".join(sys.argv))
+    logger.info("")
+
+    log_runtime_information("Starting label computation.")
+
+    difficulty = compute_label(
+        msa_file=msa_file,
+        raxmlng=pathlib.Path(args.raxmlng),
+        iqtree=pathlib.Path(args.iqtree),
+        prefix=prefix,
+        model=args.model,
+        n_trees=args.ntrees,
+        seed=args.seed,
+        threads=args.threads,
+        redo=args.redo,
+        log_info=True,
+    )
+
+    script_end = time.perf_counter()
+
+    logger.info("")
+    logger.info(f"Ground Truth Difficulty for {msa_file}: {difficulty:.3f}")
+
+    if args.ntrees < 100:
+        logger.info(
+            "WARNING: The number of inferred ML trees is less than 100. The computed label may be less reliable."
+        )
+
+    logger.info("")
+    total_runtime = script_end - SCRIPT_START
+    hours, remainder = divmod(total_runtime, 3600)
+    minutes, seconds = divmod(remainder, 60)
+
+    if hours > 0:
+        logger.info(
+            f"Total runtime: {int(hours):02d}:{int(minutes):02d}:{seconds:02d} hours ({round(total_runtime)} seconds)."
+        )
+    elif minutes > 0:
+        logger.info(
+            f"Total runtime: {int(minutes):02d}:{int(seconds):02d} minutes ({round(total_runtime)} seconds)."
+        )
+    else:
+        logger.info(f"Total runtime: {seconds:.2f} seconds.")
+
+
+if __name__ == "__main__":
+    main()

labelgenerator/raxmlng.py

@@ -0,0 +1,173 @@
+import math
+import pathlib
+from typing import Optional
+
+from pypythia.raxmlng import RAxMLNG, get_raxmlng_rfdist_results, run_raxmlng_command
+
+
+def _inference_results_exist_and_correct(prefix: pathlib.Path, n_trees: int) -> bool:
+    ml_trees = pathlib.Path(f"{prefix}.raxml.mlTrees")
+    best_tree = pathlib.Path(f"{prefix}.raxml.bestTree")
+
+    if n_trees == 1:
+        ml_trees = best_tree
+
+    logfile = pathlib.Path(f"{prefix}.raxml.log")
+
+    files_exist = ml_trees.exists() and best_tree.exists() and logfile.exists()
+    if not files_exist:
+        # Files don't exist yet, nothing to check.
+        return False
+
+    # Check if the number of ML trees is correct, if there is a mismatch, raise an error
+    n_trees_in_file = sum(1 for _ in ml_trees.open())
+    if n_trees_in_file != n_trees:
+        raise ValueError(
+            f"Number of trees in {ml_trees} ({n_trees_in_file}) does not match the expected number of trees ({n_trees})."
+            f"Please set the `redo` flag to recompute the trees."
+        )
+
+    # Finally, check if the previous RAxML-NG run completed successfully
+    return "Elapsed time:" in logfile.read_text()
+
+
+def infer_ml_trees(
+    msa: pathlib.Path,
+    raxmlng: pathlib.Path,
+    model: str,
+    prefix: pathlib.Path,
+    n_trees: int = 100,
+    seed: int = 0,
+    threads: Optional[int] = None,
+    redo: bool = False,
+) -> None:
+    """
+    Infers ML trees using RAxML-NG.
+
+    If the results for the given prefix and number of trees already exist, the function will return without doing anything.
+    If the number of trees in the existing file does not match the expected number of trees, a ValueError is raised.
+    If you want to redo the computation, set redo=True.
+
+    Args:
+        msa (pathlib.Path): Path to the MSA file.
+        raxmlng (pathlib.Path): Path to the RAxML-NG executable.
+        model (str): Model to use for the RAxML-NG tree inference.
+        prefix (pathlib.Path): Prefix to use for the RAxML-NG output files.
+        n_trees (int): Number of ML trees to infer.
+        seed (int): Seed to use for the RAxML-NG inference.
+        threads (Optional[int]): Number of threads to use for the RAxML-NG inference.
+            Per default, uses the automatic setting of RAxML-NG which is likely to use all cores of your machine.
+        redo (bool): Flag to redo the computation even if the results already exist.
+
+    Returns:
+        None
+
+    Raises:
+        ValueError:
+        - If the number of trees is less than 1.
+        - If the number of trees in a previously computed file does not match the expected number of trees.
+
+    """
+    if n_trees < 1:
+        raise ValueError("Number of trees needs to be at least 1.")
+
+    if not redo and _inference_results_exist_and_correct(prefix, n_trees):
+        return
+
+    n_pars_trees = math.ceil(n_trees / 2)
+    n_rand_trees = n_trees - n_pars_trees
+    rand_string = f",rand{{{n_rand_trees}}}" if n_rand_trees > 0 else ""
+
+    cmd = [
+        raxmlng,
+        "--msa",
+        msa,
+        "--model",
+        model,
+        "--seed",
+        seed,
+        "--prefix",
+        prefix,
+        "--tree",
+        f"pars{{{n_pars_trees}}}{rand_string}",
+    ]
+
+    if threads is not None:
+        cmd.extend(["--threads", threads])
+
+    if redo:
+        cmd.append("--redo")
+
+    run_raxmlng_command(list(map(str, cmd)))
+
+
+def _rfdist_results_exists_and_correct(prefix: pathlib.Path, n_trees: int) -> bool:
+    rfdist = pathlib.Path(f"{prefix}.raxml.rfDistances")
+    logfile = pathlib.Path(f"{prefix}.raxml.log")
+
+    # 1. Check if all RAxML-NG files already exist
+    files_exist = rfdist.exists() and logfile.exists()
+    if not files_exist:
+        return False
+
+    # 2. Run is complete
+    run_complete = "Elapsed time:" in logfile.read_text()
+
+    # 3. Check if the number of pairwise RF-Distance results is correct
+    expected_number_of_pairs = n_trees * (n_trees - 1) // 2
+    n_pairs_in_file = sum(1 for _ in rfdist.open())
+    if n_pairs_in_file != expected_number_of_pairs:
+        raise ValueError(
+            f"Number of pairwise RF-Distances in {rfdist} ({n_pairs_in_file}) does not match "
+            f"the expected number of pairs ({expected_number_of_pairs})."
+            f"Please set the `redo` flag to recompute the distances."
+        )
+
+    return files_exist and run_complete
+
+
+def rf_distance(
+    ml_trees: pathlib.Path,
+    prefix: pathlib.Path,
+    raxmlng: pathlib.Path,
+    n_trees: Optional[int] = None,
+    redo: bool = False,
+) -> tuple[int, float]:
+    """
+    Compute the number of unique topologies and the average relative RF distance for a set of ML trees.
+    If the results already exist, the function will return the results without recomputing them.
+
+    Args:
+        ml_trees (pathlib.Path): Path to the file containing the ML trees.
+        prefix (pathlib.Path): Prefix to use for the RAxML-NG output files.
+        raxmlng (pathlib.Path): Path to the RAxML-NG executable.
+        n_trees (Optional[int]): Number of trees that were inferred.
+            If not provided, the number of trees will be inferred from the file.
+            Explicitly provide the number of trees if you want to check if existing results for the given
+            prefix contain the results for the correct number of trees.
+        redo (bool): Flag to redo the computation if the results already exist.
+
+    Returns:
+        tuple[int, float]: The number of unique topologies and the average relative RF distance.
+
+    """
+    if n_trees is None:
+        n_trees = sum(1 for _ in ml_trees.open())
+
+    if n_trees == 0:
+        raise ValueError("At least 1 tree is required.")
+
+    if n_trees == 1:
+        return 1, 0.0
+
+    if not redo and _rfdist_results_exists_and_correct(prefix, n_trees):
+        num_topos, rel_rfdist = get_raxmlng_rfdist_results(
+            pathlib.Path(f"{prefix}.raxml.log")
+        )
+    else:
+        raxmlng = RAxMLNG(raxmlng)
+        num_topos, rel_rfdist = raxmlng.get_rfdistance_results(
+            ml_trees, prefix, **{"redo": None} if redo else {}
+        )
+
+    return num_topos, rel_rfdist

pythialabelgenerator-1.0.0.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: PythiaLabelGenerator
+Version: 1.0.0
+Summary: Command line tool to generate the ground-truth phylogenetic difficulty of MSAs
+Project-URL: Homepage, https://github.com/tschuelia/PythiaLabelGenerator
+Author-email: Julia Haag <info@juliaschmid.com>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.9
+Requires-Dist: loguru
+Requires-Dist: pythiaphylopredictor>=2.0.0
+Requires-Dist: regex
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Pythia Difficulty Label Generator
+
+![Label Generator GH actions CI](https://github.com/tschuelia/PythiaLabelGenerator/actions/workflows/test-label-generator.yml/badge.svg)
+
+The Pythia Difficulty Label Generator generates the ground-truth phylogenetic difficulty label for an MSA and
+corresponds to the prediction target of our difficulty prediction tool [Pythia](https://github.com/tschuelia/PyPythia).
+
+> [!CAUTION]
+> Computing the ground-truth difficulty for an MSA is very time-consuming and requires a lot of computational resources,
+> especially for MSAs with many sites and/or taxa.
+>
+> Please use our (very accurate) difficulty prediction tool [Pythia](https://github.com/tschuelia/PyPythia) instead
+> whenever possible.
+
+The ground-truth difficulty is computed according to our definition published in [Haag _et
+al._ (2022)](https://doi.org/10.1093/molbev/msac254):
+
+Let $`N_{\text{all}}`$ be the number of inferred ML trees.
+We first compute the average pairwise relative Robinson-Foulds (RF) distance between all trees ($`RF_{\text{all}}`$), as
+well as the number of unique tree topologies among the inferred trees ($`N^*_{\text{all}}`$).
+We filter the inferred trees using likelihood-based statistical tests to obtain the set of $`N_{\text{pl}}`$ _plausible
+trees_.
+We again compute the average pairwise RF distance between the plausible trees ($`RF_{\text{pl}}`$) and the number of
+unique tree topologies among the plausible trees ($`N^*_{\text{pl}}`$).
+
+The difficulty is then computed as follows:
+
+```math
+\text{difficulty} = \frac{1}{5} \cdot \bigg[ RF_{\text{all}} + RF_{\text{pl}}
++ \frac{N^*_{\text{all}}}{N_{\text{all}}} + \frac{N^*_{\text{pl}}}{N_{\text{pl}}}
++ \left( 1 - \frac{N_{\text{pl}}}{N_{\text{all}}} \right) \bigg]
+```
+
+For further details on the reasoning and validation of this difficulty, please refer to the publication linked above.
+
+We infer the ML trees using [RAxML-NG](https://github.com/amkozlov/raxml-ng) and use the statistical significance tests
+as implemented in [IQ-TREE](http://www.iqtree.org).
+Per default, the difficulty is based on $`N_{\text{all}}=100`$ ML trees.
+Note that this number can be adjusted by the user, however, the difficulty will only be an approximation if the number
+of trees is changed.
+
+## Prediction of Phylogenetic Difficulty
+
+As stated above, computing the ground-truth difficulty for an MSA is very time-consuming and requires a lot of
+computational resources, especially for MSAs with many sites and/or taxa.
+Please use our (very accurate) difficulty prediction tool [Pythia](https://github.com/tschuelia/PyPythia) instead
+whenever possible.
+For instance, inferring _a single ML tree_ for an MSA
+comprising [SARS-CoV-2 sequences](https://doi.org/10.1093/molbev/msaa314) (approx. 5k taxa and 28.5k sites) takes about
+12 hours on a large compute cluster. Using Pythia instead, we can predict the same MSA to be very difficult in about 2.5
+minutes on a standard MacBook.
+
+Only use this tool if you need the ground-truth difficulty for a specific MSA and you are sure that Pythia is unable to
+predict the difficulty accurately.
+The only case where we observed Pythia to fail is for language MSAs, so if you are working with DNA, Protein, or
+biological morphological data, Pythia should work just fine 😉
+
+## Installation
+
+#### Requirements
+
+To use this labelling tool, you need to install
+
+- RAxML-NG: See [the RAxML-NG GitHub repository](https://github.com/amkozlov/raxml-ng) for installation instructions.
+  Please make sure that you install a RAxML-NG version < 2.
+- IQ-TREE: See [the IQ-TREE website](http://www.iqtree.org) for installation instructions. Please install IQ-TREE
+  version 2 or higher.
+
+#### Install via conda (recommended)
+
+This package will soon be available on conda-forge :)
+
+#### Install using pip
+
+You can install the package using pip:
+
+```bash
+pip install pythialabelgenerator
+```
+
+## Usage
+
+This label-generator is primarily a command line tool. You can call it using the `label` command, for instance, to
+compute the difficulty for the example MSA provided in the `examples` directory run
+
+```bash
+label -m examples/example.phy
+```
+
+This will infer 100 ML trees using RAxML-NG and run the statistical tests using IQ-TREE. The difficulty will be printed
+to the console.
+The output will look something like this:
+
+```text
+Difficulty LabelGenerator version 1.0.0 released by The Exelixis Lab
+Developed by: Julia Haag
+Latest version: https://github.com/tschuelia/LabelGenerator
+Questions/problems/suggestions? Please open an issue on GitHub.
+
+LabelGenerator was called at 06-Mar-2025 15:15:03 as follows:
+
+label -m examples/example.phy
+
+[00:00:00] Starting label computation.
+[00:00:00] Inferring 100 ML trees using RAxML-NG.
+[00:00:23] Computing RF-Distance between ML trees.
+[00:00:23] > RF-Distance ML trees: 0.78
+[00:00:23] > Unique topologies ML trees: 100
+[00:00:23] Running IQ-TREE statistical tests.
+[00:00:27] Filtering plausible ML trees.
+[00:00:27] > Found 18 plausible trees.
+[00:00:27] Computing RF-Distance between plausible ML trees.
+[00:00:27] > RF-Distance plausible trees: 0.78
+[00:00:27] > Unique topologies plausible trees: 18
+
+Ground Truth Difficulty for examples/example.phy: 0.875
+
+Total runtime: 27.42 seconds.
+```
+
+Depending on your system setup, you might need to pass a RAxML-NG and IQ-TREE binary path to the label generator.
+You can do this using the `-r` and `-i` options, respectively. This is required in case `raxml-ng` and/or `iqtree2` are
+not in your `$PATH`.
+
+Note that this `examply.phy` MSA is not the same exemplary MSA as we provide in the PyPythia repository, so please don't compare this ground-truth lable to the exemplary prediction in PyPythia 😉
+
+For a full list of command line options, run `label -h`:
+
+```text
+Difficulty LabelGenerator version 1.0.0 released by The Exelixis Lab
+Developed by: Julia Haag
+Latest version: https://github.com/tschuelia/LabelGenerator
+Questions/problems/suggestions? Please open an issue on GitHub.
+
+usage: label [-h] -m MSA -r RAXMLNG -i IQTREE [-t THREADS] [-s SEED] [-p PREFIX] [--model MODEL] [--ntrees NTREES] [--redo] [-V]
+
+Generate the ground truth difficulty for the given MSA.
+
+options:
+  -h, --help            show this help message and exit
+  -m MSA, --msa MSA     Multiple Sequence Alignment to compute the ground truth difficulty for. Must be in either phylip or fasta format.
+  -r RAXMLNG, --raxmlng RAXMLNG
+                        Path to the binary of RAxML-NG. For install instructions see https://github.com/amkozlov/raxml-ng.(default: 'raxml-
+                        ng' if in $PATH, otherwise this option is mandatory).
+  -i IQTREE, --iqtree IQTREE
+                        Path to the binary of IQ-TREE2. For install instructions see http://www.iqtree.org.(default: 'iqtree2' if in $PATH,
+                        otherwise this option is mandatory).
+  -t THREADS, --threads THREADS
+                        Number of threads to use for the RAxML-NG tree inference and IQ-TREE statistical tests (default: autoconfig in RAxML-NG and IQ-TREE).
+  -s SEED, --seed SEED  Seed for the RAxML-NG tree inference (default: 0).
+  -p PREFIX, --prefix PREFIX
+                        Prefix of the RAxML-NG and IQ-TREE log and result files (default: MSA file name).
+  --model MODEL         Model to use for the RAxML-NG tree inference (default: 'GTR+G' for DNA, 'LG+G' for AA, and 'MULTIx_GTR' for
+                        morphological data where x is the maximum state value in the MSA).
+  --ntrees NTREES       Number of ML trees to infer (default: 100)
+  --redo                Redo all computations, even if the results already exist.
+  -V, --version         Print the version number and exit.
+```
+
+Please note that inferring 100 ML trees for a large MSA can take a long time. You can adjust the number of trees to
+infer using the `--ntrees` option. However, using fewer than 100 trees will likely result in slight different
+difficulties, as the difficulty is based on the average pairwise RF distance between the inferred trees.
+
+### Result Files
+
+Running this labelling tool will result in the following files:
+
+- `{prefix}.raxml.*`: RAxML-NG log and result files.
+- `{prefix}.iqtree.*`: IQ-TREE log and result files.
+- `{prefix}.labelGen.log`: Log file containing the output of the label generator. This is the same output as printed to
+  the terminal.
+
+You can set the prefix of these files using the `-p` option. By default, the prefix is the name of the MSA file.
+Note that RAxML-NG and IQ-TREE refuse to overwrite existing files. If you want to redo the computations, you can use the
+`--redo` option.
+Please also specify the `--redo` option if you want to change the number of trees to infer using the `--ntrees` option
+for the same prefix. Otherwise,
+the label generator will exit with an error message.
+
+### Input Data
+
+You can provide the MSA in either phylip or fasta format. We currently support DNA, AA, and categorical data.
+The label generator will automatically determine the data type and select an appropriate model for tree inference and
+statistical tests.
+For DNA data, we use the `GTR+G` model, for AA data the `LG+G` model, and for categorical data the `MULTIx_GTR` model, where `x`
+is the maximum state value in the MSA.
+We used these models to generate the ground-truth labels for training Pythia. If you want to specify a different model,
+you can do so using the `--model` option.
+
+
+## Citation
+We will soon publish a pre-print on bioRxiv with updates on our Pythia difficulty prediction tool that will also include a
+brief description of this new labelling tool. Please cite this pre-print if you use this tool in your research.
+
+The link to the paper will be added soon 🙂

pythialabelgenerator-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+labelgenerator/__init__.py,sha256=kwlgs69Sq0mro8LPwa_xG4g-d_Z6hngg04IHgvkC8HU,374
+labelgenerator/iqtree.py,sha256=tyEFM54HzvkgUrPTAPoudEDxBrDw1dD2vkym6CPDBss,4444
+labelgenerator/iqtree_parser.py,sha256=bZuVMRzlBsaEi0rIAEWuILc_bkahBkEW2r7i4mKtPcw,6485
+labelgenerator/label.py,sha256=6L7s_xDYhtX7kNvx9UVf5e6KYSuZBBd6ohJHEUSODZ0,8699
+labelgenerator/logger.py,sha256=XbYSJyL-WsjjaObI6hS4zM8E_GzqlVRvBbXtcFJcOsE,861
+labelgenerator/main.py,sha256=nXmxEDL_i_IAiRmS0c9Z96F4IORAlHpjypQtzGwGW-M,4812
+labelgenerator/raxmlng.py,sha256=HwK3kPtBeUlsIkXI10T792cJ0YRajdeJ42VcTOMK8lQ,6075
+pythialabelgenerator-1.0.0.dist-info/METADATA,sha256=ZP94OQJ_j_SEsOwoLRxN-BVfQqyNVDrfj89MWpsH4vI,10438
+pythialabelgenerator-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pythialabelgenerator-1.0.0.dist-info/entry_points.txt,sha256=sI1fBhWG20vN_beYNPpLY7Ex6tXIo0ybBhgj7xTuslM,51
+pythialabelgenerator-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pythialabelgenerator-1.0.0.dist-info/RECORD,,

pythialabelgenerator-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pythialabelgenerator-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+label = labelgenerator.main:main