sai-pg 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

sai/stats/features.py

@@ -1,302 +0,0 @@
-# Copyright 2025 Xin Huang
-#
-# GNU General Public License v3.0
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, please see
-#
-#    https://www.gnu.org/licenses/gpl-3.0.en.html
-
-
-import numpy as np
-
-
-def calc_freq(gts: np.ndarray, ploidy: int = 1) -> np.ndarray:
-    """
-    Calculates allele frequencies, supporting both phased and unphased data.
-
-    Parameters
-    ----------
-    gts : np.ndarray
-        A 2D numpy array where each row represents a locus and each column represents an individual.
-    ploidy : int, optional
-        Ploidy level of the organism. If ploidy=1, the function assumes phased data and calculates
-        frequency by taking the mean across individuals. For unphased data, it calculates frequency by
-        dividing the sum across individuals by the total number of alleles. Default is 1.
-
-    Returns
-    -------
-    np.ndarray
-        An array of allele frequencies for each locus.
-    """
-    return np.sum(gts, axis=1) / (gts.shape[1] * ploidy)
-
-
-def compute_matching_loci(
-    ref_gts: np.ndarray,
-    tgt_gts: np.ndarray,
-    src_gts_list: list[np.ndarray],
-    w: float,
-    y_list: list[tuple[str, float]],
-    ploidy: int,
-    anc_allele_available: bool,
-) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """
-    Computes loci that meet specified allele frequency conditions across reference, target, and source genotypes.
-
-    Parameters
-    ----------
-    ref_gts : np.ndarray
-        A 2D numpy array where each row represents a locus and each column represents an individual in the reference group.
-    tgt_gts : np.ndarray
-        A 2D numpy array where each row represents a locus and each column represents an individual in the target group.
-    src_gts_list : list of np.ndarray
-        A list of 2D numpy arrays for each source population, where each row represents a locus and each column
-        represents an individual in that source population.
-    w : float
-        Threshold for the allele frequency in `ref_gts`. Only loci with frequencies less than `w` are counted.
-        Must be within the range [0, 1].
-    y_list : list of tuple[str, float]
-        List of allele frequency conditions for each source population in `src_gts_list`.
-        Each entry is a tuple (operator, threshold), where:
-        - `operator` can be '=', '<', '>', '<=', '>='
-        - `threshold` is a float within [0, 1]
-        The length must match `src_gts_list`.
-    ploidy : int
-        The ploidy level of the organism.
-    anc_allele_available : bool
-        If True, checks only for matches with `y` (assuming `1` represents the derived allele).
-        If False, checks both matches with `y` and `1 - y`, taking the dominant allele in the source as the reference.
-
-    Returns
-    -------
-    tuple[np.ndarray, np.ndarray, np.ndarray]
-        - Adjusted reference allele frequencies (`ref_freq`).
-        - Adjusted target allele frequencies (`tgt_freq`).
-        - Boolean array indicating loci that meet the specified frequency conditions (`condition`).
-    """
-    # Validate input parameters
-    if not (0 <= w <= 1):
-        raise ValueError("Parameters w must be within the range [0, 1].")
-
-    for op, y in y_list:
-        if not (0 <= y <= 1):
-            raise ValueError(f"Invalid value in y_list: {y}. within the range [0, 1].")
-        if op not in ("=", "<", ">", "<=", ">="):
-            raise ValueError(
-                f"Invalid operator in y_list: {op}. Must be '=', '<', '>', '<=', or '>='."
-            )
-
-    if len(src_gts_list) != len(y_list):
-        raise ValueError("The length of src_gts_list and y_list must match.")
-
-    # Compute allele frequencies
-    ref_freq = calc_freq(ref_gts, ploidy)
-    tgt_freq = calc_freq(tgt_gts, ploidy)
-    src_freq_list = [calc_freq(src_gts, ploidy) for src_gts in src_gts_list]
-
-    # Check match for each `y`
-    op_funcs = {
-        "=": lambda src_freq, y: src_freq == y,
-        "<": lambda src_freq, y: src_freq < y,
-        ">": lambda src_freq, y: src_freq > y,
-        "<=": lambda src_freq, y: src_freq <= y,
-        ">=": lambda src_freq, y: src_freq >= y,
-    }
-
-    match_conditions = [
-        op_funcs[op](src_freq, y) for src_freq, (op, y) in zip(src_freq_list, y_list)
-    ]
-    all_match_y = np.all(match_conditions, axis=0)
-
-    if not anc_allele_available:
-        # Check if all source populations match `1 - y`
-        match_conditions_1_minus_y = [
-            op_funcs[op](src_freq, 1 - y)
-            for src_freq, (op, y) in zip(src_freq_list, y_list)
-        ]
-        all_match_1_minus_y = np.all(match_conditions_1_minus_y, axis=0)
-        all_match = all_match_y | all_match_1_minus_y
-
-        # Identify loci where all sources match `1 - y` for frequency inversion
-        inverted = all_match_1_minus_y
-
-        # Invert frequencies for these loci
-        ref_freq[inverted] = 1 - ref_freq[inverted]
-        tgt_freq[inverted] = 1 - tgt_freq[inverted]
-    else:
-        all_match = all_match_y
-
-    # Final condition: locus must satisfy source matching and have `ref_freq < w`
-    condition = all_match & (ref_freq < w)
-
-    return ref_freq, tgt_freq, condition
-
-
-def calc_u(
-    ref_gts: np.ndarray,
-    tgt_gts: np.ndarray,
-    src_gts_list: list[np.ndarray],
-    pos: np.ndarray,
-    w: float,
-    x: float,
-    y_list: list[float],
-    ploidy: int = 1,
-    anc_allele_available: bool = False,
-) -> tuple[int, np.ndarray]:
-    """
-    Calculates the count of genetic loci that meet specified allele frequency conditions
-    across reference, target, and multiple source genotypes, with adjustments based on src_freq consistency.
-
-    Parameters
-    ----------
-    ref_gts : np.ndarray
-        A 2D numpy array where each row represents a locus and each column represents an individual in the reference group.
-    tgt_gts : np.ndarray
-        A 2D numpy array where each row represents a locus and each column represents an individual in the target group.
-    src_gts_list : list of np.ndarray
-        A list of 2D numpy arrays for each source population, where each row represents a locus and each column
-        represents an individual in that source population.
-    pos : np.ndarray
-        A 1D numpy array where each element represents the genomic position.
-    w : float
-        Threshold for the allele frequency in `ref_gts`. Only loci with frequencies less than `w` are counted.
-        Must be within the range [0, 1].
-    x : float
-        Threshold for the allele frequency in `tgt_gts`. Only loci with frequencies greater than `x` are counted.
-        Must be within the range [0, 1].
-    y_list : list of float
-        List of exact allele frequency thresholds for each source population in `src_gts_list`.
-        Must be within the range [0, 1] and have the same length as `src_gts_list`.
-    ploidy : int, optional
-        The ploidy level of the organism. Default is 1, which assumes phased data.
-    anc_allele_available : bool
-        If True, checks only for matches with `y` (assuming `1` represents the derived allele).
-        If False, checks both matches with `y` and `1 - y`, taking the major allele in the source as the reference.
-
-    Returns
-    -------
-    tuple[int, np.ndarray]
-        - The count of loci that meet all specified frequency conditions.
-        - A 1D numpy array containing the genomic positions of the loci that meet the conditions.
-
-    Raises
-    ------
-    ValueError
-        If `x` is outside the range [0, 1].
-    """
-    # Validate input parameters
-    if not (0 <= x <= 1):
-        raise ValueError("Parameter x must be within the range [0, 1].")
-
-    ref_freq, tgt_freq, condition = compute_matching_loci(
-        ref_gts,
-        tgt_gts,
-        src_gts_list,
-        w,
-        y_list,
-        ploidy,
-        anc_allele_available,
-    )
-
-    # Apply final conditions
-    condition &= tgt_freq > x
-
-    loci_indices = np.where(condition)[0]
-    loci_positions = pos[loci_indices]
-    count = loci_indices.size
-
-    # Return count of matching loci
-    return count, loci_positions
-
-
-def calc_q(
-    ref_gts: np.ndarray,
-    tgt_gts: np.ndarray,
-    src_gts_list: list[np.ndarray],
-    pos: np.ndarray,
-    w: float,
-    y_list: list[float],
-    quantile: float = 0.95,
-    ploidy: int = 1,
-    anc_allele_available: bool = False,
-) -> float:
-    """
-    Calculates a specified quantile of derived allele frequencies in `tgt_gts` for loci that meet specific conditions
-    across reference and multiple source genotypes, with adjustments based on src_freq consistency.
-
-    Parameters
-    ----------
-    ref_gts : np.ndarray
-        A 2D numpy array where each row represents a locus and each column represents an individual in the reference group.
-    tgt_gts : np.ndarray
-        A 2D numpy array where each row represents a locus and each column represents an individual in the target group.
-    src_gts_list : list of np.ndarray
-        A list of 2D numpy arrays for each source population, where each row represents a locus and each column
-        represents an individual in that source population.
-    pos: np.ndarray
-        A 1D numpy array where each element represents the genomic position.
-    w : float
-        Frequency threshold for the derived allele in `ref_gts`. Only loci with frequencies lower than `w` are included.
-        Must be within the range [0, 1].
-    y_list : list of float
-        List of exact frequency thresholds for each source population in `src_gts_list`.
-        Must be within the range [0, 1] and have the same length as `src_gts_list`.
-    quantile : float, optional
-        The quantile to compute for the filtered `tgt_gts` frequencies. Must be within the range [0, 1].
-        Default is 0.95 (95% quantile).
-    ploidy : int, optional
-        The ploidy level of the organism. Default is 1, which assumes phased data.
-    anc_allele_available : bool
-        If True, checks only for matches with `y` (assuming `1` represents the derived allele).
-        If False, checks both matches with `y` and `1 - y`, taking the major allele in the source as the reference.
-
-    Returns
-    -------
-    tuple[float, np.ndarray]
-        - The specified quantile of the derived allele frequencies in `tgt_gts` for loci meeting the specified conditions,
-          or NaN if no loci meet the criteria.
-        - A 1D numpy array containing the genomic positions of the loci that meet the conditions.
-
-    Raises
-    ------
-    ValueError
-        If `quantile` is outside the range [0, 1].
-    """
-    # Validate input parameters
-    if not (0 <= quantile <= 1):
-        raise ValueError("Parameter quantile must be within the range [0, 1].")
-
-    ref_freq, tgt_freq, condition = compute_matching_loci(
-        ref_gts,
-        tgt_gts,
-        src_gts_list,
-        w,
-        y_list,
-        ploidy,
-        anc_allele_available,
-    )
-
-    # Filter `tgt_gts` frequencies based on the combined condition
-    filtered_tgt_freq = tgt_freq[condition]
-    filtered_positions = pos[condition]
-
-    # Return NaN if no loci meet the criteria
-    if filtered_tgt_freq.size == 0:
-        return np.nan, np.array([])
-
-    threshold = np.nanquantile(filtered_tgt_freq, quantile)
-    loci_positions = filtered_positions[filtered_tgt_freq >= threshold]
-
-    # Calculate and return the specified quantile of the filtered `tgt_gts` frequencies
-    return threshold, loci_positions

