XspecT 0.2.7__py3-none-any.whl → 0.4.1__py3-none-any.whl

xspect/train.py

@@ -2,266 +2,282 @@
 This module contains the main functions for training the models.
 """
 
-import os
 import shutil
 from pathlib import Path
-import sys
-from time import localtime, perf_counter, asctime, sleep
+from tempfile import TemporaryDirectory
 from loguru import logger
-from xspect.definitions import get_xspect_model_path, get_xspect_tmp_path
-from xspect.file_io import concatenate_meta
+from xspect.definitions import get_xspect_model_path
+from xspect.file_io import (
+    concatenate_species_fasta_files,
+    concatenate_metagenome,
+    extract_zip,
+    get_ncbi_dataset_accession_paths,
+)
+from xspect.models.probabilistic_filter_model import ProbabilisticFilterModel
 from xspect.models.probabilistic_filter_svm_model import ProbabilisticFilterSVMModel
 from xspect.models.probabilistic_single_filter_model import (
     ProbabilisticSingleFilterModel,
 )
-from xspect.train_filter.ncbi_api import (
-    ncbi_assembly_metadata,
-    ncbi_taxon_metadata,
-    ncbi_children_tree,
-    download_assemblies,
-)
-from xspect.train_filter import (
-    create_svm,
-    extract_and_concatenate,
-)
-
-
-def check_user_input(user_input: str):
-    """The given input of the user will be checked. The input has to be a genus in NCBI.
-
-    :return: The genus name.
+from xspect.ncbi import AssemblySource, NCBIHandler
+
+
+def train_from_directory(
+    display_name: str,
+    dir_path: Path,
+    meta: bool = False,
+    training_accessions: dict[str, list[str]] = None,
+    svm_accessions: list[str] = None,
+    svm_step: int = 1,
+    translation_dict: dict[str, str] = None,
+    author: str = None,
+    author_email: str = None,
+):
     """
-    taxon_metadata = ncbi_taxon_metadata.NCBITaxonMetadata([user_input])
-    all_metadata = taxon_metadata.get_metadata()
-    for metadata in all_metadata.values():
-        sci_name = metadata["sci_name"]
-        tax_id = metadata["tax_id"]
-        rank = metadata["rank"]
-        lineage = metadata["lineage"]
-        bacteria_id = 2
-        if user_input not in (sci_name, tax_id):
-            print(
-                f"{get_current_time()}| The given genus: {user_input} was found as"
-                f" genus: {sci_name} ID: {tax_id}"
-            )
-            print(f"{get_current_time()}| Using {sci_name} as genus name.")
-        if rank == "GENUS":
-            if bacteria_id not in lineage:
-                print(f"{get_current_time()}| The given genus is not a bacteria.")
-                print(f"{get_current_time()}| Do you want to continue: [y/n]")
-                choice = input("-> ").lower()
-                if choice == "y":
-                    return str(sci_name)
-                print(f"{get_current_time()}| Exiting...")
-                sys.exit()
-            return str(sci_name)
-        print(f"{get_current_time()}| {user_input} is rank {rank} and not genus.")
-        sys.exit()
-
-
-def set_logger(dir_name: str):
-    """Sets the logger parameters.
-
-    :param dir_name: Name of the folder where the log should be saved.
+    Train a model from a directory containing training data.
+
+    This function trains a probabilistic filter model using the data in the specified directory.
+    The training data should be organized in the following way:
+    - dir_path
+        - cobs
+            - <species_name_1>
+                - <fasta_file_1>
+                - <fasta_file_2>
+            - <species_name_2>
+                - <fasta_file_1>
+                - <fasta_file_2>
+        - svm (optional)
+            - <species_name_1>
+                - <svm_file_1>
+                - <svm_file_2>
+            - <species_name_2>
+                - <svm_file_1>
+                - <svm_file_2>
+    If no SVM directory is found, the model will be trained without SVM.
+    The training data should be in FASTA format. The model is saved to the xspect_data directory.
+
+    Args:
+        display_name (str): Name of the model to be trained.
+        dir_path (Path): Path to the directory containing training data.
+        meta (bool, optional): Whether to train a metagenome model. Defaults to False.
+        training_accessions (list[str], optional): List of training accessions. Defaults to None.
+        svm_accessions (list[str], optional): List of SVM accession identifiers. Defaults to None.
+        svm_step (int, optional): Step size for SVM training. Defaults to 1.
+        translation_dict (dict[str, str], optional): Dictionary for display names. Defaults to None.
+        author (str, optional): Author of the model. Defaults to None.
+        author_email (str, optional): Author's email. Defaults to None.
+
+    Raises:
+        TypeError: If `display_name` is not a string.
+        TypeError: If `dir_path` is not a Path object to a valid directory.
+        ValueError: If the "cobs" directory is not found in `dir_path`.
+        ValueError: If no folders are found in the "cobs" directory.
+        ValueError: If the number of SVM folders does not match the number of COBS folders.
+        ValueError: If the names of COBS folders and SVM folders do not match.
+        ValueError: If no FASTA files are found in a COBS folder.
+
+    Notes:
+        - If the "svm" directory is not found, the model will be trained without SVM.
+        - Temporary directories are used for intermediate processing.
     """
-    genus = dir_name.split("_")[0]
-
-    # Starting logger.
-    logger.remove()
-    logger.add(sys.stderr, format="{time:HH:mm:ss} | {level} | {message}", level="INFO")
-    log_path = get_xspect_tmp_path() / dir_name / (genus + ".log")
-    logger.add(log_path, format="{time:HH:mm:ss} | {level} | {message}", level="DEBUG")
-
 
-def create_translation_dict(dir_name: str) -> dict[str, str]:
-    """Create a translation dictionary to translate the taxon ID to its scientific name.
+    if not isinstance(display_name, str):
+        raise TypeError("display_name must be a string")
 
