PGAP2 2.2__tar.gz → 2.4__tar.gz

{pgap2-2.2 → pgap2-2.4/PGAP2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PGAP2
-Version: 2.2
+Version: 2.4
 Summary: PGAP2: a comprehensive pan-genome analysis pipeline for prokaryotic genomes
 Author-email: bucongfan <bucf@big.ac.cn>
 Maintainer-email: bucongfan <bucf@big.ac.cn>

{pgap2-2.2/PGAP2.egg-info → pgap2-2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PGAP2
-Version: 2.2
+Version: 2.4
 Summary: PGAP2: a comprehensive pan-genome analysis pipeline for prokaryotic genomes
 Author-email: bucongfan <bucf@big.ac.cn>
 Maintainer-email: bucongfan <bucf@big.ac.cn>

{pgap2-2.2 → pgap2-2.4}/pgap2/cli/neighborhood.py

@@ -4,6 +4,12 @@ CLI definitions for the 'neigh' (conserved gene neighborhood) subcommand.
 This subcommand runs the full partition pipeline (identical to 'main')
 followed by a conserved gene neighborhood discovery step inspired by
 spacedust's agglomerative clustering algorithm.
+
+spacedust:
+https://github.com/soedinglab/spacedust
+Zhang, R., Mirdita, M. & Söding, J. De novo discovery of conserved gene clusters in microbial genomes with Spacedust. 
+Nat Methods 22, 2065–2073 (2025). https://doi.org/10.1038/s41592-025-02816-x
+
 """
 
 import os
@@ -79,7 +85,7 @@ def neighborhood_cmd(subparser: _SubParsersAction):
         'neigh',
         help='Conserved gene neighborhood (synteny block) analysis. '
              'Runs the full partition pipeline then discovers conserved '
-             'gene neighborhoods across genomes (spacedust-style).',
+             'gene neighborhoods across genomes.',
         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 
     # ---- Partition parameters (same as 'main') ----

{pgap2-2.2 → pgap2-2.4}/pgap2/lib/synteny.py

@@ -17,8 +17,9 @@ The algorithm works in four steps:
      gene neighborhoods.
 
 Reference:
-  Zhang, R., Mirdita, M., & Söding, J. (2024). De novo discovery of conserved
-  gene clusters in microbial genomes with Spacedust. bioRxiv.
+  Zhang, R., Mirdita, M. & Söding, J. De novo discovery of conserved gene clusters in microbial genomes with Spacedust. 
+  Nat Methods 22, 2065–2073 (2025). 
+  https://doi.org/10.1038/s41592-025-02816-x
 """
 
 import math

{pgap2-2.2 → pgap2-2.4}/pgap2/main.py

@@ -23,7 +23,7 @@ def main():
     parser.add_argument(
         "-V", "--version",
         action="version",
-        version=f"%(prog)s {__version__}  (author: {__author__})"
+        version=f"%(prog)s current version: {__version__}"
     )
     subparser: _SubParsersAction = parser.add_subparsers()
 

{pgap2-2.2 → pgap2-2.4}/pgap2/postprocess/profile.py

@@ -55,7 +55,7 @@ def main(pav_file: str, outdir: str, nodraw: bool, threads: int = 1, disable: bo
     group_freq, pan_para_stat = get_pan_group(pav, outdir)
 
     logger.info("Starting rarefaction curve fitting.")
-    fit_rerefaction(pan_profile, outdir)
+    fit_rerefaction(pan_profile, outdir, new_clusters)
 
     if nodraw:
         logger.info('Drawing is disabled')

{pgap2-2.2 → pgap2-2.4}/pgap2/postprocess/stat.py

@@ -56,6 +56,132 @@ def pan_gene_model(x, k, gamma):
     return k * x**gamma
 
 
+def new_gene_model(x, k, alpha):
+    return k * x**(-alpha)
+
+
+# Make sure that only finite values are used in the fitting process.
+def _drop_invalid_fit_points(x_data, y_data):
+    x_data = np.asarray(x_data, dtype=float)
+    y_data = np.asarray(y_data, dtype=float)
+    valid_points = np.isfinite(x_data) & np.isfinite(y_data)
+    return x_data[valid_points], y_data[valid_points]
+
+
+def _get_core_fit_initial_params(core_gene_means):
+    if len(core_gene_means) == 0:
+        raise ValueError("No valid core gene points are available for curve fitting.")
+    C_inf = max(float(core_gene_means[-1]), 0.0)
+    C0 = max(float(core_gene_means[0]) - C_inf, 0.0)
+    return [C0, 0.05, C_inf]
+
+
+def _get_pan_fit_initial_params(pan_gene_means):
+    if len(pan_gene_means) == 0:
+        raise ValueError("No valid pan gene points are available for curve fitting.")
+    k = max(float(pan_gene_means[0]), 0.0)
+    return [k, 0.5]
+
+
+def _fit_pan_gene_loglog(x_data, pan_gene_means):
+    positive_points = (x_data > 0) & (pan_gene_means > 0)
+    if np.count_nonzero(positive_points) < 2:
+        raise RuntimeError(
+            "At least two positive points are required for log-log pan gene fitting.")
+
+    gamma, log_k = np.polyfit(
+        np.log(x_data[positive_points]), np.log(pan_gene_means[positive_points]), 1)
+    k = np.exp(log_k)
+    return np.asarray([k, gamma], dtype=float)
+
+
+def _prepare_new_gene_fit_data(new_clusters):
+    if new_clusters is None or len(new_clusters) != 2:
+        raise ValueError("New gene cluster data are required for pan-genome state fitting.")
+
+    x_data = np.asarray(new_clusters[0], dtype=float)
+    sample_groups = new_clusters[1]
+    if len(x_data) != len(sample_groups):
+        raise ValueError("New gene cluster strain counts and samples have different lengths.")
+
+    means = []
+    for samples in sample_groups:
+        values = np.asarray(
+            [value for value in samples if value != 'NA'], dtype=float)
+        values = values[np.isfinite(values)]
+        means.append(np.mean(values) if len(values) else np.nan)
+
+    x_data, means = _drop_invalid_fit_points(x_data, means)
+    valid_points = (x_data > 0) & (means >= 0)
+    x_data = x_data[valid_points]
+    means = means[valid_points]
+    if len(np.unique(x_data)) < 3:
+        raise ValueError(
+            "At least three distinct strain counts are required for pan-genome state fitting.")
+    return x_data, means
+
+
+def _fit_new_gene_decay(new_clusters):
+    x_data, new_gene_means = _prepare_new_gene_fit_data(new_clusters)
+    if np.all(new_gene_means == 0):
+        return np.asarray([0.0, np.inf]), None
+
+    alpha_initial = 0.5
+    k_initial = max(
+        float(new_gene_means[0]) * float(x_data[0])**alpha_initial,
+        np.finfo(float).eps,
+    )
+    try:
+        return curve_fit(
+            new_gene_model,
+            x_data,
+            new_gene_means,
+            p0=[k_initial, alpha_initial],
+            bounds=([0, 0], [np.inf, np.inf]),
+            maxfev=10000,
+        )
+    except (RuntimeError, ValueError):
+        positive_points = new_gene_means > 0
+        if np.count_nonzero(positive_points) < 3:
+            raise RuntimeError(
+                "At least three positive points are required for log-log new gene fitting.")
+
+        coefficients, log_covariance = np.polyfit(
+            np.log(x_data[positive_points]),
+            np.log(new_gene_means[positive_points]),
+            1,
+            cov=True,
+        )
+        slope, log_k = coefficients
+        popt = np.asarray([np.exp(log_k), -slope], dtype=float)
+        covariance = np.zeros((2, 2), dtype=float)
+        covariance[1, 1] = log_covariance[0, 0]
+        return popt, covariance
+
+
+def _get_alpha_confidence_interval(alpha, covariance):
+    if covariance is None or not np.isfinite(alpha):
+        return None
+    alpha_variance = covariance[1, 1]
+    if not np.isfinite(alpha_variance) or alpha_variance < 0:
+        return None
+    margin = 1.96 * np.sqrt(alpha_variance)
+    return alpha - margin, alpha + margin
+
+
+def _classify_pan_genome(alpha, alpha_interval):
+    if np.isposinf(alpha):
+        return "closed"
+    if alpha_interval is None:
+        return "uncertain"
+    lower_alpha, upper_alpha = alpha_interval
+    if lower_alpha > 1:
+        return "closed"
+    if upper_alpha <= 1:
+        return "open"
+    return "uncertain"
+
+
 def stat_pan_core(sampling_list, pav, i_strain, strain_num):
     core_list = []
     pan_list = []
@@ -97,32 +223,35 @@ def calculate_rarefaction(i_strain, pangp: PanGP):
     return {'strain_num': i_strain, 'profile': record, 'new_clusters': new_clusters, }
 
 
-def log_pan_genome_state(popt_pan, ofh):
-    k, gamma = popt_pan
-    if gamma < 1:
-        genome_status = "open"
+def log_pan_genome_state(alpha, alpha_interval, genome_status, ofh):
+    if genome_status == "open":
+        status_description = (
+            "The pan-genome is open because the 95% confidence interval for alpha is at or below 1."
+        )
+    elif genome_status == "closed":
         status_description = (
-            "The pan-genome is open, meaning that the discovery of new genes will continue as more genomes are added."
+            "The pan-genome is closed because no new clusters were observed or the 95% confidence interval for alpha is above 1."
         )
     else:
-        genome_status = "closed"
         status_description = (
-            "The pan-genome is closed, meaning that the discovery of new genes will saturate as more genomes are added."
+            "The pan-genome state is uncertain because the alpha confidence interval crosses 1."
         )
     logger.info(
-        f"The pan-genome is {genome_status}. {status_description}")
-    ofh.write(
-        f"The pan-genome is {genome_status}. {status_description}\n")
+        status_description)
+    ofh.write(f"{status_description}\n")
 
-    logger.info(
-        f"The coefficient k is approximately {k:.2f}, indicating the initial addition rate of new gene clusters per genome.\nLarger values of k suggest a higher initial rate of gene discovery. ")
-    ofh.write(
-        f"The coefficient k is approximately {k:.2f}, indicating the initial addition rate of new gene clusters per genome.\nLarger values of k suggest a higher initial rate of gene discovery. ")
+    if np.isfinite(alpha):
+        ofh.write(f"The new-gene decay exponent alpha is {alpha:.3f}.\n")
+    else:
+        ofh.write("The new-gene decay exponent alpha is infinite.\n")
+    if alpha_interval is not None:
+        ofh.write(
+            f"The 95% confidence interval for alpha is [{alpha_interval[0]:.3f}, {alpha_interval[1]:.3f}].\n")
 
 
-def fit_rerefaction(pan_rarefaction, outdir):
+def fit_rerefaction(pan_rarefaction, outdir, new_clusters=None):
 
-    x_data = pan_rarefaction[0]
+    x_data = np.asarray(pan_rarefaction[0], dtype=float)
     core_gene_samples = pan_rarefaction[1]
     pan_gene_samples = pan_rarefaction[2]
 
@@ -134,27 +263,96 @@ def fit_rerefaction(pan_rarefaction, outdir):
             pan_gene_samples[i] = [
                 int(_) for _ in pan_gene_samples[i] if _ != 'NA']
 
-    core_gene_means = [np.mean(samples) for samples in core_gene_samples]
-    pan_gene_means = [np.mean(samples) for samples in pan_gene_samples]
-
-    ofh = open(file=f'{outdir}/postprocess.curve_fit.txt', mode='w')
-
-    logger.info("Fitting core gene data.")
-    popt_core, _ = curve_fit(core_gene_model, x_data,
-                             core_gene_means, p0=[2000, 0.1, 500])
-    logger.info(f"Optimal parameters for core genes: {popt_core}")
-    ofh.write(f'Optimal parameters for core genes: {popt_core}\n')
+    core_gene_means = np.asarray(
+        [np.mean(samples) for samples in core_gene_samples], dtype=float)
+    pan_gene_means = np.asarray(
+        [np.mean(samples) for samples in pan_gene_samples], dtype=float)
+
+    core_x_data, core_gene_means = _drop_invalid_fit_points(
+        x_data, core_gene_means)
+    pan_x_data, pan_gene_means = _drop_invalid_fit_points(
+        x_data, pan_gene_means)
+
+    with open(file=f'{outdir}/postprocess.curve_fit.txt', mode='w') as ofh:
+
+        logger.info("Fitting core gene data.")
+        try:
+            popt_core, _ = curve_fit(
+                core_gene_model,
+                core_x_data,
+                core_gene_means,
+                p0=_get_core_fit_initial_params(core_gene_means),
+                bounds=([0, 0, 0], [np.inf, np.inf, np.inf]),
+                maxfev=10000,
+            )
+            logger.info(f"Optimal parameters for core genes: {popt_core}")
+            ofh.write(f'Optimal parameters for core genes: {popt_core}\n')
+        except (RuntimeError, ValueError) as err:
+            popt_core = None
+            logger.warning(f"Core gene curve fitting failed: {err}")
+            ofh.write('Optimal parameters for core genes: NA\n')
+
+        logger.info("Fitting pan gene data.")
+        try:
+            popt_pan, _ = curve_fit(
+                pan_gene_model,
+                pan_x_data,
+                pan_gene_means,
+                p0=_get_pan_fit_initial_params(pan_gene_means),
+                bounds=([0, 0], [np.inf, np.inf]),
+                maxfev=10000,
+            )
+            logger.info(f"Optimal parameters for pan genes: {popt_pan}")
+            ofh.write(f'Optimal parameters for pan genes: {popt_pan}\n')
+        except (RuntimeError, ValueError) as err:
+            logger.warning(
+                f"Pan gene curve fitting failed with curve_fit: {err}. Trying log-log fallback.")
+            try:
+                popt_pan = _fit_pan_gene_loglog(pan_x_data, pan_gene_means)
+                logger.info(
+                    f"Optimal parameters for pan genes from log-log fallback: {popt_pan}")
+                ofh.write(
+                    f'Optimal parameters for pan genes: {popt_pan} (log-log fallback)\n')
+            except (RuntimeError, ValueError) as fallback_err:
+                popt_pan = None
+                logger.warning(
+                    f"Pan gene log-log fallback fitting failed: {fallback_err}")
+                ofh.write('Optimal parameters for pan genes: NA\n')
+
+        if popt_core is None:
+            ofh.write('Core Gene Fit: NA\n')
+        else:
+            ofh.write(
+                f'Core Gene Fit: y={popt_core[0]:.3f}*exp(-{popt_core[1]:.3f}*x)+ {popt_core[2]:.3f}\n')
 
-    logger.info("Fitting pan gene data.")
-    popt_pan, _ = curve_fit(pan_gene_model, x_data,
-                            pan_gene_means, p0=[1000, 0.8])
-    logger.info(f"Optimal parameters for pan genes: {popt_pan}")
-    ofh.write(f'Optimal parameters for pan genes: {popt_pan}\n')
-    ofh.write(
-        f'Core Gene Fit: y={popt_core[0]:.3f}*exp({popt_core[1]:.3f}*x)+ {popt_core[2]:.3f}\n')
-    ofh.write(
-        f'Pan Gene Fit: y={popt_pan[0]:.3f}*x^{popt_pan[1]:.3f} \n')
-    log_pan_genome_state(popt_pan, ofh)
+        if popt_pan is None:
+            ofh.write('Pan Gene Fit: NA\n')
+        else:
+            ofh.write(
+                f'Pan Gene Fit: y={popt_pan[0]:.3f}*x^{popt_pan[1]:.3f} \n')
+
+        logger.info("Fitting new gene decay data for pan-genome state classification.")
+        try:
+            popt_new, covariance_new = _fit_new_gene_decay(new_clusters)
+            k_new, alpha = popt_new
+            alpha_interval = _get_alpha_confidence_interval(
+                alpha, covariance_new)
+            genome_status = _classify_pan_genome(alpha, alpha_interval)
+            logger.info(f"Optimal parameters for new genes: {popt_new}")
+            ofh.write(f'Optimal parameters for new genes: {popt_new}\n')
+            if np.isfinite(alpha):
+                ofh.write(
+                    f'New Gene Fit: y={k_new:.3f}*x^(-{alpha:.3f})\n')
+            else:
+                ofh.write('New Gene Fit: y=0\n')
+            log_pan_genome_state(
+                alpha, alpha_interval, genome_status, ofh)
+        except (RuntimeError, ValueError) as err:
+            logger.warning(
+                f"Pan-genome state fitting could not be completed: {err}")
+            ofh.write('Optimal parameters for new genes: NA\n')
+            ofh.write('New Gene Fit: NA\n')
+            ofh.write('Pan-genome state: NA\n')
 
     # plt.figure(figsize=(8, 6))
 
@@ -361,7 +559,7 @@ def main(indir: str, outdir: str, nodraw: bool, threads: int, disable: bool = Fa
     pan_profile, new_clusters = get_rarefaction(
         basic.pav, outdir, disable=disable, threads=threads, S=S, N=N, R=R, K=K, method=method)
     logger.info("Starting rarefaction curve fitting.")
-    fit_rerefaction(pan_profile, outdir)
+    fit_rerefaction(pan_profile, outdir, new_clusters)
 
     if nodraw:
         logger.info('Drawing is disabled')

{pgap2-2.2 → pgap2-2.4}/pgap2/utils/sqlite_builder.py

@@ -714,11 +714,9 @@ def _import_post_results(db: Session, project_id: int, data_path: Path):
     if curve_file.exists():
         content = curve_file.read_text().strip()
         if content:
-            openness = None
-            if "open" in content.lower():
-                openness = "open"
-            elif "closed" in content.lower():
-                openness = "closed"
+            state_match = re.search(
+                r"The pan-genome is (open|closed)\b", content, re.IGNORECASE)
+            openness = state_match.group(1).lower() if state_match else None
             db.add(CurveFit(
                 project_id=project_id,
                 model_name="heaps",

{pgap2-2.2 → pgap2-2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PGAP2"
-version = "2.2"
+version = "2.4"
 dynamic = ["readme"]
 keywords = ["pan-genome", "prokaryotic", "genomes", "pipeline","cluster"]
 

pgap2-2.4/tests/test_post.py

@@ -0,0 +1,143 @@
+import pytest
+import numpy as np
+
+
+@pytest.fixture
+def test_basic():
+    basic_file = 'tests/output/basic.pkl'
+    from pgap2.lib.pklcheck import PklCheck
+    from pgap2.lib.basic import Basic
+    import pickle
+
+    with open(f'{basic_file}', 'rb') as fh:
+        previous: PklCheck = pickle.load(fh)
+        decode_status = previous.decode()
+        assert decode_status is True, "decode did not return True for matching parameters"
+        basic: Basic = previous.data_dump('basic')
+        assert isinstance(
+            basic, Basic), "Basic object was not created correctly"
+        return basic
+
+
+def test_get_pan_group(test_basic):
+    from pgap2.postprocess.stat import get_pan_group
+    basic = test_basic
+    outdir = 'tests/output'
+    basic.load_pav(file=f'{outdir}/pgap2.partition.gene_content.pav')
+    pan_group_freq, pan_para_stat = get_pan_group(basic.pav, outdir)
+    assert len(
+        pan_group_freq) == 3, "get_pan_group did not return the expected number of groups"
+    assert len(
+        pan_para_stat) == 5, "get_pan_group did not return the expected number of parameters"
+
+
+def test_rare(test_basic):
+    from pgap2.postprocess.stat import get_rarefaction, fit_rerefaction
+    basic = test_basic
+    outdir = 'tests/output/'
+    basic.load_pav(file=f'{outdir}/pgap2.partition.gene_content.pav')
+    pan_profile, new_clusters = get_rarefaction(
+        basic.pav, outdir, N=1)
+    assert len(
+        pan_profile) == 3, "get_rarefaction did not return the expected number of profiles"
+    assert len(
+        new_clusters) == 2, "get_rarefaction did not return the expected number of clusters"
+
+
+def test_fit_rarefaction_keeps_running_when_core_fit_fails(tmp_path, monkeypatch):
+    from pgap2.postprocess import stat
+
+    pan_profile = [
+        [1, 2, 3, 4],
+        [[3000], [2500], [2300], [2200]],
+        [[4000], [4500], [4800], [5100]],
+    ]
+    original_curve_fit = stat.curve_fit
+
+    def fail_core_fit(model, *args, **kwargs):
+        if model is stat.core_gene_model:
+            raise RuntimeError("forced core failure")
+        return original_curve_fit(model, *args, **kwargs)
+
+    monkeypatch.setattr(stat, "curve_fit", fail_core_fit)
+
+    stat.fit_rerefaction(pan_profile, tmp_path)
+
+    content = (tmp_path / "postprocess.curve_fit.txt").read_text()
+    assert "Optimal parameters for core genes: NA" in content
+    assert "Pan Gene Fit: y=" in content
+
+
+def test_fit_rarefaction_uses_pan_loglog_fallback(tmp_path, monkeypatch):
+    from pgap2.postprocess import stat
+
+    pan_profile = [
+        [1, 2, 4, 8],
+        [[3000], [2500], [2300], [2200]],
+        [[1000], [1414], [2000], [2828]],
+    ]
+
+    def fail_pan_fit(model, *args, **kwargs):
+        if model is stat.pan_gene_model:
+            raise RuntimeError("forced pan failure")
+        return (
+            np.asarray([800.0, 0.1, 2200.0], dtype=float),
+            np.eye(3),
+        )
+
+    monkeypatch.setattr(stat, "curve_fit", fail_pan_fit)
+
+    stat.fit_rerefaction(pan_profile, tmp_path)
+
+    content = (tmp_path / "postprocess.curve_fit.txt").read_text()
+    assert "Optimal parameters for pan genes:" in content
+    assert "log-log fallback" in content
+    assert "Pan Gene Fit: y=" in content
+
+
+@pytest.mark.parametrize(
+    ("alpha", "expected_state"),
+    [
+        (0.5, "open"),
+        (1.5, "closed"),
+    ],
+)
+def test_fit_rarefaction_classifies_state_from_new_genes(
+        tmp_path, alpha, expected_state):
+    from pgap2.postprocess import stat
+
+    x_data = np.asarray([1, 2, 4, 8, 16, 32], dtype=float)
+    pan_profile = [
+        x_data.tolist(),
+        [[3000 - 20 * i] for i in range(len(x_data))],
+        [[4000 + 300 * np.sqrt(x)] for x in x_data],
+    ]
+    new_x_data = x_data[1:]
+    new_gene_means = 1000 * new_x_data**(-alpha)
+    new_clusters = [
+        new_x_data.tolist(),
+        [[value] for value in new_gene_means],
+    ]
+
+    stat.fit_rerefaction(pan_profile, tmp_path, new_clusters)
+
+    content = (tmp_path / "postprocess.curve_fit.txt").read_text()
+    assert "New Gene Fit: y=" in content
+    assert f"The pan-genome is {expected_state}" in content
+
+
+def test_fit_rarefaction_reports_na_with_too_few_new_gene_points(tmp_path):
+    from pgap2.postprocess import stat
+
+    pan_profile = [
+        [1, 2, 3, 4],
+        [[3000], [2500], [2300], [2200]],
+        [[4000], [4500], [4800], [5100]],
+    ]
+    new_clusters = [[2, 3], [[500], [200]]]
+
+    stat.fit_rerefaction(pan_profile, tmp_path, new_clusters)
+
+    content = (tmp_path / "postprocess.curve_fit.txt").read_text()
+    assert "Optimal parameters for new genes: NA" in content
+    assert "Pan-genome state: NA" in content

pgap2-2.2/tests/test_post.py

@@ -1,43 +0,0 @@
-import pytest
-
-
-@pytest.fixture
-def test_basic():
-    basic_file = 'tests/output/basic.pkl'
-    from pgap2.lib.pklcheck import PklCheck
-    from pgap2.lib.basic import Basic
-    import pickle
-
-    with open(f'{basic_file}', 'rb') as fh:
-        previous: PklCheck = pickle.load(fh)
-        decode_status = previous.decode()
-        assert decode_status is True, "decode did not return True for matching parameters"
-        basic: Basic = previous.data_dump('basic')
-        assert isinstance(
-            basic, Basic), "Basic object was not created correctly"
-        return basic
-
-
-def test_get_pan_group(test_basic):
-    from pgap2.postprocess.stat import get_pan_group
-    basic = test_basic
-    outdir = 'tests/output'
-    basic.load_pav(file=f'{outdir}/pgap2.partition.gene_content.pav')
-    pan_group_freq, pan_para_stat = get_pan_group(basic.pav, outdir)
-    assert len(
-        pan_group_freq) == 3, "get_pan_group did not return the expected number of groups"
-    assert len(
-        pan_para_stat) == 5, "get_pan_group did not return the expected number of parameters"
-
-
-def test_rare(test_basic):
-    from pgap2.postprocess.stat import get_rarefaction, fit_rerefaction
-    basic = test_basic
-    outdir = 'tests/output/'
-    basic.load_pav(file=f'{outdir}/pgap2.partition.gene_content.pav')
-    pan_profile, new_clusters = get_rarefaction(
-        basic.pav, outdir, N=1)
-    assert len(
-        pan_profile) == 3, "get_rarefaction did not return the expected number of profiles"
-    assert len(
-        new_clusters) == 2, "get_rarefaction did not return the expected number of clusters"