snplib 1.0.0__py3-none-any.whl

snplib-1.0.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.2
+Name: snplib
+Version: 1.0.0
+Summary: Snptools is a tool for Single Nucleotide Polymorphism (SNP) data processing
+Author-email: Igor <igor.loschinin@gmail.com>
+License: GNU
+Project-URL: Homepage, https://github.com/IgorekLoschinin/snptools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy==1.26.1
+Requires-Dist: pandas==2.1.1
+Requires-Dist: six==1.16.0
+Requires-Dist: swifter==1.4.0
+Requires-Dist: xlrd==2.0.1
+Requires-Dist: XlsxWriter==3.1.9
+Requires-Dist: openpyxl==3.1.2
+Requires-Dist: pydantic==2.4.2
+Requires-Dist: pytest==7.4.2
+Requires-Dist: sphinx==7.2.6
+Requires-Dist: sphinx_rtd_theme==1.3.0
+
+# snptools
+
+**Snptools** is a tool for SNP (Single Nucleotide Polymorphism) data processing, 
+parentage calculation and call rate estimation.
+
+## Introduction
+
+SNP (Single Nucleotide Polymorphism) represent genetic variations, that can 
+be used to analyze genetic data. SNPTools provides a set of tools for working 
+with SNP data, including the following capabilities:
+
+- SNP data processing - FinalReport.
+- Parentage Verification and Parentage Discovery Based on SNP Genotypes (ICAR). 
+- Call rate estimation (percentage of missing data).
+- Processing and preparation of data in plink formats.
+
+## Installation
+
+To install SNPTools, follow the steps below:
+
+1. Clone the repository into your project directory:
+   ```
+   git clone https://github.com/yourusername/snpTools.git
+   ```
+2. Set dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+3. Use SNPTools:
+   ```
+   import snptools
+   ```
+   
+## Usage
+Snptools provides commands for a variety of operations. Here are examples of 
+usage:
+
+#### SNP data processing:
+```
+from snptools.finalreport import FinalReport
+```
+
+#### Computation of parentage:
+```
+from snptools.parentage import Discovery, Verification
+```
+
+#### Preparation format files:
+```
+from snptools.format import (
+   Snp, make_fam, make_ped, make_lgen, make_map
+)
+```
+
+#### Stat:
+```
+from snptools.statistics import (
+   hwe, hwe_test, call_rate, allele_freq, minor_allele_freq
+)
+```
+
+## Documentation
+Detailed documentation on how to use SNPTools is available see the docs.
+
+## License
+This project is licensed under the GNU General Public License - see the 
+LICENSE file for details.

