pycmplot 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

pycmplot/_core.py

@@ -92,6 +92,7 @@ def main() -> None:
     )
     from pycmplot.plotting.linear import plot_linear
     from pycmplot.plotting.circular import plot_circular
+    from pycmplot.plotting.qq import plot_qq_combined, plot_qq_separate, plot_qq_overlay
     from pycmplot.resources import ResourceConfig
 
     # ------------------------------------------------------------------
@@ -110,6 +111,13 @@ def main() -> None:
     labels_raw       = args.labels
     pcol_arg         = args.pval_column
     logp             = args.logp
+    qq               = args.qq_plot
+    qq_separate      = args.qq_separate
+    qq_ncols         = args.qq_ncols
+    qq_thin          = args.qq_thin
+    thin_below       = args.thin_below
+    qq_max_points    = args.qq_max_points
+    qq_overlay       = args.qq_overlay    
     chrom_label_size = args.chrom_label_size
     chrom_label_side = args.chrom_label_side
     track_label_size = args.track_label_size
@@ -164,7 +172,8 @@ def main() -> None:
     # ------------------------------------------------------------------
     (
         plt_name, 
-        table_out 
+        table_out,
+        plt_base, 
     ) = get_output_paths(
         labels,
         mode = mode,
@@ -202,6 +211,7 @@ def main() -> None:
         sumstats_loaded,
         hits_table,
         signif_lines,
+        pval_dict,
     ) = get_sumstats_and_merged_sector_list(
         sum_stats=sum_stats,
         labels=labels,
@@ -296,6 +306,52 @@ def main() -> None:
             figsize=(15, 9)
         )
 
+    # ------------------------------------------------------------------
+    # QQ PLOT
+    # ------------------------------------------------------------------
+    if qq and sumstats_loaded:
+        logger.info("Generating QQ Plot(s) ...")
+        qq_stem = f"{plt_base}_qq"
+ 
+        if qq_separate:
+            plot_qq_separate(
+                pval_dict=pval_dict,
+                thin=qq_thin,
+                thin_below=thin_below,
+                max_points=qq_max_points,                
+                output_path=qq_stem,
+                colors=colors,
+                signif_threshold=signif_threshold or 5e-8,
+                dpi=dpi,
+                fig_format=output_format,
+            )
+        elif qq_overlay:
+            plot_qq_overlay(
+                pval_dict=pval_dict,
+                thin=qq_thin,
+                thin_below=thin_below,
+                max_points=qq_max_points,                
+                colors=colors,
+                signif_threshold=signif_threshold or 5e-8,
+                dpi=dpi,
+                title=plot_title,
+                output_path=f"{qq_stem}_overlay",
+                fig_format=output_format,
+            )
+        else:
+            plot_qq_combined(
+                pval_dict=pval_dict,
+                thin=qq_thin,
+                thin_below=thin_below,
+                max_points=qq_max_points,
+                colors=colors,
+                ncols=qq_ncols,
+                signif_threshold=signif_threshold or 5e-8,
+                dpi=dpi,
+                title=plot_title,
+                output_path=f"{qq_stem}_combined",
+                fig_format=output_format,
+            )
 
 if __name__ == "__main__":
     main()

pycmplot/cli.py

@@ -329,29 +329,50 @@ def get_arguments(descmsg: str = DESCMSG) -> argparse.Namespace:
     )
     opt.add_argument(
         "-bc",   "--build_column",  required=False, type=str, metavar="str",
-        help="Name of column containing genome build (hg18/hg19/hg38). Or use ``--build`` below to supply genome builds per summary stat file."
-    )
+                     help=("Name of column containing genome build (hg18/hg19/hg38)." 
+                         "Or use ``--build`` below to supply genome builds per summary stat file."
+                    ))
     opt.add_argument(
-        "-b","--build",
-        help="""
-        Comma-sperated list of genome build of summary stats file(s) listed in the same order as sumstats files.
-        (e.g. hg19,hg38,hg38,hg19 means: 
-            file1.txt.gz --> hg19
-            file2.txt.gz --> hg38
-            file3.tsv --> hg38 ... etc)
-        """,
-        required=False,
-        type=str,
-        metavar='str'        
+        "-b","--build", required=False, type=str, metavar='str',
+        help=
+        """Comma-sperated list of genome build of summary stats file(s) listed 
+        in the same order as sumstats files. e.g. hg19,hg38,hg38,hg19 means:
+        file1.txt.gz --> hg19
+        file2.txt.gz --> hg38
+        file3.tsv --> hg38 ... etc
+        """
     )
     opt.add_argument(
         "--logp", action="store_true",
         help="Plot −log₁₀(p) instead of raw p-values."
     )