sai/utils/preprocessors/feature_preprocessor.py

@@ -1,211 +0,0 @@
-# Copyright 2025 Xin Huang
-#
-# GNU General Public License v3.0
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, please see
-#
-#    https://www.gnu.org/licenses/gpl-3.0.en.html
-
-
-import numpy as np
-from typing import Any
-from sai.stats.features import calc_u, calc_q
-from sai.utils.preprocessors import DataPreprocessor
-
-
-class FeaturePreprocessor(DataPreprocessor):
-    """
-    A preprocessor subclass for generating feature vectors from genomic data.
-
-    This class extends DataPreprocessor to include additional functionality for creating
-    feature vectors based on genomic variants, reference and target individual genotypes,
-    and window-based genomic statistics.
-    """
-
-    def __init__(
-        self,
-        w: float,
-        y: list[float],
-        output_file: str,
-        stat_type: str,
-        anc_allele_available: bool = False,
-    ):
-        """
-        Initializes FeatureVectorsPreprocessor with specific frequency thresholds
-        and output file for storing generated feature vectors.
-
-        Parameters
-        ----------
-        w : float
-            Frequency threshold for `calc_u` and `calc_q`.
-        y : list[float]
-            List of frequency thresholds for `calc_u` and `calc_q`.
-        output_file : str
-            Path to the output file to save processed feature vectors.
-        stat_type: str,
-            Specifies the type of statistic to compute.
-            - "UXX" (e.g., "U50", "U90") : Compute the U statistic using `calc_u()`.
-            - "QXX" (e.g., "Q95", "Q50") : Compute the Q statistic using `calc_q()`,
-        anc_allele_available: bool, optional
-            If True, ancestral allele information is available.
-            If False, ancestral allele information is unavailable.
-            Default is False.
-
-        Raises
-        ------
-        ValueError
-            If `stat_type` is not in a valid format. Must be either: 'UXX' or 'QXX'.
-        """
-        self.w = w
-        self.y = y
-        self.output_file = output_file
-        self.anc_allele_available = anc_allele_available
-        if not (
-            len(stat_type) == 3
-            and stat_type[0] in {"U", "Q"}
-            and stat_type[1:].isdigit()
-        ):
-            raise ValueError(
-                f"Invalid stat_type format: {stat_type}. Expected format 'UXX' or 'QXX' (e.g., 'U50' or 'Q95')."
-            )
-        self.stat_prefix = stat_type[0]
-        self.threshold = int(stat_type[1:]) / 100
-
-    def run(
-        self,
-        chr_name: str,
-        ref_pop: str,
-        tgt_pop: str,
-        src_pop_list: list[str],
-        start: int,
-        end: int,
-        pos: np.ndarray,
-        ref_gts: np.ndarray,
-        tgt_gts: np.ndarray,
-        src_gts_list: list[np.ndarray],
-        ploidy: int,
-    ) -> list[dict[str, Any]]:
-        """
-        Generates feature vectors for a specified genomic window.
-
-        Parameters
-        ----------
-        chr_name : str
-            Chromosome name.
-        ref_pop : str
-            Reference population name.
-        tgt_pop : str
-            Target population name.
-        src_pop_list : list[str]
-            List of source population names.
-        start : int
-            Start position of the genomic window.
-        end : int
-            End position of the genomic window.
-        pos : np.ndarray
-            A 1D numpy array where each element represents the genomic position.
-        ref_gts : np.ndarray
-            Genotype data for the reference population.
-        tgt_gts : np.ndarray
-            Genotype data for the target population.
-        src_gts_list : list[np.ndarray]
-            List of genotype arrays for each source population.
-        ploidy: int
-            Ploidy of the genome.
-
-        Returns
-        -------
-        list[dict[str, Any]]
-            A list containing a dictionary of calculated feature vectors for the genomic window.
-        """
-        items = {
-            "chr_name": chr_name,
-            "start": start,
-            "end": end,
-            "ref_pop": ref_pop,
-            "tgt_pop": tgt_pop,
-            "src_pop_list": src_pop_list,
-            "nsnps": len(pos),
-        }
-
-        if (
-            (ref_gts is None)
-            or (tgt_gts is None)
-            or (src_gts_list is None)
-            or (ploidy is None)
-        ):
-            items["statistic"] = np.nan
-            items["candidates"] = np.array([])
-        elif self.stat_prefix == "U":
-            items["statistic"], items["candidates"] = calc_u(
-                ref_gts=ref_gts,
-                tgt_gts=tgt_gts,
-                src_gts_list=src_gts_list,
-                pos=pos,
-                w=self.w,
-                x=self.threshold,
-                y_list=self.y,
-                ploidy=ploidy,
-                anc_allele_available=self.anc_allele_available,
-            )
-        elif self.stat_prefix == "Q":
-            items["statistic"], items["candidates"] = calc_q(
-                ref_gts=ref_gts,
-                tgt_gts=tgt_gts,
-                src_gts_list=src_gts_list,
-                pos=pos,
-                w=self.w,
-                y_list=self.y,
-                quantile=self.threshold,
-                ploidy=ploidy,
-                anc_allele_available=self.anc_allele_available,
-            )
-        else:
-            raise ValueError(
-                f"Invalid stat_type: {self.stat_type}. Must be 'U' or 'QXX' (e.g., 'Q95')."
-            )
-
-        return [items]
-
-    def process_items(self, items: list[dict[str, Any]]) -> None:
-        """
-        Processes and writes a single dictionary of feature vectors to the output file.
-
-        Parameters
-        ----------
-        items : dict[str, Any]
-            A dictionary containing feature vectors for a genomic window.
-        """
-        with open(
-            self.output_file, "a"
-        ) as f:  # Open in append mode for continuous writing
-            lines = []
-            for item in items:
-                src_pop_str = ",".join(item["src_pop_list"])
-                candidates = (
-                    "NA"
-                    if item["candidates"].size == 0
-                    else ",".join(
-                        f"{item['chr_name']}:{pos}" for pos in item["candidates"]
-                    )
-                )
-
-                line = (
-                    f"{item['chr_name']}\t{item['start']}\t{item['end']}\t"
-                    f"{item['ref_pop']}\t{item['tgt_pop']}\t{src_pop_str}\t"
-                    f"{item['nsnps']}\t{item['statistic']}\t{candidates}\n"
-                )
-                lines.append(line)
-
-            f.writelines(lines)