snplib-1.0.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+finalreport/__init__.py,sha256=Yk49x8t-STIfsdP6QLMtaGm1gTj_n-XS8kchPguvW1g,161
+finalreport/_finalreport.py,sha256=el_d8MVmpic3wKCRJ-J52VZYSmMuNSf4p_tmPkgh0Z0,5876
+finalreport/tests/__init__.py,sha256=oNE_1bfqJEIatN_AZEuBAoM7uim_Q1X9DZuLAe1-dDc,174
+finalreport/tests/test_finalreport.py,sha256=uOnV-p2_yhqKEZSoVOt7W4oxJwEyuBVTfpi3iQ2tTp4,6498
+format/__init__.py,sha256=3W_l_sP1u9HV3HWwnsJxPGw9anrVknstqLaJmWQaG0k,261
+format/__settings.py,sha256=kyAVZ4tiU61sNr3jQhjXbLXRyBA3pjFfCw3fOfSkY14,289
+format/_plink.py,sha256=Z09IOPACOt3n8CKEVRkE4tLT16I8e_6ZoMaWRxSImrA,10529
+format/_snp.py,sha256=oI-V4-_w28aX-VxoimywLDDnX6owhdjLbqt9a54_ouU,3172
+format/tests/__init__.py,sha256=oNE_1bfqJEIatN_AZEuBAoM7uim_Q1X9DZuLAe1-dDc,174
+format/tests/test_plink_fam.py,sha256=vUcDFIU17ez2S9hIXIxrqjs4OxgWuC8wat6NzG4nwYQ,2757
+format/tests/test_plink_lgen.py,sha256=cw8jeAe74iWI45gZ8Ix8diLWFGeoAoq3LWmHW9Mz8Nw,2205
+format/tests/test_plink_map.py,sha256=DtFgJpYjSdKk5AzDbZW4O9mRu1M43lgZMYMb-bmzEX8,947
+format/tests/test_plink_ped.py,sha256=8SbNs9v9ss8ZDv52csMU1D5uONfhic7_mvuBrgN5Xss,2938
+format/tests/test_snp.py,sha256=xtb2fniEARHoNFvFd9IrnX-QBBEKO6zyDmhaTdJ3Ric,3263
+parentage/__init__.py,sha256=bN3mWTxmaFQ1qzRtyMLaAoxfomz6jnoWa-kmnJ9q_fE,280
+parentage/_discov.py,sha256=qGlNzpl4xKOWRr6-fi1osylzizgiPO8vCus8VE56nec,3180
+parentage/_isagmark.py,sha256=0xi9YhuIpU7zf16HnWw1XIkcQLk4rTNeAeCE-5p9hQE,356
+parentage/_verif.py,sha256=VbX46dC4tl4Qeuw65aRg1s6hSn0FI25Hy9-3U_jxmrg,3019
+parentage/tests/__init__.py,sha256=DvTuot4rW2KfvH-orj-CJdZc1seq3SXhFcrkO39geeQ,172
+parentage/tests/test_discov.py,sha256=gJt1SjYTr7ZaphZayc1oBR9THTFjFxvViTi9a0X4fnI,4150
+parentage/tests/test_verif.py,sha256=JROafzDlyMUBfbXq6iq3EVhEqHkrh9tRB-C0EdOf7aY,3951
+statistics/__init__.py,sha256=XJFU7mEwAJJ2M187jEkO8rFNYKoxF-g9KF_stS7eFFw,302
+statistics/_callrate.py,sha256=ghB1EXT5JLQeIEIzh8LjWpqAnhCtCOk6l5ecNMLtQa0,1865
+statistics/_freq.py,sha256=ZPZBZM3xq9EseOxuMzRVvzkjjFfaaA4ZvF7XI8ctON0,1623
+statistics/_snphwe.py,sha256=KcoRGwovMCc53-GJ8VfYs_3ZEHObgt8B0EvrW5nFnmM,3353
+statistics/tests/__init__.py,sha256=DvTuot4rW2KfvH-orj-CJdZc1seq3SXhFcrkO39geeQ,172
+statistics/tests/test_callrate.py,sha256=a-j3muIn5unTH9dZW7xe_v2WU6uIMmj4PvzfWYkQbIs,5653
+statistics/tests/test_freq_allele.py,sha256=7jbxM7MCkUnrAouiuphJ5lGdZq4K72IoIqz7JQdTFds,2586
+statistics/tests/test_freq_maf.py,sha256=IndsZaCUBn7Hql8_ao35Cip78GA_ytDZjYugWXkdPt4,430
+statistics/tests/test_hwe_t.py,sha256=MqoP3DJ-159WTJEbWsAzIVsuGG791PYPm4DjPFoehfw,847
+statistics/tests/test_snphwe.py,sha256=chutPCO7lYYUMvsuDwvuehB6_4oBRkp1OnUJtL52HTE,995
+snplib-1.0.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+snplib-1.0.0.dist-info/METADATA,sha256=E_EU6XriENiCXVP0rHOjnqwQGa19oqnALVKK3glNqg0,2298
+snplib-1.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+snplib-1.0.0.dist-info/top_level.txt,sha256=JrsCvtXEC8OFF-STMY1jzbM5YEuA_57kuXXq5aI8dfc,40
+snplib-1.0.0.dist-info/RECORD,,

snplib-1.0.0.dist-info/WHEEL

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

snplib-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+finalreport
+format
+parentage
+statistics

statistics/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+# coding: utf-8
+__author__ = "Igor Loschinin (igor.loschinin@gmail.com)"
+
+from ._snphwe import hwe, hwe_test
+from ._callrate import call_rate
+from ._freq import allele_freq, minor_allele_freq
+
+
+__all__ = [
+	"call_rate",
+	"allele_freq",
+	"minor_allele_freq",
+	"hwe",
+	"hwe_test"
+]