-    :param dir_name: Directory name for current genus.
-    :return: The created translation dictionary.
-    """
-    path = get_xspect_tmp_path() / dir_name / "concatenate"
-    files = os.listdir(path)
-    translation_dict = {}
-    for file in files:
-        file_split = file.split(".")[0].split("_")
-        tax_id = file_split[0]
-        final_file_name = tax_id + ".fasta"
-        name = file_split[1]
-        translation_dict[final_file_name] = name
+    if not isinstance(dir_path, Path) and dir_path.exists() and dir_path.is_dir():
+        raise TypeError("dir must be Path object to a valid directory")
+
+    cobs_training_path = dir_path / "cobs"
+    if not cobs_training_path.exists():
+        raise ValueError("cobs directory not found")
+
+    cobs_folders = [f for f in cobs_training_path.iterdir() if f.is_dir()]
+    if len(cobs_folders) == 0:
+        raise ValueError("no folders found in cobs directory")
+
+    svm_path = dir_path / "svm"
+    if svm_path.exists():
+        svm_folders = [f for f in svm_path.iterdir() if f.is_dir()]
+        if len(svm_folders) != len(cobs_folders):
+            raise ValueError(
+                "number of svm folders does not match number of cobs folders"
+            )
 
-    return translation_dict
+        for cobs_folder, svm_folder in zip(cobs_folders, svm_folders):
+            if cobs_folder.name != svm_folder.name:
+                raise ValueError("cobs folder and svm folder names do not match")
+    else:
+        print("SVM directory not found. Model will be trained without SVM.")
+
+    with TemporaryDirectory() as tmp_dir:
+        tmp_dir = Path(tmp_dir)
+        species_dir = tmp_dir / "species"
+        species_dir.mkdir(parents=True, exist_ok=True)
+
+        # concatenate files in cobs_training_data for each species
+        concatenate_species_fasta_files(cobs_folders, species_dir)
+
+        if svm_path.exists():
+            species_model = ProbabilisticFilterSVMModel(
+                k=21,
+                model_display_name=display_name,
+                author=author,
+                author_email=author_email,
+                model_type="Species",
+                base_path=get_xspect_model_path(),
+                kernel="rbf",
+                c=1.0,
+            )
+            species_model.fit(
+                species_dir,
+                svm_path,
+                display_names=translation_dict,
+                svm_step=svm_step,
+                training_accessions=training_accessions,
+                svm_accessions=svm_accessions,
+            )
+        else:
+            species_model = ProbabilisticFilterModel(
+                k=21,
+                model_display_name=display_name,
+                author=author,
+                author_email=author_email,
+                model_type="Species",
+                base_path=get_xspect_model_path(),
+            )
+            species_model.fit(
+                species_dir,
+                display_names=translation_dict,
+                training_accessions=training_accessions,
+            )
 
+        species_model.save()
 
-def change_bf_assembly_file_names(dir_name: str):
-    """Change all concatenated assembly names to only the taxon ID.
+        if meta:
+            meta_fasta = tmp_dir / f"{display_name}.fasta"
+            concatenate_metagenome(species_dir, meta_fasta)
 