-    opt.add_argument(
-        "-qq", "--qq_plot", action="store_true",
-        help="Also generate a QQ-plot."
-    )
+    opt.add_argument("-qq", "--qq_plot", action="store_true",
+                     help="Generate QQ-plot(s) alongside the Manhattan plot.")
+    opt.add_argument("-qq_sep", "--qq_separate", action="store_true",
+                     help=(
+                         "Save one QQ-plot file per sumstat instead of a "
+                         "combined multi-panel figure. Only used when -qq is set."
+                     ))
+    opt.add_argument("-qq_cols", "--qq_ncols", default=3, type=int, metavar="int",
+                     help="Number of columns in the combined QQ-plot grid (default: 3).")
+    opt.add_argument("-qq_thin", "--qq_thin", action="store_true", default=False,
+                     help=(
+                         "Thin null-like p-values before QQ plotting for speed (default: off)."
+                         "Include this flag to turn on for speed."
+                    ))
+    opt.add_argument("-thin_below", "--thin_below", type=float, metavar="float", default=0.01,
+                     help=(
+                         "P-value threshold below which all points are always kept."
+                         "Points above this threshold are downsampled (default: 0.01)."
+                     ))
+    opt.add_argument("-qq_max_pts", "--qq_max_points", default=50000, type=int, metavar="int",
+                     help="Max points to plot per QQ track after thinning (default: 50000).")
+    opt.add_argument("-qq_ov", "--qq_overlay", action="store_true",
+                     help=(
+                         "Plot all sumstats on a single overlaid QQ-plot, "
+                         "each coloured by label with lambda in the legend. "
+                         "Only used when -qq is set."
+                     ))
     opt.add_argument(
         "-tp", "--trim_pval", type=float, metavar="float",
         help="Trim variants with p > this value before plotting."

pycmplot/io.py

@@ -291,7 +291,9 @@ def strip_comma_separated_input_streams(
 
     if builds:
         builds  = [s.strip() for s in builds.strip().split(",")]
-        if len(sum_stats) != len(labels) != len(builds):
+        if len(sum_stats) == len(labels) == len(builds):
+            pass
+        else:
             sys.exit(
                 "Error: number of summary stats files, labels, and builds must match.\n"
                 f"  Files:  {sum_stats}\n"
@@ -429,16 +431,16 @@ def get_output_paths(
 
     labels = [re.sub(r"[^a-zA-Z0-9\s]", "", x).replace(" ", "_") for x in labels]
 
-    plt_base = str(out_path / f"{pltitle}_{'_'.join(labels)}_{mode.lower()}")
-
     suffix     = "_logp" if logp else "_pval"
 
-    plt_name   = f"{plt_base}{suffix}.{output_format.lower()}"
+    plt_base = str(out_path / f"{pltitle}_{'_'.join(labels)}_{mode.lower()}{suffix}")
+
+    plt_name   = f"{plt_base}.{output_format.lower()}"
     
-    table_out  = f"{plt_base}{suffix}_locus_summary_table.tsv"
+    table_out  = f"{plt_base}_locus_summary_table.tsv"
 
 
-    return plt_name, table_out
+    return plt_name, table_out, plt_base
 
 
 
@@ -561,11 +563,13 @@ def prep_pycmplot_input_info(
     snp_candidates = [c for c in snp_candidates if c]
     pvl_candidates = [c for c in pvl_candidates if c]
 
-    bld_candidates = ["BUILD", "Genome", "Genome_Build", "Genome-build"]
-    bld_candidates_l = [x.lower() for x in bld_candidates]
-    bld_candidates_u = [x.upper() for x in bld_candidates]
-    bld_candidates = [build] + bld_candidates + bld_candidates_l + bld_candidates_u
-    bld_candidates = [c for c in bld_candidates if c]
+    bld_candidates = []
+    if buildc:
+        bld_candidates = ["BUILD", "Genome", "Genome_Build", "Genome-build"]
+        bld_candidates_l = [x.lower() for x in bld_candidates]
+        bld_candidates_u = [x.upper() for x in bld_candidates]
+        bld_candidates = [buildc] + bld_candidates + bld_candidates_l + bld_candidates_u
+        bld_candidates = [c for c in bld_candidates if c]
 
     # ------------------------------------------------------------------
     # Resolve column names per file
@@ -795,6 +799,7 @@ def get_sumstats_and_merged_sector_list(
     }
 
     sumstats_loaded: dict[str, list] = {}
+    pval_dict: dict[str, np.ndarray | pd.Series] = {}
     all_lead_snps: list[pd.DataFrame] = []
 
     for label in sumstats.keys() & (file_info or {}).keys():
@@ -818,6 +823,11 @@ def get_sumstats_and_merged_sector_list(
             dtype=sumstat_dtypes,
         ).rename(columns=sumstat_newcols)
 
+        # Get dict of p-values for qq-plotting before applying trim_pval
+        logger.info("Extracting raw p-values for qq-plotting ...")
+        pval_dict[label] = df["P"].dropna().astype(float).values
+
+
         # Add build column if not exist and build supplied
         if build:
             df['BUILD'] = build
@@ -917,7 +927,13 @@ def get_sumstats_and_merged_sector_list(
         for _ in sumstats
     ]
 
-    # Optionally sort tracks
+
+    # sort dicts by user-supplied order
+    sumstats_loaded = {key: sumstats_loaded[key] for key in labels if key in sumstats_loaded}
+    pval_dict = {key: pval_dict[key] for key in labels if key in pval_dict}
+    
+
+    # or sort by user option
     if sort_tracks is not None:
         if sort_tracks.lower() == "label":
             sumstats_loaded = dict(sorted(sumstats_loaded.items()))
@@ -928,6 +944,7 @@ def get_sumstats_and_merged_sector_list(
                     key=lambda item: (item[0], natsort.natsort_keygen()(item[1][1])),
                 )
             )
+       
 
     # Compute per-sumstat sector sizes (chrom → [min_pos, max_pos])
     assoc_sector_sizes_list: list[dict] = []
@@ -941,7 +958,7 @@ def get_sumstats_and_merged_sector_list(
         for chrom in assoc["CHR"].unique():
             sub = assoc[assoc["CHR"] == chrom]
             lo_val = max(sub["POS"].min() - 1_000_000, 0)
-            hi_val = sub["POS"].max() + 1_000_000
+            hi_val = sub["POS"].max()
             assoc_dic[str(chrom)] = [lo_val, hi_val]
 
         min_dic_val = min(assoc_dic.values())
@@ -955,9 +972,9 @@ def get_sumstats_and_merged_sector_list(
 
     # Add spacer sector for y-axis labelling
     if min_dic_val is not None:
-        if len(labels) <= 5:
-            merged["Spacer1"] = [x + x / 2 for x in min_dic_val]
-        else:
-            merged["Spacer1"] = [x * 2 for x in min_dic_val]
+        #if len(labels) <= 5:
+        #    merged["Spacer1"] = [x + x / 2 for x in min_dic_val]
+        #else:
+        merged["Spacer1"] = [x * 2 for x in min_dic_val]
 
-    return merged, sumstats_loaded, hits_table, signif_lines
+    return merged, sumstats_loaded, hits_table, signif_lines, pval_dict

pycmplot/plotting/circular.py

@@ -380,6 +380,7 @@ def plot_circular(
     annotate: str = None,
     label_col: str = None,
     chrom_label_side: str = 'inside',
+    chrom_label_size: float = 6,
     signif_line: float = 5e-8,
     highlight: bool = False,
     highlight_thresh: float = 5e-8,
@@ -387,7 +388,6 @@ def plot_circular(
     highlight_line: bool = False,
     highlight_line_color: str = 'grey',
     colors: list[str] = ['steelblue', 'grey'],
-    chrom_label_size: float = 6,
     track_label_size: float = 6,
     track_label_orientation: str = 'vertical',
     hits_table: pd.DataFrame = None,
@@ -526,7 +526,8 @@ def plot_circular(
     labels = list(sumstats_loaded.keys())
     (
         plt_name, 
-        table_out
+        table_out,
+        plt_base,
     ) = get_output_paths(
         labels,
         mode='cm', 
@@ -558,14 +559,16 @@ def plot_circular(
     radii_reversed = dict(reversed(list(radii.items())))
 
     inside_loc  = r_min - 3
-    outside_loc = 105
-    chrom_label_loc = outside_loc if chrom_label_side == "outside" else inside_loc
+    outside_loc = r_max + 4
 
     if annotate:
         annot_key = next(iter(radii_reversed))
         annot_r   = radii_reversed.pop(annot_key)
+        outside_loc = max(list(radii_reversed.values())[0]) + 2
         radii_reversed["annot_track_r"] = annot_r
 
+    chrom_label_loc = outside_loc if chrom_label_side == "outside" else inside_loc
+
     for index, (sector_radius, sumstats_key, sumstats_value, signif_dict) in enumerate(
         zip(
             radii_reversed.values(),
@@ -647,7 +650,7 @@ def plot_circular(
                         x=pos,
                         label=str(label),
                         min_r=r_low,
-                        max_r=r_low + 3,
+                        max_r=r_low + 6,
                         label_size=annotation_size,
                         text_kws={
                             "size": "large",
@@ -668,8 +671,9 @@ def plot_circular(
                             r=[sector_min_r, r_low],
                             start=pos,
                             end=pos,
+                            alpha=0.4,
                             color=highlight_line_color,
-                            lw=0.5,
+                            lw=0.4,
                             ls="--",
                         )
 
@@ -709,6 +713,6 @@ def plot_circular(
 
     if plt_name:
         fig.savefig(fname=plt_name.lower(), dpi=dpi)
-        logger.info("Saved circular Manhattan plot: %s", plt_name)
+        logger.info("Saved circular Manhattan plot: %s", plt_name.lower())
 
     return fig

pycmplot/plotting/linear.py

@@ -100,7 +100,7 @@ def _cluster_annotations_by_chr(
     return clusters
 
 
-def _draw_annotation_arrows_2(
+def _draw_annotation_arrows(
     ax,
     annot_df,
     chr_col: str,
@@ -212,7 +212,7 @@ def _draw_annotation_arrows_2(
 
 
 
-def _draw_annotation_arrows(
+def _draw_annotation_arrows_2(
     ax,
     annot_df,
     chr_col: str,
@@ -361,6 +361,118 @@ def _draw_annotation_arrows(
 
         last_xtext = max(x_texts)
 
+
+# Using cumulative distance for anntations and separating clusters
+def _draw_annotation_arrows_3(
+    ax,
+    annot_df,
+    chr_col: str,
+    label_col: str,
+    offsets: dict,
+    chr_max: dict,
+    spread_width: float = 60e6,
+    isolation_threshold: float = 80e6,
+    stack_threshold: float = 10e6,
+    y_text_base: float = 0.55,
+    y_stack_step: float = 0.02,
+    max_rad: float = 0.35,
+    y_tip: float = 0.0,
+) -> None:
+
+    annot_df = annot_df.sort_values(by=[chr_col, "x"], key=natsort_keygen())
+    last_xtext = 0 - spread_width
+
+    for chr_name, df_chr in annot_df.groupby(chr_col, sort=False):
+        df_chr    = df_chr.sort_values("x")
+        chr_start = offsets[chr_name]
+        chr_end   = offsets[chr_name] + chr_max[chr_name]
+        chr_range = chr_end - chr_start
+
+        x_signals = df_chr["x"].values
+        labels    = df_chr[label_col].values
+        n         = len(x_signals)
+
+        # ------------------------------------------------------------------
+        # Compute label x positions (spread or straight)
+        # ------------------------------------------------------------------
+        x_texts = []
+        for k, x_sig in enumerate(x_signals):
+            neighbours = np.delete(x_signals, k)
+            min_dist   = np.min(np.abs(neighbours - x_sig)) if len(neighbours) else np.inf
+
+            if min_dist >= isolation_threshold:
+                x_texts.append(x_sig)          # Tier 1: sit directly above
+            else:
+                x_texts.append(None)            # Tier 2: needs spreading
+
+        spread_indices = [k for k, v in enumerate(x_texts) if v is None]
+        if spread_indices:
+            sw  = spread_width
+            pad = sw / int(str(sw)[:2]) / 2
+            while sw > chr_range and sw > pad:
+                sw -= pad
+
+            sig_start = x_signals[spread_indices[0]]
+            xmin      = sig_start - sw
+            positions = np.arange(xmin, xmin + len(spread_indices) * sw, sw)
+
+            while positions[0] <= last_xtext:
+                positions = positions + sw
+
+            for j, k in enumerate(spread_indices):
+                x_texts[k] = positions[j]
+
+        # ------------------------------------------------------------------
+        # Compute label y positions using cumulative x distance
+        # ------------------------------------------------------------------
+        y_texts = [y_text_base] * n
+
+        for k in range(1, n):
+            cum_dist = abs(x_texts[k] - x_texts[k - 1])
+            if cum_dist <= stack_threshold:
+                # too close to previous label — stack upward adaptively
+                y_texts[k] = y_texts[k - 1] + y_stack_step + (
+                    y_stack_step * (1 - cum_dist / stack_threshold)
+                )
+            else:
+                y_texts[k] = y_text_base     # far enough — reset to baseline
+
+        # ------------------------------------------------------------------
+        # Draw arrows and labels
+        # ------------------------------------------------------------------
+        for x_sig, x_txt, y_txt, label in zip(x_signals, x_texts, y_texts, labels):
+            dx  = x_txt - x_sig
+            rad = np.clip(dx / (spread_width * 2), -max_rad, max_rad)
+
+            arrow = FancyArrowPatch(
+                (x_txt, y_txt),
+                (x_sig, y_tip - 0.05),
+                arrowstyle="-|>",
+                mutation_scale=12,
+                lw=0.6,
+                color="grey",
+                alpha=0.5,
+                connectionstyle=f"arc3,rad={rad}",
+                transform=ax.transData,
+            )
+            ax.add_patch(arrow)
+
+            ax.text(
+                x_txt,
+                y_txt + 0.02,
+                str(label),
+                rotation=45,
+                ha="left",
+                va="bottom",
+                fontsize=10,
+                clip_on=False,
+                color="black",
+                fontstyle="italic",
+                fontweight="regular",
+            )
+
+        last_xtext = max(x_texts)
+
 # ---------------------------------------------------------------------------
 # Public function
 # ---------------------------------------------------------------------------
@@ -647,7 +759,8 @@ def plot_linearm(
     # Annotation track
     # ------------------------------------------------------------------
     if annotate and annot_df is not None:
-        """
+        
+        
         _draw_annotation_arrows(
             ax_annot,
             annot_df,
@@ -657,9 +770,10 @@ def plot_linearm(
             chr_max=chr_max,
             spread_width=60e6,
         )
-        """
+        
 
-        _draw_annotation_arrows(
+        """
+        _draw_annotation_arrows_2(
             ax=ax_annot,
             annot_df=annot_df,
             chr_col=chr_col,
@@ -667,13 +781,31 @@ def plot_linearm(
             offsets=offsets,
             chr_max=chr_max,
             spread_width=60e6,
-            isolation_threshold=80e6,   # above this → straight (Tier 1)
+            isolation_threshold=40e6,   # above this → straight (Tier 1)
             stack_threshold=10e6,       # below this → stack (Tier 3)
             max_tilt=45,                # max angleA departure from vertical
             y_tip=0.0,
             y_text=0.55,
             y_stack_step=0.12,          # vertical gap between stacked labels
         )
+        
+
+        _draw_annotation_arrows_3(
+            ax=ax_annot,
+            annot_df=annot_df,
+            chr_col=chr_col,
+            label_col=label_col,
+            offsets=offsets,
+            chr_max=chr_max,
+            spread_width=60e6,
+            isolation_threshold=80e6,
+            stack_threshold=90e6,
+            y_text_base=0.55,
+            y_stack_step=0.03,
+            max_rad=0.35,
+            y_tip=0.0,
+        )
+        """
 
         ax_annot.set_ylim(0, 1)
         ax_annot.axis("off")
@@ -859,12 +991,11 @@ def plot_linear(
             logger.info("'SNP' column is used for annotation since '%s' column could not be resolved in hits table.", label_col)
             pass         
 
-        logger.info(f"LABEL COL: {label}")
-
     # plot name
     (
         plt_name, 
-        table_out
+        table_out,
+        plt_base,
     ) = get_output_paths(
         labels = t_labels,
         mode='lm', 

pycmplot/plotting/qq.py

@@ -0,0 +1,643 @@
+from __future__ import annotations
+
+"""
+pycmplot.plotting.qq
+====================
+QQ (quantile-quantile) plots for GWAS p-values.
+
+Speed notes
+-----------
+GWAS summary statistics often contain millions of SNPs.  Most of those points
+lie near the null diagonal and are visually redundant.  Two optimisations are
+applied by default:
+
+1. **P-value thinning** (``thin_below`` / ``max_points``):
+   All points above a -log10(p) tail threshold are kept in full; the bulk
+   of null-like points below that threshold are randomly downsampled to at
+   most ``max_points`` total.  Lambda (λ) is always computed on the *full*
+   unfiltered array before thinning, so the statistic is never affected.
+
+2. **Rasterised scatter** (``rasterized=True``):
+   The scatter layer is rendered as a bitmap inside vector formats (PDF/SVG),
+   dramatically reducing file size and save time for large point clouds.
+
+Public functions
+----------------
+thin_pvals          Downsample null-like p-values for fast plotting.
+plot_qq_single      Draw one QQ plot onto a given Axes.
+plot_qq_combined    All QQ plots in a single figure (grid layout).
+plot_qq_separate    One output file per sumstat.
+plot_qq_overlay     All sumstats overlaid on one axes, coloured by label.
+"""
+
+import logging
+import math
+from pathlib import Path
+from typing import Optional
+
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import numpy as np
+import pandas as pd
+from scipy.stats import beta as beta_dist
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Thinning helper
+# ---------------------------------------------------------------------------
+
+def thin_pvals(
+    pvals: np.ndarray,
+    tail_threshold: float = 0.01,
+    max_points: int = 50_000,
+    seed: int = 42,
+) -> tuple[np.ndarray, np.ndarray, int]:
+    """Downsample p-values for faster QQ plotting with no visible breaks.
+ 
+    Rather than splitting into tail / bulk regions with different sampling
+    strategies (which produces a visible seam at the threshold), this function
+    uses a single **log-uniform** thinning pass over all p-values:
+ 
+    1. Sort p-values ascending and convert to −log₁₀ scale.
+    2. Pick ``max_points`` evenly-spaced indices along the −log₁₀ axis.
+       Because −log₁₀ compresses large p-values and expands small ones, this
+       automatically gives dense coverage in the interesting tail and sparse
+       coverage in the null bulk — with no hard boundary.
+ 
+    Parameters
+    ----------
+    pvals:
+        Full array of raw p-values.
+    tail_threshold:
+        Kept for API compatibility; no longer used as a hard split point.
+        All points above −log₁₀(tail_threshold) are always represented because
+        the log-uniform spacing naturally keeps them.
+    max_points:
+        Maximum number of points to return (default 50 000).
+    seed:
+        Unused (kept for API compatibility — log-uniform selection is
+        deterministic).
+ 
+    Returns
+    -------
+    (kept_pvals, kept_ranks, n_full)
+        *kept_pvals*  — thinned p-values in ascending order.
+        *kept_ranks*  — 1-based ranks in the full sorted array.
+        *n_full*      — total SNP count before thinning (for expected quantiles).
+ 
+    Notes
+    -----
+    Lambda (λ) must be computed on the full *pvals* array **before** calling
+    this function — thinning changes the empirical distribution.
+    """
+    pvals = np.asarray(pvals, dtype=float)
+    pvals = pvals[np.isfinite(pvals) & (pvals > 0) & (pvals <= 1)]
+    n_full = len(pvals)
+ 
+    if n_full <= max_points:
+        # Nothing to thin
+        sort_idx = np.argsort(pvals)
+        return pvals[sort_idx], np.arange(1, n_full + 1), n_full
+ 
+    # Sort ascending; full_ranks[i] = i+1
+    pvals_sorted = np.sort(pvals)
+    full_ranks   = np.arange(1, n_full + 1)
+ 
+    # Work in −log10 space so spacing is proportional to visual separation
+    logp = -np.log10(pvals_sorted)          # ascending p → descending logp
+    logp_min = logp[0]                      # smallest logp (bulk end)
+    logp_max = logp[-1]                     # largest logp (tail end)
+ 
+    # Evenly-spaced target positions along the logp axis
+    targets = np.linspace(logp_min, logp_max, max_points)
+ 
+    # For each target, pick the closest actual point (searchsorted on
+    # the reversed array since logp is descending)
+    logp_desc = logp[::-1]                  # descending for searchsorted
+    idx_desc  = np.searchsorted(logp_desc, targets, side="left")
+    idx_desc  = np.clip(idx_desc, 0, n_full - 1)
+ 
+    # Convert back to ascending-p indices and deduplicate
+    idx_asc = (n_full - 1 - idx_desc)
+    idx_asc = np.unique(idx_asc)            # sorted, no duplicates
+ 
+    kept_pvals = pvals_sorted[idx_asc]
+    kept_ranks = full_ranks[idx_asc]
+ 
+    n_kept = len(kept_pvals)
+    logger.debug(
+        "QQ thinning: %d → %d points (%.1f%% retained)",
+        n_full, n_kept, 100 * n_kept / n_full,
+    )
+ 
+    return kept_pvals, kept_ranks, n_full
+
+
+# ---------------------------------------------------------------------------
+# Core array builder
+# ---------------------------------------------------------------------------
+
+def _qq_arrays(
+    pvals: np.ndarray,
+    ranks: Optional[np.ndarray] = None,
+    n_full: Optional[int] = None,
+    ci: float = 0.95,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Return (expected, observed, ci_lower, ci_upper) in −log10 scale.
+
+    Parameters
+    ----------
+    pvals:
+        Sorted (ascending) p-values to plot — may be a thinned subset.
+    ranks:
+        1-based ranks of *pvals* in the full distribution.  If ``None``,
+        assumes *pvals* is the complete set and ranks are 1..n.
+    n_full:
+        Total number of SNPs in the full (pre-thinning) dataset.  Used to
+        compute correct expected quantiles.  Defaults to ``len(pvals)``.
+    ci:
+        Confidence interval level.
+    """
+    pvals = np.asarray(pvals, dtype=float)
+    n = len(pvals)
+
+    if n_full is None:
+        n_full = n
+    if ranks is None:
+        ranks = np.arange(1, n + 1)
+
+    # Expected −log10(p): rank i → expected p = i/(n_full+1)
+    expected = -np.log10(ranks / (n_full + 1))
+
+    # Observed −log10(p): rank i paired with the i-th smallest p-value
+    observed = -np.log10(pvals)
+
+    # CI from the beta distribution (uses original ranks in full dataset)
+    alpha = 1.0 - ci
+    ci_lo = -np.log10(beta_dist.ppf(1 - alpha / 2, ranks, n_full - ranks + 1))
+    ci_hi = -np.log10(beta_dist.ppf(    alpha / 2, ranks, n_full - ranks + 1))
+
+    # Sort by expected ascending for clean polygon fill
+    order = np.argsort(expected)
+    return expected[order], observed[order], ci_lo[order], ci_hi[order]
+
+
+# ---------------------------------------------------------------------------
+# Lambda
+# ---------------------------------------------------------------------------
+
+def _compute_lambda(pvals: np.ndarray) -> float:
+    """Genomic inflation factor λ = median(χ²_obs) / median(χ²_expected)."""
+    from scipy.stats import chi2
+    pvals = pvals[np.isfinite(pvals) & (pvals > 0) & (pvals <= 1)]
+    if len(pvals) == 0:
+        return float("nan")
+    obs_median_chi2 = chi2.ppf(1 - np.median(pvals), df=1)
+    expected_median_chi2 = chi2.ppf(0.5, df=1)   # ≈ 0.4549
+    return round(float(obs_median_chi2 / expected_median_chi2), 4)
+
+
+# ---------------------------------------------------------------------------
+# Single-axis QQ plot
+# ---------------------------------------------------------------------------
+
+def plot_qq_single(
+    pvals: np.ndarray | pd.Series,
+    ax: plt.Axes,
+    label: Optional[str] = None,
+    color: str = "steelblue",
+    point_size: float = 8,
+    ci: float = 0.95,
+    ci_alpha: float = 0.15,
+    signif_threshold: Optional[float] = 5e-8,
+    show_lambda: bool = True,
+    title: Optional[str] = None,
+    # --- speed options ---
+    thin: bool = False,
+    thin_below: float = 0.01,
+    max_points: int = 50_000,
+    rasterized: bool = True,
+) -> plt.Axes:
+    """Draw a single QQ plot onto *ax*.
+
+    Parameters
+    ----------
+    pvals:
+        Array or Series of raw p-values (not −log10).
+    ax:
+        Matplotlib Axes to draw on.
+    label:
+        Legend label for the scatter points.
+    color:
+        Colour for points and CI fill.
+    point_size:
+        Scatter point size.
+    ci:
+        Confidence interval level (default 0.95).
+    ci_alpha:
+        Transparency of the CI band.
+    signif_threshold:
+        If given, draw a horizontal dashed line at −log10(threshold).
+    show_lambda:
+        Annotate the plot with the genomic inflation factor λ.
+    title:
+        Axes title.
+    thin:
+        Enable p-value thinning for speed (default ``True``).
+    thin_below:
+        P-value threshold below which all points are always kept.
+        Points above this threshold are downsampled.
+    max_points:
+        Maximum number of points to plot after thinning (default 50 000).
+    rasterized:
+        Render the scatter as a bitmap inside vector output formats —
+        greatly reduces PDF/SVG file size (default ``True``).
+
+    Returns
+    -------
+    plt.Axes
+    """
+    pvals_full = np.asarray(pvals, dtype=float)
+    pvals_full = pvals_full[np.isfinite(pvals_full) & (pvals_full > 0) & (pvals_full <= 1)]
+
+    # Lambda always on the full array
+    lam = _compute_lambda(pvals_full)
+
+    if thin and len(pvals_full) > max_points:
+        plot_pvals, plot_ranks, n_full = thin_pvals(
+            pvals_full, tail_threshold=thin_below, max_points=max_points
+        )
+    else:
+        plot_pvals = np.sort(pvals_full)
+        plot_ranks = np.arange(1, len(plot_pvals) + 1)
+        n_full = len(plot_pvals)
+
+    expected, observed, ci_lo, ci_hi = _qq_arrays(
+        plot_pvals, ranks=plot_ranks, n_full=n_full, ci=ci
+    )
+
+    # CI band
+    ax.fill_between(
+        expected, ci_lo, ci_hi,
+        color=color, alpha=ci_alpha, linewidth=0,
+        label=f"{int(ci * 100)}% CI",
+    )
+
+    # Diagonal null line
+    max_val = max(expected.max(), observed.max()) * 1.05
+    ax.plot([0, max_val], [0, max_val], color="grey", linewidth=0.8,
+            linestyle="--", zorder=1)
+
+    # Observed points
+    ax.scatter(
+        expected, observed,
+        s=point_size, color=color, alpha=0.85,
+        label=label, zorder=2, edgecolors="none",
+        rasterized=rasterized,
+    )
+
+    '''"""
+    # Significance line
+    if signif_threshold is not None:
+        sig_logp = -np.log10(signif_threshold)
+        ax.axhline(sig_logp, color="red", linewidth=0.7, linestyle="--",
+                   label=f"p={signif_threshold:.0e}")
+    """'''
+
+    # Lambda annotation
+    if show_lambda and not math.isnan(lam):
+        ax.text(
+            0.05, 0.95,
+            f"λ = {lam:.4f}",
+            transform=ax.transAxes,
+            va="top", ha="left",
+            fontsize=9, fontstyle="italic",
+            color="black",
+        )
+
+    ax.set_xlabel("Expected −log₁₀(p)", fontsize=10)
+    ax.set_ylabel("Observed −log₁₀(p)", fontsize=10)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    if title:
+        ax.set_title(title, fontsize=10, pad=6)
+    if label:
+        ax.legend(fontsize=8, frameon=False, loc="lower right")
+
+    return ax
+
+
+# ---------------------------------------------------------------------------
+# Combined multi-panel figure
+# ---------------------------------------------------------------------------
+
+def plot_qq_combined(
+    pval_dict: dict[str, np.ndarray | pd.Series],
+    colors: Optional[list[str]] = None,
+    point_size: float = 8,
+    ci: float = 0.95,
+    signif_threshold: Optional[float] = 5e-8,
+    show_lambda: bool = True,
+    ncols: int = 3,
+    figsize: Optional[tuple] = None,
+    dpi: int = 300,
+    title: Optional[str] = None,
+    output_path: Optional[str] = None,
+    fig_format: str = "png",
+    thin: bool = False,
+    thin_below: float = 0.01,
+    max_points: int = 50_000,
+    rasterized: bool = True,
+) -> tuple[plt.Figure, list[plt.Axes]]:
+    """Plot all QQ plots in a single figure arranged in a grid.
+
+    Parameters
+    ----------
+    pval_dict:
+        Ordered dict of ``{label: p_value_array}``.
+    colors:
+        List of colours, one per track.  Cycles if fewer than tracks.
+    ncols:
+        Number of columns in the subplot grid (default 3).
+    figsize:
+        Figure size.  Auto-calculated from *ncols* and number of tracks
+        if ``None``.
+    output_path:
+        If given, save the figure here.
+    thin, thin_below, max_points, rasterized:
+        See :func:`plot_qq_single`.
+
+    Returns
+    -------
+    (fig, axes)
+    """
+    n = len(pval_dict)
+    if n == 0:
+        raise ValueError("pval_dict is empty.")
+
+    nrows = math.ceil(n / ncols)
+
+    cmap = plt.get_cmap("tab10")
+    colors = [mcolors.to_hex(cmap(i % 10)) for i in range(n)]
+    #if colors is None:
+    #    cmap = plt.get_cmap("tab10")
+    #    colors = [mcolors.to_hex(cmap(i % 10)) for i in range(n)]
+    #elif len(colors) < n:
+    #    colors = [colors[i % len(colors)] for i in range(n)]
+
+    if figsize is None:
+        figsize = (ncols * 4.5, nrows * 4.5)
+
+    fig, axes_grid = plt.subplots(nrows, ncols, figsize=figsize, squeeze=False)
+    axes_flat = axes_grid.flatten()
+
+    for idx, (label, pvals) in enumerate(pval_dict.items()):
+        plot_qq_single(
+            pvals=pvals,
+            ax=axes_flat[idx],
+            label=label,
+            color=colors[idx],
+            point_size=point_size,
+            ci=ci,
+            signif_threshold=signif_threshold,
+            show_lambda=show_lambda,
+            title=label,
+            thin=thin,
+            thin_below=thin_below,
+            max_points=max_points,
+            rasterized=rasterized,
+        )
+
+    for ax in axes_flat[n:]:
+        ax.set_visible(False)
+
+    if title:
+        fig.suptitle(title, fontsize=13, y=1.01)
+
+    plt.tight_layout()
+
+    if output_path:
+        fmt = fig_format or Path(output_path).suffix.lstrip(".") or "png"
+        fig.savefig(f"{output_path}.{fmt}", format=fmt, dpi=dpi, bbox_inches="tight")
+        logger.info("Saved combined QQ plot: %s", f"{output_path}.{fmt}")
+
+    return fig, list(axes_flat[:n])
+
+
+# ---------------------------------------------------------------------------
+# Separate figures — one file per sumstat
+# ---------------------------------------------------------------------------
+
+def plot_qq_separate(
+    pval_dict: dict[str, np.ndarray | pd.Series],
+    output_path: str = ".",
+    colors: Optional[list[str]] = None,
+    point_size: float = 8,
+    ci: float = 0.95,
+    signif_threshold: Optional[float] = 5e-8,
+    show_lambda: bool = True,
+    figsize: tuple = (5, 5),
+    dpi: int = 300,
+    fig_format: str = "png",
+    thin: bool = False,
+    thin_below: float = 0.01,
+    max_points: int = 50_000,
+    rasterized: bool = True,
+) -> list[str]:
+    """Save one QQ plot per sumstat as individual files.
+
+    Parameters
+    ----------
+    pval_dict:
+        Ordered dict of ``{label: p_value_array}``.
+    output_dir:
+        Directory to save files in.
+    file_stem:
+        Prefix for output filenames.
+    colors:
+        List of colours, one per track.
+    thin, thin_below, max_points, rasterized:
+        See :func:`plot_qq_single`.
+
+    Returns
+    -------
+    List of output file paths.
+    """
+
+    n = len(pval_dict)
+
+    cmap = plt.get_cmap("tab10")
+    colors = [mcolors.to_hex(cmap(i % 10)) for i in range(n)]
+    #if colors is None:
+    #    cmap = plt.get_cmap("tab10")
+    #    colors = [mcolors.to_hex(cmap(i % 10)) for i in range(n)]
+    #elif len(colors) < n:
+    #    colors = [colors[i % len(colors)] for i in range(n)]
+
+    saved: list[str] = []
+
+    for idx, (label, pvals) in enumerate(pval_dict.items()):
+        fig, ax = plt.subplots(figsize=figsize)
+
+        plot_qq_single(
+            pvals=pvals,
+            ax=ax,
+            label=label,
+            color=colors[idx],
+            point_size=point_size,
+            ci=ci,
+            signif_threshold=signif_threshold,
+            show_lambda=show_lambda,
+            title=label,
+            thin=thin,
+            thin_below=thin_below,
+            max_points=max_points,
+            rasterized=rasterized,
+        )
+
+        plt.tight_layout()
+
+        safe_label = label.replace(" ", "_").replace("/", "-")
+        out_path = f"{output_path}_{safe_label}.{fig_format}"
+        fig.savefig(out_path, format=fig_format, dpi=dpi, bbox_inches="tight")
+        plt.close(fig)
+        logger.info("Saved QQ plot: %s", out_path)
+        saved.append(out_path)
+
+    return saved
+
+
+# ---------------------------------------------------------------------------
+# Overlay — all sumstats on one axes
+# ---------------------------------------------------------------------------
+
+def plot_qq_overlay(
+    pval_dict: dict[str, np.ndarray | pd.Series],
+    colors: Optional[list[str]] = None,
+    point_size: float = 8,
+    ci: float = 0.95,
+    ci_alpha: float = 0.10,
+    signif_threshold: Optional[float] = 5e-8,
+    show_lambda: bool = True,
+    figsize: tuple = (6, 6),
+    dpi: int = 300,
+    title: Optional[str] = None,
+    output_path: Optional[str] = None,
+    fig_format: str = "png",
+    thin: bool = False,
+    thin_below: float = 0.01,
+    max_points: int = 50_000,
+    rasterized: bool = True,
+) -> tuple[plt.Figure, plt.Axes]:
+    """Plot all sumstats on a single QQ axes, each coloured differently.
+
+    Lambda (λ) values appear in the legend label for each sumstat.
+
+    Parameters
+    ----------
+    pval_dict:
+        Ordered dict of ``{label: p_value_array}``.
+    colors:
+        List of colours, one per sumstat.  Defaults to ``tab10`` palette.
+    ci_alpha:
+        Transparency of CI bands (default 0.10 — lower than single-panel
+        default to keep overlapping bands readable).
+    show_lambda:
+        Append λ to each legend entry.
+    thin, thin_below, max_points, rasterized:
+        See :func:`plot_qq_single`.
+
+    Returns
+    -------
+    (fig, ax)
+    """
+    n = len(pval_dict)
+    if n == 0:
+        raise ValueError("pval_dict is empty.")
+
+
+    cmap = plt.get_cmap("tab10")
+    colors = [mcolors.to_hex(cmap(i % 10)) for i in range(n)]
+    #if colors is None:
+    #    cmap = plt.get_cmap("tab10")
+    #    colors = [mcolors.to_hex(cmap(i % 10)) for i in range(n)]
+    #elif len(colors) < n:
+    #    colors = [colors[i % len(colors)] for i in range(n)]
+
+    fig, ax = plt.subplots(figsize=figsize)
+    global_max = 0.0
+
+    for idx, (label, pvals) in enumerate(pval_dict.items()):
+        pvals_full = np.asarray(pvals, dtype=float)
+        pvals_full = pvals_full[np.isfinite(pvals_full) & (pvals_full > 0) & (pvals_full <= 1)]
+
+        # Lambda on full array before any thinning
+        lam = _compute_lambda(pvals_full)
+
+        if thin and len(pvals_full) > max_points:
+            plot_pvals, plot_ranks, n_full = thin_pvals(
+                pvals_full, tail_threshold=thin_below, max_points=max_points
+            )
+        else:
+            plot_pvals = np.sort(pvals_full)
+            plot_ranks = np.arange(1, len(plot_pvals) + 1)
+            n_full = len(plot_pvals)
+
+        expected, observed, ci_lo, ci_hi = _qq_arrays(
+            plot_pvals, ranks=plot_ranks, n_full=n_full, ci=ci
+        )
+
+        color = colors[idx]
+        legend_label = f"{label}  (λ={lam:.4f})" if show_lambda else label
+
+        ax.fill_between(
+            expected, ci_lo, ci_hi,
+            color=color, alpha=ci_alpha, linewidth=0,
+        )
+        ax.scatter(
+            expected, observed,
+            s=point_size, color=color, alpha=0.85,
+            label=legend_label, zorder=2 + idx, edgecolors="none",
+            rasterized=rasterized,
+        )
+
+        global_max = max(global_max, expected.max(), observed.max())
+
+    ax.plot(
+        [0, global_max * 1.05], [0, global_max * 1.05],
+        color="grey", linewidth=0.8, linestyle="--", zorder=1,
+    )
+
+    '''"""
+    if signif_threshold is not None:
+        ax.axhline(
+            -np.log10(signif_threshold),
+            color="red", linewidth=0.7, linestyle="--",
+            label=f"p = {signif_threshold:.0e}",
+        )
+    """'''
+
+    ax.set_xlabel("Expected −log₁₀(p)", fontsize=11)
+    ax.set_ylabel("Observed −log₁₀(p)", fontsize=11)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+    ax.legend(
+        fontsize=8, frameon=True, framealpha=0.7,
+        edgecolor="lightgrey", loc="lower right",
+    )
+
+    if title:
+        ax.set_title(title, fontsize=11, pad=8)
+
+    plt.tight_layout()
+
+    if output_path:
+        fmt = fig_format or Path(output_path).suffix.lstrip(".") or "png"
+        fig.savefig(f"{output_path}.{fmt}", format=fmt, dpi=dpi, bbox_inches="tight")
+        logger.info("Saved combined QQ plot: %s", f"{output_path}.{fmt}")
+
+    return fig, ax

{pycmplot-0.2.1.dist-info → pycmplot-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycmplot
-Version: 0.2.1
+Version: 0.2.2
 Summary: Multi-track circular and linear Manhattan plot generation for GWAS summary statistics
 Author: Kevin Esoh
 Author-email: Kevin Esoh <kesohku1@jh.edu>
@@ -183,7 +183,8 @@ pycmplot \
 | `-b, --build` | Comma-separated genome builds of sumstats  | off |
 | `-bc, --build_column` | Genome build column name (containing hg18/hg19/hg38) | off |
 | `-m, --mode` | `lm` linear or `cm` circular | `lm` |
-| `-qq, --qq_plot` | Also generate a QQ-plot | off (coming soon...) |
+| `-qq, --qq_plot` | Also generate a QQ-plot | off |
+| `-qq_thin, --qq_thin` | Thin p-values for faster QQ-plotting | off |
 | `--logp` | Plot -log10(p) | off |
 | `-sig, --signif_threshold` | Genome-wide significance threshold | off (auto 0.05/N) |
 | `-sigl, --signif_line` | Value for genome-wide significance line if different from `-sig` | 5e-8 |

{pycmplot-0.2.1.dist-info → pycmplot-0.2.2.dist-info}/RECORD

@@ -1,21 +1,22 @@
 pycmplot/__init__.py,sha256=fGBHi1vh_9_eu2Xks5B5tPk51RZxji5s-khGhSTNQCI,1288
-pycmplot/_core.py,sha256=Jn47lbtrCoE8nBkQ2HEScdKyT0E98b4pgRtgfleMA4k,10965
+pycmplot/_core.py,sha256=H8Ab0db5cV9wbkuq8Nq9xjTqwRkra5ook6xu6A-N-ys,13021
 pycmplot/annotation.py,sha256=gMgDfnHmMYpkLuQIaJNHmtXVHHIeSUAcviLrisF2vmY,20886
-pycmplot/cli.py,sha256=CAOt1vzwLdKY_RnpbQ9oHVuyTeWxlkiPlClG_u6Cz9U,17807
+pycmplot/cli.py,sha256=k6uBR5V0Y89VSzq-GHZxfR0XmBGS6aEUt66fqYEmQ40,19430
 pycmplot/constants.py,sha256=XaT3pTWM3dkawU1cA0HFpaNnUupSjv28wpPgmnVEjL0,3431
-pycmplot/io.py,sha256=zPVSdtXk99TUzJ01BpzRlE5PRTLIGdwpC12NBZBh0dc,34724
+pycmplot/io.py,sha256=hWM4x_euyYUZ3gzFaP9tkZYHi_1fj8XE1wE9f5XOdbE,35301
 pycmplot/liftover.py,sha256=ZawfO9ZKZADFwyXZBnbrovh4TnV-ja1qHHnIgtxSCBM,6942
 pycmplot/resources.py,sha256=r0zHy_-9wu98lkqKENYrptX54uO6np_x94_ju3v2KYE,6414
 pycmplot/stats.py,sha256=8TXHxfGc4sUr3rE3cHnS2mXfIS1PPj0YgDk1C-z2Pqk,5813
 pycmplot/data/Homo_sapiens.GRCh37.geneinfo.tsv.gz,sha256=kLldtgT5-k4ZzU5jN--woFZEuOaWe9pQ4g4hhB3sdQI,840666
 pycmplot/data/Homo_sapiens.GRCh38.geneinfo.tsv.gz,sha256=cRAuNxifZi12yOxNKrVt0uTS52HwDDFzV_1N4E2Qwuw,626249
 pycmplot/data/hg19ToHg38.over.chain,sha256=oHPYkUIztVQtKXYauOxLOBUFKxOWSRnBKh77LjEfvzk,606773
-pycmplot/plotting/circular.py,sha256=Tp08RySuXH6mowM7UWH7l9mzAHN_-F12WFn_69r4sYk,27158
-pycmplot/plotting/linear.py,sha256=rGqQtFEp6NPWnnFFwT7zL7n1uIkQRbZdijzW6vBRodg,32941
-pycmplot-0.2.1.dist-info/licenses/LICENSE,sha256=7HtJWU-I9Tayt7xnvHU0D6oVqeTp3hMqCbTxbkYBTZQ,20904
+pycmplot/plotting/circular.py,sha256=Xa_2GDW7lLKb8PeN_IL3_hvfkQaqcbQ68Q5QrxjCKs4,27295
+pycmplot/plotting/linear.py,sha256=lrioORKyOaz34UAOhBWg3W2kLq6nBT7HNkPxy8hX340,37416
+pycmplot/plotting/qq.py,sha256=ylPJj9gMlDqTOR7JWnQ7wCfvEBUczqEUVMsFiXXEt3s,20883
+pycmplot-0.2.2.dist-info/licenses/LICENSE,sha256=7HtJWU-I9Tayt7xnvHU0D6oVqeTp3hMqCbTxbkYBTZQ,20904
 pycmplot_docs/docs/conf.py,sha256=gUt_OitflxpaOrIjeP2aYJ_LCWqTRRdmo_HIcVVf3hI,2992
-pycmplot-0.2.1.dist-info/METADATA,sha256=H_KRLR0x6ZeJ3OTUlwgeIpOwkj_m-w2SlyrmbKcFYTo,8054
-pycmplot-0.2.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-pycmplot-0.2.1.dist-info/entry_points.txt,sha256=cE8IAltA_Q-QQuWQ5DE3Lv-9ktYQ_jyWaD6I97QbeyU,49
-pycmplot-0.2.1.dist-info/top_level.txt,sha256=gxbPirasq6TczoykxC2gfk5_En7R65BN-J5ADiV5i3c,23
-pycmplot-0.2.1.dist-info/RECORD,,
+pycmplot-0.2.2.dist-info/METADATA,sha256=9qN2xJp3CGcTp8kxjfmzAz7AhfJVPmk60jTqJ8sxeqI,8108
+pycmplot-0.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pycmplot-0.2.2.dist-info/entry_points.txt,sha256=cE8IAltA_Q-QQuWQ5DE3Lv-9ktYQ_jyWaD6I97QbeyU,49
+pycmplot-0.2.2.dist-info/top_level.txt,sha256=gxbPirasq6TczoykxC2gfk5_En7R65BN-J5ADiV5i3c,23
+pycmplot-0.2.2.dist-info/RECORD,,