statistics/_callrate.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+# coding: utf-8
+__author__ = "Igor Loschinin (igor.loschinin@gmail.com)"
+
+import pandas as pd
+
+
+def call_rate(
+		data: pd.DataFrame | str,
+		id_col: str = None,
+		snp_col: str = None
+) -> pd.DataFrame | float | None:
+	""" The call rate for a given SNP is defined as the proportion of
+	individuals in the study for which the corresponding SNP information is
+	not missing. In the following example, we filter using a call rate of 95%,
+	meaning we retain SNPs for which there is less than 5% missing data.
+
+		Of the say, 54K markers in the chip, 50K have been genotyped for a
+	particular animal, the “call rate animal” is 50K/54K=93%
+		Of the say, 900 animals genotyped for marker CL635944_160.1, how many
+	have actually been successfully read? Assume that 600 have been read, then
+	the “call rate marker” is 600/900 = 67%
+
+	:param data: Pre-processed data on which the call rate is calculated.
+	:param id_col: The name of the column with the id of the animals or
+		markers.
+	:param snp_col: The name of the column with the snp sequence.
+	:return: Return dataframe with call rates for each animal if a dataframe
+		is transmitted. The number if the snp sequence is passed as a string.
+		None if there were errors.
+	"""
+
+	if isinstance(data, pd.DataFrame):
+		try:
+			if data[snp_col].dtype.hasobject:
+				if not data[snp_col].str.isdigit().all():
+					return None
+
+				return data[[id_col, snp_col]].\
+					groupby(by=id_col)[snp_col].\
+					apply(lambda x: 1 - ((x == "5").sum() / len(x))).\
+					reset_index()
+
+			return data[[id_col, snp_col]]. \
+				groupby(by=id_col)[snp_col]. \
+				apply(lambda x: 1 - ((x == 5).sum() / len(x))). \
+				reset_index()
+
+		except Exception as e:
+			raise e
+
+	elif isinstance(data, str):
+		if not data.isdigit():
+			return None
+
+		return round(1 - (data.count('5') / len(data)), 6)
+
+	else:
+		return None

statistics/_freq.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# coding: utf-8
+__author__ = "Igor Loschinin (igor.loschinin@gmail.com)"
+
+import pandas as pd
+
+
+def allele_freq(
+		data: pd.DataFrame | str, id_col: str = None, seq_col: str = None
+) -> pd.DataFrame | float | None:
+	""" The allele frequency represents the incidence of a gene variant in a
+	population.
+
+	:param data: Data array.
+	:param id_col: Columns with snp names.
+	:param seq_col: Columns with value snp in format ucg - 0, 1, 2, 5.
+	:return: Return the alleles frequency.
+	"""
+
+	if isinstance(data, pd.DataFrame):
+		try:
+			if data[seq_col].dtype.hasobject:
+				if not data[seq_col].str.isdigit().all():
+					return None
+
+				return data.\
+					loc[data[seq_col] != "5", [id_col, seq_col]]. \
+					groupby(by=id_col)[seq_col]. \
+					apply(lambda x: x.astype("int8").sum() / (2 * x.count())).\
+					reset_index().\
+					round(3)
+
+			return data.\
+				loc[data[seq_col] != 5, [id_col, seq_col]].\
+				groupby(by=id_col)[seq_col].\
+				apply(lambda x: x.sum() / (2 * x.count())).\
+				reset_index().\
+				round(3)
+
+		except Exception as e:
+			raise e
+
+	elif isinstance(data, str):
+		if not data.isdigit():
+			return None
+
+		sam_seq = tuple(
+			map(int, filter(lambda x: x if x != "5" else None, data))
+		)
+		return round(sum(sam_seq) / (2 * len(sam_seq)), 3)
+
+	else:
+		return None
+
+
+def minor_allele_freq(value: float) -> float:
+	""" The minor allele frequency is therefore the frequency at which the
+	minor allele occurs within a population.
+
+	:param value: Allele frequency
+	:return: Return the minor alleles frequency
+	"""
+
+	if value > 0.5:
+		return round(1 - value, 3)
+
+	return round(value, 3)