-    :param dir_name: Directory name for current genus.
+            genus_model = ProbabilisticSingleFilterModel(
+                k=21,
+                model_display_name=display_name,
+                author=author,
+                author_email=author_email,
+                model_type="Genus",
+                base_path=get_xspect_model_path(),
+            )
+            genus_model.fit(
+                meta_fasta,
+                display_name,
+                training_accessions=(
+                    sum(training_accessions.values(), [])
+                    if training_accessions
+                    else None
+                ),
+            )
+            genus_model.save()
+
+
+def train_from_ncbi(
+    genus: str,
+    svm_step: int = 1,
+    author: str = None,
+    author_email: str = None,
+):
+    """Train a model using NCBI assembly data for a given genus.
+
+    This function trains a probabilistic filter model using the assembly data from NCBI.
+    The training data is downloaded and processed, and the model is saved to the
+    xspect_data directory.
+
+    Args:
+        genus (str): Genus name for which the model will be trained.
+        svm_step (int, optional): Step size for SVM training. Defaults to 1.
+        author (str, optional): Author of the model. Defaults to None.
+        author_email (str, optional): Author's email. Defaults to None.
+
+    Raises:
+        TypeError: If `genus` is not a string.
+        ValueError: If no species with accessions are found.
+
+    Notes:
+        - The function uses NCBI API to fetch assembly metadata.
+        - Temporary directories are used for intermediate processing.
     """
-    path = get_xspect_tmp_path() / dir_name / "concatenate"
-    files = os.listdir(path)
-    for file in files:
-        file_split = file.split(".")[0].split("_")
-        tax_id = file_split[0]
-        new_file_name = f"{tax_id}.fasta"
-        os.rename((path / file), (path / new_file_name))
-
-
-def get_current_time():
-    """Returns the current time in the form hh:mm:ss."""
-    return asctime(localtime()).split()[3]
-
-
-def train_ncbi(genus: str, svm_step: int = 1):
-    """Train genus and species models with NCBI assemblies from the given genus."""
-
     if not isinstance(genus, str):
         raise TypeError("genus must be a string")
 
-    # Check user input.
-    genus = check_user_input(user_input=genus)
-
-    # The directory name is defined in the following format: 'genus'_DD_MM_YYYY_hh-mm-ss
-    curr_time = localtime()
-    dir_name = f"{genus}_{curr_time[2]}_{curr_time[1]}_{curr_time[0]}_{curr_time[3]}-{curr_time[4]}-{curr_time[5]}"
-
-    # Set the logger.
-    set_logger(dir_name)
-
-    # Time for the whole program.
-    start = perf_counter()
-
-    # Search for every defined species of the genus.
-    logger.info("Getting all species of the genus")
-    children_ids = ncbi_children_tree.NCBIChildrenTree(genus).children_ids()
-    species_dict = ncbi_taxon_metadata.NCBITaxonMetadata(children_ids).get_metadata()
-
-    # Look for up to 8 assembly accessions per species.
-    logger.info("Getting assembly metadata")
-    all_metadata = ncbi_assembly_metadata.NCBIAssemblyMetadata(
-        all_metadata=species_dict, count=8, contig_n50=10000
-    )
-    all_metadata = all_metadata.get_all_metadata()
-
-    # Ensure that the genus has at least one species with accessions.
-    if not all_metadata:
-        raise ValueError("No species with accessions found")
-
-    # Download the chosen assemblies.
-    # One file for each species with it's downloaded assemblies in zip format.
-
-    # Iterate through all species.
-    logger.info("Downloading assemblies for bloomfilter training")
-    for metadata in all_metadata.values():
-        # Only try to download when the species has accessions.
-        if len(metadata["accessions"]) >= 1:
-            sleep(5)
-            species_name = metadata["sci_name"]
-            tax_id = metadata["tax_id"]
-            logger.info("Downloading {id}_{name}", id=tax_id, name=species_name)
-            file_name = f"{tax_id}_{species_name}.zip"
-
-            # Selecting the first 4 assemblies for training the filters.
-            accessions = metadata["accessions"][:4]
-
-            download_assemblies.download_assemblies(
-                accessions=accessions,
-                dir_name=dir_name,
-                target_folder="zip_files",
-                zip_file_name=file_name,
-            )
-    logger.info("Concatenating and extracting")
-
-    # Concatenate all assemblies of each species.
-    extract_and_concatenate.bf(dir_name=dir_name, delete=True)
-    concatenate_meta(get_xspect_tmp_path() / dir_name, genus)
+    ncbi_handler = NCBIHandler()
+    genus_tax_id = ncbi_handler.get_genus_taxon_id(genus)
+    species_ids = ncbi_handler.get_species(genus_tax_id)
+    species_names = ncbi_handler.get_taxon_names(species_ids)
+
+    filtered_species_ids = [
+        tax_id
+        for tax_id in species_ids
+        if "candidatus" not in species_names[tax_id].lower()
+        and " sp." not in species_names[tax_id].lower()
+    ]
+    filtered_species_names = {
+        str(tax_id): species_names[tax_id] for tax_id in filtered_species_ids
+    }
 
