pylocuszoom 0.8.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

pylocuszoom/__init__.py

@@ -51,6 +51,8 @@ from .colors import (
     get_phewas_category_palette,
 )
 
+# Configuration classes (internal - use kwargs directly on plot()/plot_stacked())
+# from .config import PlotConfig, StackedPlotConfig  # Internal use only
 # Ensembl integration
 from .ensembl import (
     clear_ensembl_cache,
@@ -62,7 +64,6 @@ from .ensembl import (
 
 # eQTL support
 from .eqtl import (
-    EQTLValidationError,
     calculate_colocalization_overlap,
     filter_eqtl_by_gene,
     filter_eqtl_by_region,
@@ -71,9 +72,19 @@ from .eqtl import (
     validate_eqtl_df,
 )
 
+# Exception hierarchy
+from .exceptions import (
+    BackendError,
+    DataDownloadError,
+    EQTLValidationError,
+    FinemappingValidationError,
+    LoaderValidationError,
+    PyLocusZoomError,
+    ValidationError,
+)
+
 # Fine-mapping/SuSiE support
 from .finemapping import (
-    FinemappingValidationError,
     filter_by_credible_set,
     filter_finemapping_by_region,
     get_credible_sets,
@@ -134,11 +145,8 @@ from .recombination import (
     load_recombination_map,
 )
 
-# Schema validation
-from .schemas import LoaderValidationError
-
 # Validation utilities
-from .utils import ValidationError, to_pandas
+from .utils import to_pandas
 
 __all__ = [
     # Core
@@ -187,8 +195,12 @@ __all__ = [
     # Logging
     "enable_logging",
     "disable_logging",
-    # Validation & Utils
+    # Exceptions
+    "PyLocusZoomError",
     "ValidationError",
+    "BackendError",
+    "DataDownloadError",
+    # Utils
     "to_pandas",
     # PheWAS
     "validate_phewas_df",

pylocuszoom/config.py

@@ -0,0 +1,365 @@
+"""Pydantic configuration classes for pyLocusZoom plot methods.
+
+This module provides typed, validated configuration objects that replace
+the parameter explosion in plot methods. Each config is immutable (frozen)
+to prevent accidental modification.
+
+Example:
+    >>> from pylocuszoom.config import RegionConfig, DisplayConfig, PlotConfig
+    >>> region = RegionConfig(chrom=1, start=1000000, end=2000000)
+    >>> display = DisplayConfig(snp_labels=False, label_top_n=3)
+    >>>
+    >>> # Using composite PlotConfig with factory method
+    >>> config = PlotConfig.from_kwargs(chrom=1, start=1000000, end=2000000)
+"""
+
+from typing import List, Optional, Tuple
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class RegionConfig(BaseModel):
+    """Genomic region specification.
+
+    Attributes:
+        chrom: Chromosome number (must be >= 1).
+        start: Start position in base pairs (must be >= 0).
+        end: End position in base pairs (must be > start).
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    chrom: int = Field(..., ge=1, description="Chromosome number")
+    start: int = Field(..., ge=0, description="Start position (bp)")
+    end: int = Field(..., gt=0, description="End position (bp)")
+
+    @model_validator(mode="after")
+    def validate_region(self) -> "RegionConfig":
+        """Validate that start < end."""
+        if self.start >= self.end:
+            raise ValueError(f"start ({self.start}) must be < end ({self.end})")
+        return self
+
+
+class ColumnConfig(BaseModel):
+    """DataFrame column name mappings for GWAS data.
+
+    Attributes:
+        pos_col: Column name for genomic position.
+        p_col: Column name for p-value.
+        rs_col: Column name for SNP identifier.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    pos_col: str = Field(default="ps", description="Position column name")
+    p_col: str = Field(default="p_wald", description="P-value column name")
+    rs_col: str = Field(default="rs", description="SNP ID column name")
+
+
+class DisplayConfig(BaseModel):
+    """Display and visual options for plots.
+
+    Attributes:
+        snp_labels: Whether to show SNP labels on plot.
+        label_top_n: Number of top SNPs to label.
+        show_recombination: Whether to show recombination rate overlay.
+        figsize: Figure size as (width, height) in inches.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    snp_labels: bool = Field(default=True, description="Show SNP labels")
+    label_top_n: int = Field(default=5, ge=0, description="Number of top SNPs to label")
+    show_recombination: bool = Field(
+        default=True, description="Show recombination overlay"
+    )
+    figsize: Tuple[float, float] = Field(
+        default=(12.0, 8.0), description="Figure size (width, height)"
+    )
+
+
+class LDConfig(BaseModel):
+    """Linkage disequilibrium configuration.
+
+    Supports three modes:
+    1. No LD coloring: All fields None (default)
+    2. Pre-computed LD: Provide ld_col for column with R^2 values
+    3. Calculate LD: Provide lead_pos and ld_reference_file
+
+    Attributes:
+        lead_pos: Position of lead/index SNP to highlight.
+        ld_reference_file: Path to PLINK binary fileset for LD calculation.
+        ld_col: Column name for pre-computed LD (R^2) values.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    lead_pos: Optional[int] = Field(default=None, ge=1, description="Lead SNP position")
+    ld_reference_file: Optional[str] = Field(
+        default=None, description="PLINK binary fileset path"
+    )
+    ld_col: Optional[str] = Field(
+        default=None, description="Pre-computed LD column name"
+    )
+
+    @model_validator(mode="after")
+    def validate_ld_config(self) -> "LDConfig":
+        """Validate LD configuration consistency.
+
+        When ld_reference_file is provided, lead_pos is required to identify
+        the index SNP for LD calculation.
+
+        Note: For StackedPlotConfig, ld_reference_file may be provided without
+        lead_pos when lead_positions list is used (broadcast mode). This is
+        validated at the StackedPlotConfig level, not here.
+        """
+        # Validation moved to StackedPlotConfig.validate_broadcast_ld
+        # to allow broadcast mode where lead_positions list is used instead
+        return self
+
+
+class PlotConfig(BaseModel):
+    """Composite configuration for plot() method.
+
+    Composes all sub-configs into a single validated configuration object.
+    Use either direct construction with nested configs, or the from_kwargs()
+    factory method for backward compatibility with existing code.
+
+    Attributes:
+        region: Genomic region specification (required).
+        columns: DataFrame column name mappings.
+        display: Display and visual options.
+        ld: Linkage disequilibrium configuration.
+
+    Example:
+        >>> # Direct construction
+        >>> config = PlotConfig(
+        ...     region=RegionConfig(chrom=1, start=1000000, end=2000000),
+        ...     display=DisplayConfig(snp_labels=False),
+        ... )
+        >>>
+        >>> # Factory method (backward compatible with plot() signature)
+        >>> config = PlotConfig.from_kwargs(
+        ...     chrom=1, start=1000000, end=2000000,
+        ...     snp_labels=False, lead_pos=1500000,
+        ... )
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    region: RegionConfig
+    columns: ColumnConfig = Field(default_factory=ColumnConfig)
+    display: DisplayConfig = Field(default_factory=DisplayConfig)
+    ld: LDConfig = Field(default_factory=LDConfig)
+
+    @model_validator(mode="after")
+    def validate_ld_requires_lead_pos(self) -> "PlotConfig":
+        """Validate that LD reference file has lead_pos for single plots."""
+        if self.ld.ld_reference_file is not None and self.ld.lead_pos is None:
+            raise ValueError("lead_pos is required when ld_reference_file is provided")
+        return self
+
+    @classmethod
+    def from_kwargs(
+        cls,
+        *,
+        # Region params (required)
+        chrom: int,
+        start: int,
+        end: int,
+        # Column params
+        pos_col: str = "ps",
+        p_col: str = "p_wald",
+        rs_col: str = "rs",
+        # Display params
+        snp_labels: bool = True,
+        label_top_n: int = 5,
+        show_recombination: bool = True,
+        figsize: Tuple[float, float] = (12.0, 8.0),
+        # LD params
+        lead_pos: Optional[int] = None,
+        ld_reference_file: Optional[str] = None,
+        ld_col: Optional[str] = None,
+    ) -> "PlotConfig":
+        """Create PlotConfig from flat keyword arguments.
+
+        Factory method that accepts parameters matching the plot() method
+        signature, enabling backward compatibility with existing code.
+
+        Args:
+            chrom: Chromosome number.
+            start: Start position (bp).
+            end: End position (bp).
+            pos_col: Column name for position.
+            p_col: Column name for p-value.
+            rs_col: Column name for SNP ID.
+            snp_labels: Whether to show SNP labels.
+            label_top_n: Number of top SNPs to label.
+            show_recombination: Whether to show recombination overlay.
+            figsize: Figure size (width, height).
+            lead_pos: Position of lead SNP.
+            ld_reference_file: PLINK binary fileset path.
+            ld_col: Pre-computed LD column name.
+
+        Returns:
+            PlotConfig with nested config objects.
+
+        Raises:
+            ValidationError: If parameters are invalid.
+        """
+        return cls(
+            region=RegionConfig(chrom=chrom, start=start, end=end),
+            columns=ColumnConfig(pos_col=pos_col, p_col=p_col, rs_col=rs_col),
+            display=DisplayConfig(
+                snp_labels=snp_labels,
+                label_top_n=label_top_n,
+                show_recombination=show_recombination,
+                figsize=figsize,
+            ),
+            ld=LDConfig(
+                lead_pos=lead_pos,
+                ld_reference_file=ld_reference_file,
+                ld_col=ld_col,
+            ),
+        )
+
+
+class StackedPlotConfig(BaseModel):
+    """Composite configuration for plot_stacked() method.
+
+    Extends PlotConfig pattern with list-based parameters for stacked plots.
+    Supports multiple lead positions, panel labels, and LD reference files.
+
+    Attributes:
+        region: Genomic region specification (required).
+        columns: DataFrame column name mappings.
+        display: Display and visual options.
+        ld: Linkage disequilibrium configuration (single file for broadcast).
+        lead_positions: List of lead SNP positions (one per panel).
+        panel_labels: List of panel labels (one per panel).
+        ld_reference_files: List of PLINK filesets (one per panel).
+
+    Example:
+        >>> config = StackedPlotConfig.from_kwargs(
+        ...     chrom=1, start=1000000, end=2000000,
+        ...     lead_positions=[1500000, 1600000],
+        ...     panel_labels=["Study A", "Study B"],
+        ... )
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    region: RegionConfig
+    columns: ColumnConfig = Field(default_factory=ColumnConfig)
+    display: DisplayConfig = Field(default_factory=DisplayConfig)
+    ld: LDConfig = Field(default_factory=LDConfig)
+
+    # Stacked-specific list parameters
+    lead_positions: Optional[List[int]] = Field(
+        default=None, description="Lead SNP positions (one per panel)"
+    )
+    panel_labels: Optional[List[str]] = Field(
+        default=None, description="Panel labels (one per panel)"
+    )
+    ld_reference_files: Optional[List[str]] = Field(
+        default=None, description="PLINK filesets (one per panel)"
+    )
+
+    @model_validator(mode="after")
+    def validate_broadcast_ld(self) -> "StackedPlotConfig":
+        """Validate broadcast LD configuration for stacked plots.
+
+        When ld_reference_file is provided for broadcast, lead_positions must
+        be provided to specify the reference SNP for each panel.
+        """
+        if self.ld.ld_reference_file is not None and self.ld.lead_pos is None:
+            # Broadcast mode: ld_reference_file without lead_pos in LDConfig
+            # Requires lead_positions list instead
+            if self.lead_positions is None:
+                raise ValueError(
+                    "lead_positions is required when ld_reference_file is provided "
+                    "for broadcast (one lead position per panel)"
+                )
+        return self
+
+    @classmethod
+    def from_kwargs(
+        cls,
+        *,
+        # Region params (required)
+        chrom: int,
+        start: int,
+        end: int,
+        # Column params
+        pos_col: str = "ps",
+        p_col: str = "p_wald",
+        rs_col: str = "rs",
+        # Display params
+        snp_labels: bool = True,
+        label_top_n: int = 3,  # Default for stacked is 3 (less crowded)
+        show_recombination: bool = True,
+        figsize: Tuple[float, float] = (12.0, 8.0),
+        # LD params (single for broadcast)
+        ld_reference_file: Optional[str] = None,
+        ld_col: Optional[str] = None,
+        # Stacked-specific list params
+        lead_positions: Optional[List[int]] = None,
+        panel_labels: Optional[List[str]] = None,
+        ld_reference_files: Optional[List[str]] = None,
+    ) -> "StackedPlotConfig":
+        """Create StackedPlotConfig from flat keyword arguments.
+
+        Factory method that accepts parameters matching the plot_stacked()
+        method signature, enabling backward compatibility.
+
+        Args:
+            chrom: Chromosome number.
+            start: Start position (bp).
+            end: End position (bp).
+            pos_col: Column name for position.
+            p_col: Column name for p-value.
+            rs_col: Column name for SNP ID.
+            snp_labels: Whether to show SNP labels.
+            label_top_n: Number of top SNPs to label (default 3 for stacked).
+            show_recombination: Whether to show recombination overlay.
+            figsize: Figure size (width, height).
+            ld_reference_file: Single PLINK fileset (broadcast to all panels).
+            ld_col: Pre-computed LD column name.
+            lead_positions: List of lead SNP positions.
+            panel_labels: List of panel labels.
+            ld_reference_files: List of PLINK filesets.
+
+        Returns:
+            StackedPlotConfig with nested config objects.
+
+        Raises:
+            ValidationError: If parameters are invalid.
+        """
+        return cls(
+            region=RegionConfig(chrom=chrom, start=start, end=end),
+            columns=ColumnConfig(pos_col=pos_col, p_col=p_col, rs_col=rs_col),
+            display=DisplayConfig(
+                snp_labels=snp_labels,
+                label_top_n=label_top_n,
+                show_recombination=show_recombination,
+                figsize=figsize,
+            ),
+            ld=LDConfig(
+                ld_reference_file=ld_reference_file,
+                ld_col=ld_col,
+            ),
+            lead_positions=lead_positions,
+            panel_labels=panel_labels,
+            ld_reference_files=ld_reference_files,
+        )
+
+
+__all__ = [
+    "RegionConfig",
+    "ColumnConfig",
+    "DisplayConfig",
+    "LDConfig",
+    "PlotConfig",
+    "StackedPlotConfig",
+]

pylocuszoom/eqtl.py

@@ -9,20 +9,15 @@ from typing import List, Optional
 import numpy as np
 import pandas as pd
 
+from .exceptions import EQTLValidationError, ValidationError
 from .logging import logger
-from .utils import ValidationError, filter_by_region
+from .utils import filter_by_region
 from .validation import DataFrameValidator
 
 REQUIRED_EQTL_COLS = ["pos", "p_value"]
 OPTIONAL_EQTL_COLS = ["gene", "effect_size", "rs", "se"]
 
 
-class EQTLValidationError(ValueError):
-    """Raised when eQTL DataFrame validation fails."""
-
-    pass
-
-
 def validate_eqtl_df(
     df: pd.DataFrame,
     pos_col: str = "pos",
@@ -42,6 +37,7 @@ def validate_eqtl_df(
         (
             DataFrameValidator(df, "eQTL DataFrame")
             .require_columns([pos_col, p_col])
+            .require_numeric([p_col])
             .validate()
         )
     except ValidationError as e:

pylocuszoom/exceptions.py

@@ -0,0 +1,33 @@
+"""Exception hierarchy for pyLocusZoom.
+
+All pyLocusZoom exceptions inherit from PyLocusZoomError, enabling users to
+catch all library errors with `except PyLocusZoomError`.
+"""
+
+
+class PyLocusZoomError(Exception):
+    """Base exception for all pyLocusZoom errors."""
+
+
+class ValidationError(PyLocusZoomError, ValueError):
+    """Raised when input validation fails. Inherits ValueError for backward compat."""
+
+
+class EQTLValidationError(ValidationError):
+    """Raised when eQTL DataFrame validation fails."""
+
+
+class FinemappingValidationError(ValidationError):
+    """Raised when fine-mapping DataFrame validation fails."""
+
+
+class LoaderValidationError(ValidationError):
+    """Raised when loaded data fails validation."""
+
+
+class BackendError(PyLocusZoomError):
+    """Raised when backend operations fail."""
+
+
+class DataDownloadError(PyLocusZoomError, RuntimeError):
+    """Raised when data download operations fail."""

pylocuszoom/finemapping.py

@@ -8,8 +8,9 @@ from typing import List, Optional
 
 import pandas as pd
 
+from .exceptions import FinemappingValidationError, ValidationError
 from .logging import logger
-from .utils import ValidationError, filter_by_region
+from .utils import filter_by_region
 from .validation import DataFrameValidator
 
 # Required columns for fine-mapping data
@@ -17,12 +18,6 @@ REQUIRED_FINEMAPPING_COLS = ["pos", "pip"]
 OPTIONAL_FINEMAPPING_COLS = ["rs", "cs", "cs_id", "effect", "se"]
 
 
-class FinemappingValidationError(ValueError):
-    """Raised when fine-mapping DataFrame validation fails."""
-
-    pass
-
-
 def validate_finemapping_df(
     df: pd.DataFrame,
     pos_col: str = "pos",

pylocuszoom/forest.py

@@ -31,5 +31,6 @@ def validate_forest_df(
         DataFrameValidator(df, "Forest plot DataFrame")
         .require_columns([study_col, effect_col, ci_lower_col, ci_upper_col])
         .require_numeric([effect_col, ci_lower_col, ci_upper_col])
+        .require_ci_ordering(ci_lower_col, effect_col, ci_upper_col)
         .validate()
     )

pylocuszoom/gene_track.py

@@ -48,22 +48,23 @@ def assign_gene_positions(genes_df: pd.DataFrame, start: int, end: int) -> List[
         List of integer row indices (0, 1, 2, ...) for each gene.
     """
     positions = []
-    occupied = []  # List of (end_pos, row)
+    # Track the rightmost end position for each row (including label buffer)
+    row_ends: dict[int, int] = {}  # row -> rightmost end position
     region_width = end - start
+    label_buffer = region_width * 0.08  # Extra space for labels
 
     for _, gene in genes_df.iterrows():
         gene_start = max(gene["start"], start)
         gene_end = min(gene["end"], end)
 
-        # Find first available row with buffer for label spacing
+        # Find first available row where gene doesn't overlap
         row = 0
-        label_buffer = region_width * 0.08  # Extra space for labels
-        for occ_end, occ_row in occupied:
-            if occ_row == row and occ_end > gene_start - label_buffer:
-                row = occ_row + 1
+        while row in row_ends and row_ends[row] > gene_start - label_buffer:
+            row += 1
 
         positions.append(row)
-        occupied.append((gene_end, row))
+        # Update the row's end position (including buffer for next gene check)
+        row_ends[row] = gene_end
 
     return positions
 

pylocuszoom/plotter.py

@@ -15,6 +15,7 @@ from typing import Any, List, Optional, Tuple
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
+import requests
 
 from .backends import BackendType, get_backend
 from .backends.hover import HoverConfig, HoverDataBuilder
@@ -30,6 +31,7 @@ from .colors import (
     get_ld_color_palette,
     get_phewas_category_palette,
 )
+from .config import PlotConfig, StackedPlotConfig
 from .ensembl import get_genes_for_region
 from .eqtl import validate_eqtl_df
 from .finemapping import (
@@ -171,9 +173,17 @@ class LocusZoomPlotter:
             # Download
             try:
                 return download_canine_recombination_maps()
-            except Exception as e:
+            except (requests.RequestException, OSError, IOError) as e:
+                # Expected network/file errors - graceful fallback
                 logger.warning(f"Could not download recombination maps: {e}")
                 return None
+            except Exception as e:
+                # JUSTIFICATION: Download failure should not prevent plotting.
+                # We catch broadly here because graceful degradation is acceptable
+                # for optional recombination map downloads. Error-level logging
+                # ensures the issue is visible.
+                logger.error(f"Unexpected error downloading recombination maps: {e}")
+                return None
         elif self.recomb_data_dir:
             return Path(self.recomb_data_dir)
         return None
@@ -207,53 +217,76 @@ class LocusZoomPlotter:
     def plot(
         self,
         gwas_df: pd.DataFrame,
+        *,
         chrom: int,
         start: int,
         end: int,
+        pos_col: str = "ps",
+        p_col: str = "p_wald",
+        rs_col: str = "rs",
+        snp_labels: bool = True,
+        label_top_n: int = 5,
+        show_recombination: bool = True,
+        figsize: Tuple[float, float] = (12.0, 8.0),
         lead_pos: Optional[int] = None,
         ld_reference_file: Optional[str] = None,
         ld_col: Optional[str] = None,
         genes_df: Optional[pd.DataFrame] = None,
         exons_df: Optional[pd.DataFrame] = None,
         recomb_df: Optional[pd.DataFrame] = None,
-        show_recombination: bool = True,
-        snp_labels: bool = True,
-        label_top_n: int = 5,
-        pos_col: str = "ps",
-        p_col: str = "p_wald",
-        rs_col: str = "rs",
-        figsize: Tuple[int, int] = (12, 8),
     ) -> Any:
         """Create a regional association plot.
 
         Args:
             gwas_df: GWAS results DataFrame.
             chrom: Chromosome number.
-            start: Start position of the region.
-            end: End position of the region.
-            lead_pos: Position of the lead/index SNP to highlight.
-            ld_reference_file: PLINK binary fileset for LD calculation.
-                If provided with lead_pos, calculates LD on the fly.
-            ld_col: Column name for pre-computed LD (R²) values.
-                Use this if LD was calculated externally.
+            start: Start position in base pairs.
+            end: End position in base pairs.
+            pos_col: Column name for genomic position.
+            p_col: Column name for p-value.
+            rs_col: Column name for SNP identifier.
+            snp_labels: Whether to show SNP labels on plot.
+            label_top_n: Number of top SNPs to label.
+            show_recombination: Whether to show recombination rate overlay.
+            figsize: Figure size as (width, height) in inches.
+            lead_pos: Position of lead/index SNP to highlight.
+            ld_reference_file: Path to PLINK binary fileset for LD calculation.
+            ld_col: Column name for pre-computed LD (R^2) values.
             genes_df: Gene annotations with chr, start, end, gene_name.
             exons_df: Exon annotations with chr, start, end, gene_name.
             recomb_df: Pre-loaded recombination rate data.
                 If None and show_recombination=True, loads from species default.
-            show_recombination: Whether to show recombination rate overlay.
-            snp_labels: Whether to label top SNPs.
-            label_top_n: Number of top SNPs to label.
-            pos_col: Column name for position.
-            p_col: Column name for p-value.
-            rs_col: Column name for SNP ID.
-            figsize: Figure size.
 
         Returns:
-            Matplotlib Figure object.
+            Figure object (type depends on backend).
 
         Raises:
-            ValidationError: If required DataFrame columns are missing.
+            ValidationError: If parameters or DataFrame columns are invalid.
+
+        Example:
+            >>> fig = plotter.plot(
+            ...     gwas_df,
+            ...     chrom=1, start=1000000, end=2000000,
+            ...     lead_pos=1500000, snp_labels=True,
+            ... )
         """
+        # Validate parameters via Pydantic
+        PlotConfig.from_kwargs(
+            chrom=chrom,
+            start=start,
+            end=end,
+            pos_col=pos_col,
+            p_col=p_col,
+            rs_col=rs_col,
+            snp_labels=snp_labels,
+            label_top_n=label_top_n,
+            show_recombination=show_recombination,
+            figsize=figsize,
+            lead_pos=lead_pos,
+            ld_reference_file=ld_reference_file,
+            ld_col=ld_col,
+        )
+
         # Validate inputs
         validate_gwas_df(gwas_df, pos_col=pos_col, p_col=p_col)
 
@@ -282,6 +315,23 @@ class LocusZoomPlotter:
 
         # Prepare data
         df = gwas_df.copy()
+
+        # Validate p-values and warn about issues
+        p_values = df[p_col]
+        nan_count = p_values.isna().sum()
+        if nan_count > 0:
+            logger.warning(
+                f"GWAS data contains {nan_count} NaN p-values which will be excluded"
+            )
+        invalid_count = ((p_values < 0) | (p_values > 1)).sum()
+        if invalid_count > 0:
+            logger.warning(
+                f"GWAS data contains {invalid_count} p-values outside [0, 1] range"
+            )
+        clipped_count = (p_values < 1e-300).sum()
+        if clipped_count > 0:
+            logger.debug(f"Clipping {clipped_count} p-values below 1e-300 to 1e-300")
+
         df["neglog10p"] = -np.log10(df[p_col].clip(lower=1e-300))
 
         # Calculate LD if reference file provided
@@ -364,10 +414,12 @@ class LocusZoomPlotter:
             )
             self._backend.set_xlabel(gene_ax, f"Chromosome {chrom} (Mb)")
             self._backend.hide_spines(gene_ax, ["top", "right", "left"])
+            # Format both axes for interactive backends (they don't share x-axis)
+            self._backend.format_xaxis_mb(gene_ax)
         else:
             self._backend.set_xlabel(ax, f"Chromosome {chrom} (Mb)")
 
-        # Format x-axis with Mb labels
+        # Format x-axis with Mb labels (association axis always needs formatting)
         self._backend.format_xaxis_mb(ax)
 
         # Adjust layout
@@ -516,18 +568,29 @@ class LocusZoomPlotter:
             return
 
         # Create secondary y-axis
-        yaxis_name = self._backend.create_twin_axis(ax)
-
-        # For plotly, yaxis_name is a tuple (fig, row, secondary_y)
-        # For bokeh, yaxis_name is just a string
-        if isinstance(yaxis_name, tuple):
-            _, _, secondary_y = yaxis_name
+        twin_result = self._backend.create_twin_axis(ax)
+
+        # Matplotlib returns the twin Axes object itself - use it for drawing
+        # Plotly returns tuple (fig, row, secondary_y_name)
+        # Bokeh returns string "secondary"
+        from matplotlib.axes import Axes
+
+        if isinstance(twin_result, Axes):
+            # Matplotlib: use the twin axis for all secondary axis operations
+            secondary_ax = twin_result
+            secondary_y = None  # Not used for matplotlib
+        elif isinstance(twin_result, tuple):
+            # Plotly: use original ax, specify y-axis via yaxis_name
+            secondary_ax = ax
+            _, _, secondary_y = twin_result
         else:
-            secondary_y = yaxis_name
+            # Bokeh: use original ax, specify y-axis via yaxis_name
+            secondary_ax = ax
+            secondary_y = twin_result
 
         # Plot fill under curve
         self._backend.fill_between_secondary(
-            ax,
+            secondary_ax,
             region_recomb["pos"],
             0,
             region_recomb["rate"],
@@ -538,7 +601,7 @@ class LocusZoomPlotter:
 
         # Plot recombination rate line
         self._backend.line_secondary(
-            ax,
+            secondary_ax,
             region_recomb["pos"],
             region_recomb["rate"],
             color=RECOMB_COLOR,
@@ -550,10 +613,10 @@ class LocusZoomPlotter:
         # Set y-axis limits and label
         max_rate = region_recomb["rate"].max()
         self._backend.set_secondary_ylim(
-            ax, 0, max(max_rate * 1.2, 20), yaxis_name=secondary_y
+            secondary_ax, 0, max(max_rate * 1.2, 20), yaxis_name=secondary_y
         )
         self._backend.set_secondary_ylabel(
-            ax,
+            secondary_ax,
             "Recombination rate (cM/Mb)",
             color=RECOMB_COLOR,
             fontsize=9,
@@ -664,14 +727,22 @@ class LocusZoomPlotter:
     def plot_stacked(
         self,
         gwas_dfs: List[pd.DataFrame],
+        *,
         chrom: int,
         start: int,
         end: int,
+        pos_col: str = "ps",
+        p_col: str = "p_wald",
+        rs_col: str = "rs",
+        snp_labels: bool = True,
+        label_top_n: int = 3,
+        show_recombination: bool = True,
+        figsize: Tuple[float, float] = (12.0, 8.0),
+        ld_reference_file: Optional[str] = None,
+        ld_col: Optional[str] = None,
         lead_positions: Optional[List[int]] = None,
         panel_labels: Optional[List[str]] = None,
-        ld_reference_file: Optional[str] = None,
         ld_reference_files: Optional[List[str]] = None,
-        ld_col: Optional[str] = None,
         genes_df: Optional[pd.DataFrame] = None,
         exons_df: Optional[pd.DataFrame] = None,
         eqtl_df: Optional[pd.DataFrame] = None,
@@ -679,13 +750,6 @@ class LocusZoomPlotter:
         finemapping_df: Optional[pd.DataFrame] = None,
         finemapping_cs_col: Optional[str] = "cs",
         recomb_df: Optional[pd.DataFrame] = None,
-        show_recombination: bool = True,
-        snp_labels: bool = True,
-        label_top_n: int = 3,
-        pos_col: str = "ps",
-        p_col: str = "p_wald",
-        rs_col: str = "rs",
-        figsize: Tuple[float, Optional[float]] = (12, None),
     ) -> Any:
         """Create stacked regional association plots for multiple GWAS.
 
@@ -695,30 +759,28 @@ class LocusZoomPlotter:
         Args:
             gwas_dfs: List of GWAS results DataFrames to stack.
             chrom: Chromosome number.
-            start: Start position of the region.
-            end: End position of the region.
-            lead_positions: List of lead SNP positions (one per GWAS).
-                If None, auto-detects from lowest p-value.
-            panel_labels: Labels for each panel (e.g., phenotype names).
-            ld_reference_file: Single PLINK fileset for all panels.
+            start: Start position in base pairs.
+            end: End position in base pairs.
+            pos_col: Column name for genomic position.
+            p_col: Column name for p-value.
+            rs_col: Column name for SNP identifier.
+            snp_labels: Whether to show SNP labels on plot.
+            label_top_n: Number of top SNPs to label (default 3 for stacked).
+            show_recombination: Whether to show recombination rate overlay.
+            figsize: Figure size as (width, height) in inches.
+            ld_reference_file: Single PLINK fileset (broadcast to all panels).
+            ld_col: Column name for pre-computed LD (R^2) values.
+            lead_positions: List of lead SNP positions (one per panel).
+            panel_labels: List of panel labels (one per panel).
             ld_reference_files: List of PLINK filesets (one per panel).
-            ld_col: Column name for pre-computed LD (R²) values in each DataFrame.
-                Use this if LD was calculated externally.
             genes_df: Gene annotations for bottom track.
             exons_df: Exon annotations for gene track.
             eqtl_df: eQTL data to display as additional panel.
             eqtl_gene: Filter eQTL data to this target gene.
             finemapping_df: Fine-mapping/SuSiE results with pos and pip columns.
                 Displayed as PIP line with optional credible set coloring.
-            finemapping_cs_col: Column name for credible set assignment in finemapping_df.
+            finemapping_cs_col: Column name for credible set assignment.
             recomb_df: Pre-loaded recombination rate data.
-            show_recombination: Whether to show recombination overlay.
-            snp_labels: Whether to label top SNPs.
-            label_top_n: Number of top SNPs to label per panel.
-            pos_col: Column name for position.
-            p_col: Column name for p-value.
-            rs_col: Column name for SNP ID.
-            figsize: Figure size (width, height). If height is None, auto-calculates.
 
         Returns:
             Figure object (type depends on backend).
@@ -728,9 +790,27 @@ class LocusZoomPlotter:
             ...     [gwas_height, gwas_bmi, gwas_whr],
             ...     chrom=1, start=1000000, end=2000000,
             ...     panel_labels=["Height", "BMI", "WHR"],
-            ...     genes_df=genes_df,
             ... )
         """
+        # Validate parameters via Pydantic
+        StackedPlotConfig.from_kwargs(
+            chrom=chrom,
+            start=start,
+            end=end,
+            pos_col=pos_col,
+            p_col=p_col,
+            rs_col=rs_col,
+            snp_labels=snp_labels,
+            label_top_n=label_top_n,
+            show_recombination=show_recombination,
+            figsize=figsize,
+            ld_reference_file=ld_reference_file,
+            ld_col=ld_col,
+            lead_positions=lead_positions,
+            panel_labels=panel_labels,
+            ld_reference_files=ld_reference_files,
+        )
+
         n_gwas = len(gwas_dfs)
         if n_gwas == 0:
             raise ValueError("At least one GWAS DataFrame required")
@@ -766,8 +846,16 @@ class LocusZoomPlotter:
             for df in gwas_dfs:
                 region_df = df[(df[pos_col] >= start) & (df[pos_col] <= end)]
                 if not region_df.empty:
-                    lead_idx = region_df[p_col].idxmin()
-                    lead_positions.append(int(region_df.loc[lead_idx, pos_col]))
+                    # Filter out NaN p-values for lead SNP detection
+                    valid_p = region_df[p_col].dropna()
+                    if valid_p.empty:
+                        logger.warning(
+                            "All p-values in region are NaN, cannot determine lead SNP"
+                        )
+                        lead_positions.append(None)
+                    else:
+                        lead_idx = valid_p.idxmin()
+                        lead_positions.append(int(region_df.loc[lead_idx, pos_col]))
                 else:
                     lead_positions.append(None)
 
@@ -990,40 +1078,41 @@ class LocusZoomPlotter:
                 has_effect = "effect_size" in eqtl_data.columns
 
                 if has_effect:
-                    # Plot triangles by effect direction (batch by sign for efficiency)
+                    # Vectorized plotting: split by sign, assign colors in bulk
                     pos_effects = eqtl_data[eqtl_data["effect_size"] >= 0]
                     neg_effects = eqtl_data[eqtl_data["effect_size"] < 0]
 
-                    # Plot positive effects (up triangles)
-                    for _, row in pos_effects.iterrows():
-                        row_df = pd.DataFrame([row])
+                    # Vectorized color assignment using apply
+                    if not pos_effects.empty:
+                        pos_colors = pos_effects["effect_size"].apply(get_eqtl_color)
                         self._backend.scatter(
                             ax,
-                            pd.Series([row["pos"]]),
-                            pd.Series([row["neglog10p"]]),
-                            colors=get_eqtl_color(row["effect_size"]),
+                            pos_effects["pos"],
+                            pos_effects["neglog10p"],
+                            colors=pos_colors.tolist(),
                             sizes=50,
                             marker="^",
                             edgecolor="black",
                             linewidth=0.5,
                             zorder=2,
-                            hover_data=eqtl_hover_builder.build_dataframe(row_df),
+                            hover_data=eqtl_hover_builder.build_dataframe(pos_effects),
                         )
-                    # Plot negative effects (down triangles)
-                    for _, row in neg_effects.iterrows():
-                        row_df = pd.DataFrame([row])
+
+                    if not neg_effects.empty:
+                        neg_colors = neg_effects["effect_size"].apply(get_eqtl_color)
                         self._backend.scatter(
                             ax,
-                            pd.Series([row["pos"]]),
-                            pd.Series([row["neglog10p"]]),
-                            colors=get_eqtl_color(row["effect_size"]),
+                            neg_effects["pos"],
+                            neg_effects["neglog10p"],
+                            colors=neg_colors.tolist(),
                             sizes=50,
                             marker="v",
                             edgecolor="black",
                             linewidth=0.5,
                             zorder=2,
-                            hover_data=eqtl_hover_builder.build_dataframe(row_df),
+                            hover_data=eqtl_hover_builder.build_dataframe(neg_effects),
                         )
+
                     # Add eQTL effect legend (all backends)
                     self._backend.add_eqtl_legend(
                         ax, EQTL_POSITIVE_BINS, EQTL_NEGATIVE_BINS
@@ -1144,18 +1233,37 @@ class LocusZoomPlotter:
         # Plot points by category
         if categories:
             for cat in categories:
-                cat_data = df[df[category_col] == cat]
+                # Handle NaN category: NaN == NaN is False in pandas
+                if pd.isna(cat):
+                    cat_data = df[df[category_col].isna()]
+                else:
+                    cat_data = df[df[category_col] == cat]
                 # Use upward triangles for positive effects, circles otherwise
                 if effect_col and effect_col in cat_data.columns:
-                    for _, row in cat_data.iterrows():
-                        marker = "^" if row[effect_col] >= 0 else "v"
+                    # Vectorized: split by effect sign, 2 scatter calls per category
+                    pos_data = cat_data[cat_data[effect_col] >= 0]
+                    neg_data = cat_data[cat_data[effect_col] < 0]
+
+                    if not pos_data.empty:
                         self._backend.scatter(
                             ax,
-                            pd.Series([row["neglog10p"]]),
-                            pd.Series([row["y_pos"]]),
+                            pos_data["neglog10p"],
+                            pos_data["y_pos"],
                             colors=palette[cat],
                             sizes=60,
-                            marker=marker,
+                            marker="^",
+                            edgecolor="black",
+                            linewidth=0.5,
+                            zorder=2,
+                        )
+                    if not neg_data.empty:
+                        self._backend.scatter(
+                            ax,
+                            neg_data["neglog10p"],
+                            neg_data["y_pos"],
+                            colors=palette[cat],
+                            sizes=60,
+                            marker="v",
                             edgecolor="black",
                             linewidth=0.5,
                             zorder=2,

pylocuszoom/schemas.py

@@ -10,12 +10,7 @@ from typing import Optional, Union
 import pandas as pd
 from pydantic import BaseModel, ConfigDict, field_validator, model_validator
 
-
-class LoaderValidationError(Exception):
-    """Raised when loaded data fails validation."""
-
-    pass
-
+from .exceptions import LoaderValidationError
 
 # =============================================================================
 # GWAS Validation

pylocuszoom/utils.py

@@ -8,6 +8,8 @@ from typing import TYPE_CHECKING, Any, List, Optional, Union
 
 import pandas as pd
 
+from .exceptions import ValidationError
+
 if TYPE_CHECKING:
     from pyspark.sql import DataFrame as SparkDataFrame
 
@@ -15,10 +17,6 @@ if TYPE_CHECKING:
 DataFrameLike = Union[pd.DataFrame, "SparkDataFrame", Any]
 
 
-class ValidationError(ValueError):
-    """Raised when input validation fails."""
-
-
 def is_spark_dataframe(df: Any) -> bool:
     """Check if object is a PySpark DataFrame.
 

pylocuszoom/validation.py

@@ -159,6 +159,57 @@ class DataFrameValidator:
 
         return self
 
+    def require_ci_ordering(
+        self,
+        ci_lower_col: str,
+        effect_col: str,
+        ci_upper_col: str,
+    ) -> "DataFrameValidator":
+        """Check that confidence intervals are properly ordered.
+
+        Validates that ci_lower <= effect <= ci_upper for all rows.
+        Invalid ordering would produce negative error bar lengths.
+
+        Args:
+            ci_lower_col: Column name for lower CI bound.
+            effect_col: Column name for effect size (point estimate).
+            ci_upper_col: Column name for upper CI bound.
+
+        Returns:
+            Self for method chaining.
+        """
+        # Skip if any column is missing
+        for col in [ci_lower_col, effect_col, ci_upper_col]:
+            if col not in self._df.columns:
+                return self
+
+        lower = self._df[ci_lower_col]
+        effect = self._df[effect_col]
+        upper = self._df[ci_upper_col]
+
+        # Check ci_lower <= effect
+        lower_gt_effect = (lower > effect).sum()
+        if lower_gt_effect > 0:
+            self._errors.append(
+                f"{lower_gt_effect} rows have {ci_lower_col} > {effect_col}"
+            )
+
+        # Check effect <= ci_upper
+        effect_gt_upper = (effect > upper).sum()
+        if effect_gt_upper > 0:
+            self._errors.append(
+                f"{effect_gt_upper} rows have {effect_col} > {ci_upper_col}"
+            )
+
+        # Check ci_lower <= ci_upper (implicit from above, but explicit is clearer)
+        lower_gt_upper = (lower > upper).sum()
+        if lower_gt_upper > 0:
+            self._errors.append(
+                f"{lower_gt_upper} rows have {ci_lower_col} > {ci_upper_col}"
+            )
+
+        return self
+
     def validate(self) -> None:
         """Raise ValidationError if any validation rules failed.
 

{pylocuszoom-0.8.0.dist-info → pylocuszoom-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylocuszoom
-Version: 0.8.0
+Version: 1.0.0
 Summary: Publication-ready regional association plots with LD coloring, gene tracks, and recombination overlays
 Project-URL: Homepage, https://github.com/michael-denyer/pylocuszoom
 Project-URL: Documentation, https://github.com/michael-denyer/pylocuszoom#readme
@@ -109,15 +109,14 @@ from pylocuszoom import LocusZoomPlotter
 # Initialize plotter (loads reference data for canine)
 plotter = LocusZoomPlotter(species="canine")
 
-# Create regional plot
+# Plot with parameters passed directly
 fig = plotter.plot(
-    gwas_df,                    # DataFrame with ps, p_wald, rs columns
+    gwas_df,                        # DataFrame with ps, p_wald, rs columns
     chrom=1,
     start=1000000,
     end=2000000,
-    lead_pos=1500000,           # Highlight lead SNP
+    lead_pos=1500000,               # Highlight lead SNP
 )
-
 fig.savefig("regional_plot.png", dpi=150)
 ```
 
@@ -137,9 +136,7 @@ fig = plotter.plot(
     start=1000000,
     end=2000000,
     lead_pos=1500000,
-    ld_reference_file="genotypes.bed",  # For LD calculation
-    genes_df=genes_df,                  # Gene annotations
-    exons_df=exons_df,                  # Exon annotations
+    ld_reference_file="genotypes",      # PLINK fileset (without extension)
     show_recombination=True,            # Overlay recombination rate
     snp_labels=True,                    # Label top SNPs
     label_top_n=5,                      # How many to label
@@ -147,6 +144,8 @@ fig = plotter.plot(
     p_col="p_wald",                     # Column name for p-value
     rs_col="rs",                        # Column name for SNP ID
     figsize=(12, 8),
+    genes_df=genes_df,                  # Gene annotations
+    exons_df=exons_df,                  # Exon annotations
 )
 ```
 
@@ -163,6 +162,8 @@ Recombination maps are automatically lifted over from CanFam3.1 to CanFam4 coord
 ## Using with Other Species
 
 ```python
+from pylocuszoom import LocusZoomPlotter
+
 # Feline (LD and gene tracks, user provides recombination data)
 plotter = LocusZoomPlotter(species="feline")
 
@@ -172,10 +173,12 @@ plotter = LocusZoomPlotter(
     recomb_data_dir="/path/to/recomb_maps/",
 )
 
-# Or provide data per-plot
+# Provide data per-plot
 fig = plotter.plot(
     gwas_df,
-    chrom=1, start=1000000, end=2000000,
+    chrom=1,
+    start=1000000,
+    end=2000000,
     recomb_df=my_recomb_dataframe,
     genes_df=my_genes_df,
 )
@@ -186,6 +189,8 @@ fig = plotter.plot(
 pyLocusZoom can automatically fetch gene annotations from Ensembl for any species:
 
 ```python
+from pylocuszoom import LocusZoomPlotter
+
 # Enable automatic gene fetching
 plotter = LocusZoomPlotter(species="human", auto_genes=True)
 
@@ -201,6 +206,8 @@ Data is cached locally for fast subsequent plots. Maximum region size is 5Mb (En
 pyLocusZoom supports multiple rendering backends (set at initialization):
 
 ```python
+from pylocuszoom import LocusZoomPlotter
+
 # Static publication-quality plot (default)
 plotter = LocusZoomPlotter(species="canine", backend="matplotlib")
 fig = plotter.plot(gwas_df, chrom=1, start=1000000, end=2000000)
@@ -229,6 +236,10 @@ fig = plotter.plot(gwas_df, chrom=1, start=1000000, end=2000000)
 Compare multiple GWAS results vertically with shared x-axis:
 
 ```python
+from pylocuszoom import LocusZoomPlotter
+
+plotter = LocusZoomPlotter(species="canine")
+
 fig = plotter.plot_stacked(
     [gwas_height, gwas_bmi, gwas_whr],
     chrom=1,
@@ -247,15 +258,21 @@ fig = plotter.plot_stacked(
 Add expression QTL data as a separate panel:
 
 ```python
+from pylocuszoom import LocusZoomPlotter
+
 eqtl_df = pd.DataFrame({
     "pos": [1000500, 1001200, 1002000],
     "p_value": [1e-6, 1e-4, 0.01],
     "gene": ["BRCA1", "BRCA1", "BRCA1"],
 })
 
+plotter = LocusZoomPlotter(species="canine")
+
 fig = plotter.plot_stacked(
     [gwas_df],
-    chrom=1, start=1000000, end=2000000,
+    chrom=1,
+    start=1000000,
+    end=2000000,
     eqtl_df=eqtl_df,
     eqtl_gene="BRCA1",
     genes_df=genes_df,
@@ -270,15 +287,21 @@ fig = plotter.plot_stacked(
 Visualize SuSiE or other fine-mapping results with credible set coloring:
 
 ```python
+from pylocuszoom import LocusZoomPlotter
+
 finemapping_df = pd.DataFrame({
     "pos": [1000500, 1001200, 1002000, 1003500],
     "pip": [0.85, 0.12, 0.02, 0.45],  # Posterior inclusion probability
     "cs": [1, 1, 0, 2],               # Credible set assignment (0 = not in CS)
 })
 
+plotter = LocusZoomPlotter(species="canine")
+
 fig = plotter.plot_stacked(
     [gwas_df],
-    chrom=1, start=1000000, end=2000000,
+    chrom=1,
+    start=1000000,
+    end=2000000,
     finemapping_df=finemapping_df,
     finemapping_cs_col="cs",
     genes_df=genes_df,
@@ -414,7 +437,7 @@ gwas_df = pd.DataFrame({
 |--------|------|----------|-------------|
 | `chr` | str or int | Yes | Chromosome identifier. Accepts "1", "chr1", or 1. The "chr" prefix is stripped for matching. |
 | `start` | int | Yes | Gene start position (bp, 1-based). Transcript start for strand-aware genes. |
-| `end` | int | Yes | Gene end position (bp, 1-based). Must be ≥ start. |
+| `end` | int | Yes | Gene end position (bp, 1-based). Must be >= start. |
 | `gene_name` | str | Yes | Gene symbol displayed in track (e.g., "BRCA1", "TP53"). Keep short for readability. |
 
 Example:
@@ -516,6 +539,7 @@ Optional:
 ## Documentation
 
 - [User Guide](docs/USER_GUIDE.md) - Comprehensive documentation with API reference
+- [Code Map](docs/CODEMAP.md) - Architecture diagram with source code links
 - [Architecture](docs/ARCHITECTURE.md) - Design decisions and component overview
 - [Example Notebook](examples/getting_started.ipynb) - Interactive tutorial
 - [CHANGELOG](CHANGELOG.md) - Version history

{pylocuszoom-0.8.0.dist-info → pylocuszoom-1.0.0.dist-info}/RECORD

@@ -1,21 +1,23 @@
-pylocuszoom/__init__.py,sha256=UtrNrjV0b0frxv3Zl4jw5D8aTMbNSE55j-PPkd8rz28,5585
+pylocuszoom/__init__.py,sha256=DNdSi6JbIQeGr6yt4G_z9NcZoY0P9ivLVbaLaOlLbRM,5894
 pylocuszoom/colors.py,sha256=B28rfhWwGZ-e6Q-F43iXxC6NZpjUo0yWk4S_-vp9ZvU,7686
+pylocuszoom/config.py,sha256=qjIEodI-RY71RVyQ5QmE6WXcPXU4Re_xEWiDlkEww3g,13266
 pylocuszoom/ensembl.py,sha256=q767o86FdcKn4V9aK48ESFwNI7ATlaX5tnwjZReYMEw,14436
-pylocuszoom/eqtl.py,sha256=OrpWbFMR1wKMCmfQiC-2sqYx-99TT2i1cStIrPWIUOs,5948
-pylocuszoom/finemapping.py,sha256=ZPcnc9E6N41Su8222wCqBkB3bhhyfASvj9u9Ot4td4o,5898
-pylocuszoom/forest.py,sha256=302gULz9I0UiwqgcB18R756OOl1aa54OsPYHc6TnxGY,1092
-pylocuszoom/gene_track.py,sha256=PkBwfqByVxhXlAPco9-d4P5X7cTg2rrOnw7BJVx48ow,17818
+pylocuszoom/eqtl.py,sha256=9hGcFARABQRCMN3rco0pVlFJdmlh4SLBBKSgOvdIH_U,5924
+pylocuszoom/exceptions.py,sha256=nd-rWMUodW62WVV4TfcYVPQcb66xV6v9FA-_4xHb5VY,926
+pylocuszoom/finemapping.py,sha256=VYQs4o4dVREXicueT1anzuENiFZk6YXb6HpbwyF0FD0,5828
+pylocuszoom/forest.py,sha256=K-wBinxBOqIzsNMtZJ587e_oMhUXIXEqmEzVTUbmHSY,1161
+pylocuszoom/gene_track.py,sha256=nbQEC3bbqukhCosPFny5ajv6hjkV-EZe7rKbsSoGs8g,17933
 pylocuszoom/labels.py,sha256=Ams5WVZFNVT692BRiQ5wZcdbdNEAm5xtgRwmF5u0s_A,3492
 pylocuszoom/ld.py,sha256=64xIulpDVvbMSryWUPoCQ99Odcjwf1wejpwVr_30MLU,6412
 pylocuszoom/loaders.py,sha256=KpWPBO0BCb2yrGTtgdiOqOuhx2YLmjK_ywmpr3onnx8,25156
 pylocuszoom/logging.py,sha256=nZHEkbnjp8zoyWj_S-Hy9UQvUYLoMoxyiOWRozBT2dg,4987
 pylocuszoom/phewas.py,sha256=6g2LmwA5kmxYlHgPxJvuXIMerEqfqgsrth110Y3CgVU,968
-pylocuszoom/plotter.py,sha256=gFywhaHPuXlbKPxWaWfw7Wrw8kqPMUPzKMgDcRB6wu8,50709
+pylocuszoom/plotter.py,sha256=7rWsBXbLg-WSjmK474FU5KbzviidXC-cJGFkMMHomAg,54980
 pylocuszoom/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pylocuszoom/recombination.py,sha256=97GGBLDLTlQSRMp5sLOna3mCeRxeJiiWPHrw4dBRjQs,14546
-pylocuszoom/schemas.py,sha256=vABBBlAR1vUP6BIewZ8E-TYpacccrcxavrdIDVCrQB4,11916
-pylocuszoom/utils.py,sha256=_rI6ov0MbsWlZGJ7ni-V4387cirmJCX6IF2JAYhBx6A,6929
-pylocuszoom/validation.py,sha256=UInqlhOWhWaCT_mrO7O7SfB1DNIYkjvEMudy4YjtUBg,5698
+pylocuszoom/schemas.py,sha256=XxeivyRm5LGDwJw4GToxzOSdyx1yXvFYk3xgeFJ6VW0,11858
+pylocuszoom/utils.py,sha256=Z2P__Eau3ilF2ftuAZBm11EZ1NqCFQzfr4br9jCiJmg,6887
+pylocuszoom/validation.py,sha256=3D9axjUvNXWW3Mk7dwRG38-di2P0zDpVVGF5WNSfZbk,7403
 pylocuszoom/backends/__init__.py,sha256=xefVj3jVxmYwVLLY5AZtFqTPMehQxZ2qGd-Pk7_V_Bk,4267
 pylocuszoom/backends/base.py,sha256=PBdm9t4f_qFDMkYR5z3edW4DvpuQSCAXuaxs2qjAeH0,21034
 pylocuszoom/backends/bokeh_backend.py,sha256=11zRhXH2guUHiaYXyd7l2IDAv6uawdRAv6dyGPkHmJc,25512
@@ -23,7 +25,7 @@ pylocuszoom/backends/hover.py,sha256=Hjm_jcxJL8dDxO_Ye7jeWAUcHKlbH6oO8ZfGJ2MzIFM
 pylocuszoom/backends/matplotlib_backend.py,sha256=098ITnvNrBTaEztqez_7D0sZ_rKAYIxS6EDR5Yxt8is,20924
 pylocuszoom/backends/plotly_backend.py,sha256=A6ZuHw0wVZaIIA6FgYJ4SH-Sz59tHOtnGUl-e-2VzZM,30574
 pylocuszoom/reference_data/__init__.py,sha256=qqHqAUt1jebGlCN3CjqW3Z-_coHVNo5K3a3bb9o83hA,109
-pylocuszoom-0.8.0.dist-info/METADATA,sha256=VqHRvFL1Wq5OJO3B727Rl0H8UfbBPaxVIJUOSA22s5A,17866
-pylocuszoom-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pylocuszoom-0.8.0.dist-info/licenses/LICENSE.md,sha256=U2y_hv8RcN5lECA3uK88irU3ODUE1TDAPictcmnP0Q4,698
-pylocuszoom-0.8.0.dist-info/RECORD,,
+pylocuszoom-1.0.0.dist-info/METADATA,sha256=OMU09xbn6MMuvw8rPy19aMUiN40rp9Vl69QvqU7nwc4,18390
+pylocuszoom-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pylocuszoom-1.0.0.dist-info/licenses/LICENSE.md,sha256=U2y_hv8RcN5lECA3uK88irU3ODUE1TDAPictcmnP0Q4,698
+pylocuszoom-1.0.0.dist-info/RECORD,,