statistics/_snphwe.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+# coding: utf-8
+__author__ = "Igor Loschinin (igor.loschinin@gmail.com)"
+
+import numpy as np
+import pandas as pd
+
+
+def hwe(
+		obs_hets: int | float, obs_hom1: int | float, obs_hom2: int | float
+) -> float:
+	""" Python interpretation hwe - https://github.com/jeremymcrae/snphwe
+
+	:param obs_hets: Number of observed heterozygotes (AB, BA)
+	:param obs_hom1: Number of observed homozygotes1 (AA)
+	:param obs_hom2: Number of observed homozygotes2 (BB)
+	:return: This is where the p-value is returned
+	"""
+
+	obs_hets = round(obs_hets)
+	obs_hom1 = round(obs_hom1)
+	obs_hom2 = round(obs_hom2)
+
+	if obs_hom1 < 0 or obs_hom2 < 0 or obs_hets < 0:
+		raise ValueError("snphwe: negative allele count")
+
+	obs_homr = min(obs_hom1, obs_hom2)
+	obs_homc = max(obs_hom1, obs_hom2)
+
+	rare = 2 * obs_homr + obs_hets
+	genotypes = obs_hets + obs_homc + obs_homr
+
+	if genotypes == 0:
+		raise ValueError("snphwe: zero genotypes")
+
+	probs = np.zeros(round(rare) + 1)
+
+	# get distribution midpoint, but ensure midpoint and rare alleles have
+	# same parity
+	mid = int(rare * (2 * genotypes - rare) / (2 * genotypes))
+	if mid % 2 != rare % 2:
+		mid += 1
+
+	probs[mid] = 1.0
+	_sum = probs[mid]
+
+	curr_homr = (rare - mid) / 2
+	curr_homc = genotypes - mid - curr_homr
+	curr_hets = mid
+	while curr_hets > 1:
+		probs[curr_hets - 2] = (
+			probs[curr_hets] * curr_hets * (curr_hets - 1.0)
+			/ (4.0 * (curr_homr + 1.0) * (curr_homc + 1.0))
+		)
+		_sum += probs[curr_hets - 2]
+
+		# fewer heterozygotes -> add one rare, one common homozygote
+		curr_homr += 1
+		curr_homc += 1
+		curr_hets -= 2
+
+	# calculate probabilities from midpoint up
+	curr_homr = (rare - mid) / 2
+	curr_homc = genotypes - mid - curr_homr
+
+	curr_hets = mid
+	while curr_hets <= rare - 2:
+		probs[curr_hets + 2] = \
+			(probs[curr_hets] * 4.0 * curr_homr * curr_homc
+			 / ((curr_hets + 2.0) * (curr_hets + 1.0)))
+		_sum += probs[curr_hets + 2]
+
+		# add 2 heterozygotes -> subtract one rare, one common homozygote
+		curr_homr -= 1
+		curr_homc -= 1
+		curr_hets += 2
+
+	# p-value calculation for p_hwe
+	target = probs[obs_hets]
+	p_hwe = 0.0
+
+	for p in probs:
+		if p <= target:
+			p_hwe += p / _sum
+
+	return min(1.0, p_hwe)
+
+
+def hwe_test(
+		seq_snp: pd.Series, freq: float, crit_chi2: float = 3.841
+) -> bool:
+	""" The Hardy-Weinberg equilibrium is a principle stating that the genetic
+	variation in a population will remain constant from one generation to the
+	next in the absence of disturbing factors.
+	https://www.nature.com/scitable/definition/hardy-weinberg-equilibrium-122/
+
+	:param seq_snp: SNP sequence
+	:param freq: Allele frequency
+	:param crit_chi2: The critical value for a test ("either / or":
+		observed and expected values are either one way or the other),
+		therefore with degrees of freedom = df = 1 is 3.84 at p = 0.05
+	:return: A decision is returned to exclude or retain the inspected snp
+	"""
+
+	_seq = seq_snp.replace(5, np.nan)
+
+	if _seq.nunique() == 1:
+		return True
+
+	n_genotypes = _seq.count()
+
+	observed = {
+		0: (_seq == 0).sum(),
+		1: (_seq == 1).sum(),
+		2: (_seq == 2).sum()
+	}
+
+	expected = {
+		0: ((1 - freq) ** 2) * n_genotypes,
+		1: (2 * ((1 - freq) * freq)) * n_genotypes,
+		2: (freq ** 2) * n_genotypes
+	}
+
+	chi = sum([
+		((obs - exp) ** 2) / exp
+		for obs, exp in zip(observed.values(), expected.values())
+	])
+
+	if chi > crit_chi2:
+		return False
+	else:
+		return True

statistics/tests/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python
+# coding: utf-8
+__author__ = "Igor Loschinin (igor.loschinin@gmail.com)"
+
+from pathlib import Path
+
+DIR_DATA = Path(__file__).parent.joinpath("data")