-    # Download assemblies for svm creation.
-    logger.info("Downloading assemblies for support-vector-machine training")
     accessions = {}
-    for metadata in all_metadata.values():
-        # Only add taxon with accessions.
-        if len(metadata["accessions"]) >= 1:
-            accessions[metadata["tax_id"]] = metadata["accessions"]
-
-    # Downloading assemblies.
-    create_svm.get_svm_assemblies(all_accessions=accessions, dir_name=dir_name)
-
-    logger.info("Extracting SVM assemblies")
-
-    # Extracting assemblies.
-    extract_and_concatenate.svm(
-        species_accessions=accessions, dir_name=dir_name, delete=True
-    )
-
-    # Make dictionary for translating taxon ID to scientific name.
-    translation_dict = create_translation_dict(dir_name)
-    change_bf_assembly_file_names(dir_name)
-
-    species_files_path = get_xspect_tmp_path() / dir_name / "concatenate"
-    species_result_path = get_xspect_model_path() / genus
-
-    # Train Bloomfilter for complete genus.
-    logger.info("Training metagenome model")
-    mg_files_path = get_xspect_tmp_path() / dir_name
-
-    genus_model = ProbabilisticSingleFilterModel(
-        k=21,
-        model_display_name=genus,
-        author="Test",
-        author_email="test@example.com",
-        model_type="Genus",
-        base_path=Path(species_result_path).parent,
-    )
-    genus_model.fit(mg_files_path / f"{genus}.fasta", genus)
-    genus_model.save()
-
-    logger.info("Training species model")
-
-    species_model = ProbabilisticFilterSVMModel(
-        k=21,
-        model_display_name=genus,
-        author="Test",
-        author_email="test@example.com",
-        model_type="Species",
-        base_path=Path(species_result_path).parent,
-        kernel="rbf",
-        c=1.0,
-    )
-    svm_dir = get_xspect_tmp_path() / dir_name / "training_data"
-    species_model.fit(
-        Path(species_files_path),
-        svm_dir,
-        display_names=translation_dict,
-        svm_step=svm_step,
-    )
-    species_model.save()
-
-    # Cleanup files.
-    shutil.rmtree(get_xspect_tmp_path() / dir_name)
-
-    end = perf_counter()
-
-    logger.info("Program runtime: {time} m", time=(round((end - start) / 60, 2)))
-    logger.info("XspecT-trainer is finished.")
-
-
-def train_from_directory(display_name: str, dir_path: Path, meta: bool = False):
-    """Train the gene family and gene filter.
-
-    :param display_name: Name of the model.
-    :param dir: Input directory.
-    """
-
-    if not isinstance(display_name, str):
-        raise TypeError("display_name must be a string")
-
-    if not isinstance(dir_path, Path) and dir_path.exists() and dir_path.is_dir():
-        raise ValueError("dir must be Path object to a valid directory")
-
-    # check if the directory contains the necessary files
-    # copy to temp path
-    # check if svm training data exists
-    # train model, with svm data if it exists
-    # add display names
-    # train metagenome model
-    # clean up temp path
+    for tax_id in filtered_species_ids:
+        taxon_accessions = ncbi_handler.get_highest_quality_accessions(
+            tax_id, AssemblySource.REFSEQ, 8
+        )
+        if not taxon_accessions:
+            logger.warning(f"No assemblies found for tax_id {tax_id}. Skipping.")
+            filtered_species_names.pop(str(tax_id), None)
+            continue
+        accessions[tax_id] = taxon_accessions
+
+    if not accessions:
+        raise ValueError(
+            "No species with accessions found. Please check the genus name."
+        )
+
+    with TemporaryDirectory() as tmp_dir:
+        tmp_dir = Path(tmp_dir)
+        cobs_dir = tmp_dir / "cobs"
+        svm_dir = tmp_dir / "svm"
+        cobs_dir.mkdir(parents=True, exist_ok=True)
+        svm_dir.mkdir(parents=True, exist_ok=True)
+
+        ncbi_handler.download_assemblies(
+            accessions=sum(accessions.values(), []), output_dir=tmp_dir
+        )
+        extract_zip(tmp_dir, tmp_dir)
+        accession_paths = get_ncbi_dataset_accession_paths(tmp_dir / "ncbi_dataset")
+
+        # select accessions
+        cobs_accessions = {}
+        svm_accessions = {}
+        for tax_id, accession_list in accessions.items():
+            cobs_accessions[tax_id] = accession_list[:4]
+            svm_accessions[tax_id] = accession_list[-4:]
+
+        # move files
+        for tax_id, accession_list in cobs_accessions.items():
+            tax_id_dir = cobs_dir / str(tax_id)
+            tax_id_dir.mkdir(parents=True, exist_ok=True)
+            for accession in accession_list:
+                accession_path = accession_paths[accession]
+                shutil.copy(accession_path, tax_id_dir / f"{accession}.fasta")
+        for tax_id, accession_list in svm_accessions.items():
+            tax_id_dir = svm_dir / str(tax_id)
+            tax_id_dir.mkdir(parents=True, exist_ok=True)
+            for accession in accession_list:
+                accession_path = accession_paths[accession]
+                shutil.copy(accession_path, tax_id_dir / f"{accession}.fasta")
+
+        train_from_directory(
+            display_name=genus,
+            dir_path=tmp_dir,
+            meta=True,
+            training_accessions=cobs_accessions,
+            svm_accessions=svm_accessions,
+            svm_step=svm_step,
+            translation_dict=filtered_species_names,
+            author=author,
+            author_email=author_email,
+        )