sai_pg-1.0.0.dist-info/RECORD

@@ -1,30 +0,0 @@
-sai/__init__.py,sha256=ZLPiBk86c9R8ZFx9y5VF7Up2v4JS8WsEMfsVNlj7nXY,724
-sai/__main__.py,sha256=WJMDikIfZh-g9j9pl0o6sZqVb4llQpUhBcJbn4-9pvE,2058
-sai/sai.py,sha256=ffPTVxKMoLFX-zr9lsiU-p5KDict9glSTMiNcgWVtsw,9969
-sai/parsers/__init__.py,sha256=ZLPiBk86c9R8ZFx9y5VF7Up2v4JS8WsEMfsVNlj7nXY,724
-sai/parsers/argument_validation.py,sha256=OzkE9Ayr3KCB8rSP8mXnfx4aNOeJuEEFfit9q7RbURU,4374
-sai/parsers/outlier_parser.py,sha256=Qw0E_1zFxfYoynnYJ1scbQHEpPVaHwTCPtPe3n643I4,2354
-sai/parsers/plot_parser.py,sha256=C4uGH96th8Yj7KN7onkE6xTqYa8K7EiU-21xgZYDNZE,4556
-sai/parsers/score_parser.py,sha256=qZ6mLBHd2QwAb2V0QaOgzBkgpb6mZv_rdDckwzN0e38,8604
-sai/stats/__init__.py,sha256=ZLPiBk86c9R8ZFx9y5VF7Up2v4JS8WsEMfsVNlj7nXY,724
-sai/stats/features.py,sha256=7CI9i3csVH9sXryWGB0uLSJB6BbM9gJtA1IPN2EeT0k,11844
-sai/utils/__init__.py,sha256=B3ZcC1ALSWieGHPiqXKBFQRTrnlTX4TaHc3tCx9fj0w,782
-sai/utils/genomic_dataclasses.py,sha256=HBYp2dehdW_y3Pd6Un8XFMnN1Odg1EiZb9ci1syIibU,1443
-sai/utils/utils.py,sha256=Nnb1tPHWk9vmlRmUJ65_FEmLfDEsT41HZ9WvJ0ps7Vs,23127
-sai/utils/generators/__init__.py,sha256=hpE4PUQIOZQXzdpSx7dEllecDoOfxIWXNu1-WHa_VcM,858
-sai/utils/generators/chunk_generator.py,sha256=Jh0wDOR6Z5PXlzOTncmY-pr9PotnmfiWTZQL2aaVGAs,4565
-sai/utils/generators/data_generator.py,sha256=bVz9KPjJSL4becTsVZ-zH4i40y5UDA0JJOtzbwf5n84,1635
-sai/utils/generators/window_generator.py,sha256=G8aMmJbB8uWLNaoJAGSeBFTCvAib7DdWvbXDk9JvDdM,9066
-sai/utils/multiprocessing/__init__.py,sha256=mI_iVjOJschKjIcneo99utCMVjR0K3UpEjA_PMcmLm4,790
-sai/utils/multiprocessing/mp_manager.py,sha256=xbgje4Fi4U9WD7eqMlUkTLKLQ9aNV_hIG7nTYvniGFk,10263
-sai/utils/multiprocessing/mp_pool.py,sha256=wqgp7E7fU2MXKsv7d8kpIp40SLjqS8voxbB_FkVwczA,2273
-sai/utils/preprocessors/__init__.py,sha256=q25uXnq4jTrIVBbl1HFv3ZgEV0d79fCMp4tTZrq4vsM,878
-sai/utils/preprocessors/chunk_preprocessor.py,sha256=mNmc22PmIRZZjYoyktxKSRGSGzN_e1Cyi392VxTbtWc,5204
-sai/utils/preprocessors/data_preprocessor.py,sha256=XSQN_kXUfyCtIpqIf7TcqWIPcSk8kynHPH-KY9gh5VY,3595
-sai/utils/preprocessors/feature_preprocessor.py,sha256=Kmc7VsO9YJcbFwWk-Jha5Rzq7gZou1pwYh93Wpd9r5o,7143
-sai_pg-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-sai_pg-1.0.0.dist-info/METADATA,sha256=e16SXHsIZBXK5EtJDbDhyPJdEXcKes88sCNPls_s3y4,1789
-sai_pg-1.0.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-sai_pg-1.0.0.dist-info/entry_points.txt,sha256=uK34frE2UhEDNa5ISbGOtjF2HGAXF5uG_EgMocesEPs,42
-sai_pg-1.0.0.dist-info/top_level.txt,sha256=Kvf-0z0sZYQbLuM6ta183EOzD37k3VZbRH-h7HXntR0,4
-sai_pg-1.0.0.dist-info/RECORD,,

sai_pg-1.0.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-sai