statistics/tests/test_callrate.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+# coding: utf-8
+__author__ = "Igor Loschinin (igor.loschinin@gmail.com)"
+
+from . import DIR_DATA
+from .. import call_rate
+
+import pytest
+import numpy as np
+import pandas as pd
+
+
+@pytest.fixture
+def data_df(request) -> pd.DataFrame:
+	match request.param:
+		case "cra":
+			return pd.read_pickle(DIR_DATA / "cr/file_cra.pl")
+
+		case "crm":
+			return pd.read_pickle(DIR_DATA / "cr/file_crm.pl")
+
+
+@pytest.fixture
+def data_str() -> list[str]:
+	return ['02011015010000500', '01110152120222512']
+
+
+class TestCallRateAnimal(object):
+
+	@pytest.mark.parametrize("data_df", ["cra"], indirect=True)
+	def test_cra_datafame_dtype_obj(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype(str)
+		result = call_rate(data=data_df, id_col="SAMPLE_ID", snp_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.882353, 0.882353]).all()
+
+	@pytest.mark.parametrize("data_df", ["cra"], indirect=True)
+	def test_cra_datafame_dtype_int(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype("int8")
+		result = call_rate(data=data_df, id_col="SAMPLE_ID", snp_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.882353, 0.882353]).all()
+
+	@pytest.mark.parametrize("data_df", ["cra"], indirect=True)
+	def test_cra_datafame_dtype_float(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype("float32")
+		result = call_rate(data=data_df, id_col="SAMPLE_ID", snp_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.882353, 0.882353]).all()
+
+	@pytest.mark.parametrize("data_df", ["cra"], indirect=True)
+	def test_cra_datafame_dtype_random_simbols(
+		self, data_df: pd.DataFrame
+	) -> None:
+		data_df.SNP = [
+			np.random.choice(["A", "C", "G", "T"])
+			for _ in range(data_df.SNP.shape[0])
+		]
+		result = call_rate(data=data_df, id_col="SAMPLE_ID", snp_col="SNP")
+
+		assert result is None
+
+	def test_cra_datafame_empty1(self) -> None:
+		with pytest.raises(KeyError):
+			call_rate(data=pd.DataFrame(), id_col="SAMPLE_ID", snp_col="SNP")
+
+	def test_cra_datafame_empty2(self) -> None:
+		result = call_rate(
+			data=pd.DataFrame(columns=["SAMPLE_ID", "SNP"]),
+			id_col="SAMPLE_ID",
+			snp_col="SNP"
+		)
+
+		assert isinstance(result, pd.DataFrame) and result.empty
+
+	@pytest.mark.parametrize("data_df", ["cra"], indirect=True)
+	def test_cra_datafame_fail(self, data_df: pd.DataFrame) -> None:
+		with pytest.raises(KeyError):
+			call_rate(data=data_df, id_col="SAMPLE_ID")
+			call_rate(data=data_df, snp_col="SNP")
+			call_rate(data=data_df)
+
+	def test_cra_str_int(self, data_str: list[str]) -> None:
+		for sequence in data_str:
+			assert call_rate(data=sequence) == 0.882353
+
+	def test_cra_str_simbols(self) -> None:
+		data_str = ['GCATGAGGTATACTCTA', 'CGCCATGCTGTATATCC']
+
+		for sequence in data_str:
+			assert call_rate(data=sequence) is None
+
+	def test_cra_str_empty(self) -> None:
+		assert call_rate(data="") is None
+
+	def test_cra_str_mixid(self) -> None:
+		assert call_rate(data="GCATGAG3G4T6A67TACTCTA") is None
+
+
+class TestCallRateMarker(object):
+
+	@pytest.mark.parametrize("data_df", ["crm"], indirect=True)
+	def test_crm_datafame_dtype_obj(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype(str)
+		result = call_rate(data=data_df, id_col="SNP_NAME", snp_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.727273, 0.909091, 0.818182]).all()
+
+	@pytest.mark.parametrize("data_df", ["crm"], indirect=True)
+	def test_crm_datafame_dtype_int(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype("int8")
+		result = call_rate(data=data_df, id_col="SNP_NAME", snp_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.727273, 0.909091, 0.818182]).all()
+
+	@pytest.mark.parametrize("data_df", ["crm"], indirect=True)
+	def test_crm_datafame_dtype_float(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype("float32")
+		result = call_rate(data=data_df, id_col="SNP_NAME", snp_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.727273, 0.909091, 0.818182]).all()
+
+	@pytest.mark.parametrize("data_df", ["crm"], indirect=True)
+	def test_crm_datafame_dtype_random_simbols(
+		self, data_df: pd.DataFrame
+	) -> None:
+		data_df.SNP = [
+			np.random.choice(["A", "C", "G", "T"])
+			for _ in range(data_df.SNP.shape[0])
+		]
+		result = call_rate(data=data_df, id_col="SNP_NAME", snp_col="SNP")
+
+		assert result is None
+
+	def test_crm_datafame_empty1(self) -> None:
+		with pytest.raises(KeyError):
+			call_rate(data=pd.DataFrame(), id_col="SNP_NAME", snp_col="SNP")
+
+	def test_crm_datafame_empty2(self) -> None:
+		result = call_rate(
+			data=pd.DataFrame(columns=["SNP_NAME", "SNP"]),
+			id_col="SNP_NAME",
+			snp_col="SNP"
+		)
+
+		assert isinstance(result, pd.DataFrame) and result.empty
+
+	@pytest.mark.parametrize("data_df", ["crm"], indirect=True)
+	def test_crm_datafame_fail(self, data_df: pd.DataFrame) -> None:
+		with pytest.raises(KeyError):
+			call_rate(data=data_df, id_col="SNP_NAME")
+			call_rate(data=data_df, snp_col="SNP")
+			call_rate(data=data_df)
+
+	def test_crm_str_simbols(self) -> None:
+		data_str = ['GCATGAGGTATACTCTA', 'CGCCATGCTGTATATCC']
+
+		for sequence in data_str:
+			assert call_rate(data=sequence) is None
+
+	def test_crm_str_empty(self) -> None:
+		assert call_rate(data="") is None
+
+	def test_crm_str_mixid(self) -> None:
+		assert call_rate(data="GCATGAG3G4T6A67TACTCTA") is None