{xspect-0.2.7.dist-info → xspect-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: XspecT
-Version: 0.2.7
+Version: 0.4.1
 Summary: Tool to monitor and characterize pathogens using Bloom filters.
 License: MIT License
         
@@ -54,34 +54,28 @@ Requires-Dist: sphinx-autobuild; extra == "docs"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: httpx; extra == "test"
+Dynamic: license-file
 
 # XspecT - Acinetobacter Species Assignment Tool
+<!-- start intro -->
 ![Test](https://github.com/bionf/xspect2/actions/workflows/test.yml/badge.svg)
 [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
-<img src="/docs/img/logo.png" height="50%" width="50%">
-
-<!-- start intro -->
-XspecT is a Python-based tool to taxonomically classify sequence-reads (or assembled genomes) on the species and/or MLST level using [Bloom Filters] and a [Support Vector Machine].
-<br/><br/>
-
-XspecT utilizes the uniqueness of kmers and compares extracted kmers from the input-data to a reference database. Bloom Filter ensure a fast lookup in this process. For a final prediction the results are classified using a Support Vector Machine. 
-<br/>
+XspecT is a Python-based tool to taxonomically classify sequence-reads (or assembled genomes) on the species and/or MLST level using [kmer indices] and a [Support Vector Machine].
 
-Local extensions of the reference database are supported.
-<br/>
+XspecT utilizes the uniqueness of kmers and compares extracted kmers from the input-data to a reference database. Bloom Filter ensure a fast lookup in this process. For a final prediction, the results are classified using a Support Vector Machine.
 
-The tool is available as a web-based application and a smaller command line interface.
+The tool is available as a web-based application and as a command line interface.
 
-[Bloom Filters]: https://en.wikipedia.org/wiki/Bloom_filter
+[kmer indices]: https://arxiv.org/abs/1905.09624
 [Support Vector Machine]: https://en.wikipedia.org/wiki/Support-vector_machine
-[blaOxa-genes]: https://en.wikipedia.org/wiki/Beta-lactamase#OXA_beta-lactamases_(class_D)
 <!-- end intro -->
 
 <!-- start quickstart -->
 ## Installation
-To install Xspect, please download the lastest 64 bit Python version and install the package using pip:
+To install XspecT, please download the lastest 64 bit Python version and install the package using pip:
 ```
 pip install xspect
 ```
@@ -91,23 +85,23 @@ Please note that Windows and Alpine Linux is currently not supported.
 ### Get the models
 To download basic pre-trained models, you can use the built-in command:
 ```
-xspect download-models
+xspect models download
 ```
 Additional species models can be trained using:
 ```
-xspect train-species you-ncbi-genus-name
+xspect models train ncbi
 ```
 
 ### How to run the web app
 To run the web app, install and run [XspecT Web](https://github.com/aromberg/xspect-web). Additionally, run XspecT in API mode:
 ```
-xspect api
+xspect web
 ```
 
 ### How to use the XspecT command line interface
-Run xspect with the configuration you want to run it with as arguments.
+Run XspecT with the configuration you want to run it with as arguments.
 ```
-xspect classify-species your-genus path/to/your/input-set
+xspect classify species
 ```
 For further instructions on how to use the command line interface, please refer to the [documentation] or execute:
 ```

xspect-0.4.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+xspect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xspect/definitions.py,sha256=fVn_li_s2hriOSGJ69o_H8H-vkw1znvkryhBj7WMnF4,1219
+xspect/download_models.py,sha256=y1wFJZa1xOJfvUP78zKkRs46O-WqKBL90vmo5AYUio0,853
+xspect/fastapi.py,sha256=DOef3MqWPdBmdYBo8Z9SPmWrbJHOsQxQe3GrC4f__Rc,3165
+xspect/file_io.py,sha256=YmfoKEQdHHEi8dO2G5Kt4tSNi5LuWW0VZ74pyYRHiTo,5937
+xspect/main.py,sha256=twIn48wPDFOEejQroYN8JM8a40naEqT_BUgrMAwwYck,12154
+xspect/model_management.py,sha256=UbmAr3YOZ4oy_9iVvApCLstYHGkcmneHEC_yftRIqCI,3010
+xspect/ncbi.py,sha256=sSJO3g8n89Qw6UJjAy13bpjOcIGSquTKNKVHNUMbDeM,10072
+xspect/train.py,sha256=7I7-inWGJe_VDzII9dLZ8U-8SUCZDIrhb-eNOZEyfss,10703
+xspect/mlst_feature/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xspect/mlst_feature/mlst_helper.py,sha256=3zhhEomkk-qiObbQ82TM_YHuyVCJ7_XgyzsYM_4TS0E,5760
+xspect/mlst_feature/pub_mlst_handler.py,sha256=oss3CkJNt6041p3qnMdOfoX8ZgUfpB93CUim-Yakc9A,5031
+xspect/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xspect/models/probabilistic_filter_mlst_model.py,sha256=JMc0yBJPo7J9b-GpvhDmzhwWPIKOwatAq0edDgM72PE,11735
+xspect/models/probabilistic_filter_model.py,sha256=l8mhcRgHPso7qIgI56buCnE3ZleO3gPWOZEpgrycOBA,10029
+xspect/models/probabilistic_filter_svm_model.py,sha256=xXimcv3iWnG1JiFyrk6UqkP9hFIxWGDdb__fRdQYwro,6245
+xspect/models/probabilistic_single_filter_model.py,sha256=yxWnCt4IP-3ZRLP4pRA3f2VTHc0_4g17PDCyOFayDDg,4090
+xspect/models/result.py,sha256=ELWiDlQPlxNG7ceLpth60Z_Hb1ZdopDJ3vgHBPgSRm8,3989
+xspect-0.4.1.dist-info/licenses/LICENSE,sha256=bhBGDKIRUVwYIHGOGO5hshzuVHyqFJajvSOA3XXOLKI,1094
+xspect-0.4.1.dist-info/METADATA,sha256=BLTAPyNGEjUxxFUqGvdgyFy8T0p9b8w8IOBbUBvnv28,4477
+xspect-0.4.1.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+xspect-0.4.1.dist-info/entry_points.txt,sha256=L7qliX3pIuwupQxpuOSsrBJCSHYPOPNEzH8KZKQGGUw,43
+xspect-0.4.1.dist-info/top_level.txt,sha256=hdoa4cnBv6OVzpyhMmyxpJxEydH5n2lDciy8urc1paE,7
+xspect-0.4.1.dist-info/RECORD,,

{xspect-0.2.7.dist-info → xspect-0.4.1.dist-info}/WHEEL

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