statistics/tests/test_freq_allele.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+# coding: utf-8
+__author__ = "Igor Loschinin (igor.loschinin@gmail.com)"
+
+from . import DIR_DATA
+from .. import allele_freq
+
+import pytest
+import numpy as np
+import pandas as pd
+
+
+@pytest.fixture
+def data_df() -> pd.DataFrame:
+	return pd.read_pickle(DIR_DATA / "freq/file.pl")
+	# [0.   , 0.9  , 0.889]
+
+
+def data_str() -> list[tuple]:
+	return [
+		('2212120', 0.714),
+		('02011015010000500', 0.2),
+		('01110152120222512', 0.6)
+	]
+
+
+class TestAlleleFreq(object):
+
+	def test_allele_freq_df_dtype_obj(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype(str)
+		result = allele_freq(data=data_df, id_col="SNP_NAME", seq_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.000, 0.900, 0.889]).all()
+
+	def test_allele_freq_df_dtype_int(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype("int8")
+		result = allele_freq(data=data_df, id_col="SNP_NAME", seq_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.000, 0.900, 0.889]).all()
+
+	def test_allele_freq_df_dtype_float(self, data_df: pd.DataFrame) -> None:
+		data_df.SNP = data_df.SNP.astype("float32")
+		result = allele_freq(data=data_df, id_col="SNP_NAME", seq_col="SNP")
+
+		assert isinstance(result, pd.DataFrame) and not result.empty
+		assert result.SNP.round(6).isin([0.000, 0.900, 0.889]).all()
+
+	def test_allele_freq_df_data_rand_simbols(
+			self, data_df: pd.DataFrame
+	) -> None:
+		data_df.SNP = [
+			np.random.choice(["A", "C", "G", "T"])
+			for _ in range(data_df.SNP.shape[0])
+		]
+		assert allele_freq(
+			data=data_df, id_col="SNP_NAME", seq_col="SNP"
+		) is None
+
+	def test_allele_freq_df_empty(self) -> None:
+		with pytest.raises(KeyError):
+			allele_freq(
+				data=pd.DataFrame(), id_col="SNP_NAME", seq_col="SNP"
+			)
+
+	def test_allele_freq_df_empty_only_columns(self) -> None:
+		result = allele_freq(
+			data=pd.DataFrame(columns=["SNP_NAME", "SNP"]),
+			id_col="SNP_NAME",
+			seq_col="SNP"
+		)
+
+		assert isinstance(result, pd.DataFrame) and result.empty
+
+	def test_allele_freq_df_raises(self, data_df: pd.DataFrame) -> None:
+		with pytest.raises(KeyError):
+			allele_freq(data=data_df, id_col="SNP_NAME")
+			allele_freq(data=data_df, seq_col="SNP")
+			allele_freq(data=data_df)
+
+	@pytest.mark.parametrize("data, obs_value", data_str())
+	def test_allele_freq_str(self, data: str, obs_value: float) -> None:
+		assert allele_freq(data=data) == obs_value
+
+	def test_allele_freq_non_type(self) -> None:
+		assert allele_freq(data=1423) is None