pylocuszoom 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

pylocuszoom/plotter.py

@@ -139,11 +139,8 @@ class LocusZoomPlotter:
     @staticmethod
     def _default_build(species: str) -> Optional[str]:
         """Get default genome build for species."""
-        if species == "canine":
-            return "canfam3.1"
-        if species == "feline":
-            return "felCat9"
-        return None
+        builds = {"canine": "canfam3.1", "feline": "felCat9"}
+        return builds.get(species)
 
     def _ensure_recomb_maps(self) -> Optional[Path]:
         """Ensure recombination maps are downloaded.
@@ -157,8 +154,8 @@ class LocusZoomPlotter:
             default_dir = get_default_data_dir()
             if (
                 default_dir.exists()
-                and len(list(default_dir.glob("chr*_recomb.tsv"))) >= 38
-            ):
+                and len(list(default_dir.glob("chr*_recomb.tsv"))) >= 39
+            ):  # 38 autosomes + X
                 return default_dir
             # Download
             try:
@@ -215,7 +212,7 @@ class LocusZoomPlotter:
         p_col: str = "p_wald",
         rs_col: str = "rs",
         figsize: Tuple[int, int] = (12, 8),
-    ) -> Figure:
+    ) -> Any:
         """Create a regional association plot.
 
         Args:
@@ -589,53 +586,6 @@ class LocusZoomPlotter:
             yaxis_name=secondary_y,
         )
 
-    def _add_eqtl_legend(self, ax: Axes) -> None:
-        """Add eQTL effect size legend to plot."""
-        legend_elements = []
-
-        # Positive effects (upward triangles)
-        for _, _, label, color in EQTL_POSITIVE_BINS:
-            legend_elements.append(
-                Line2D(
-                    [0],
-                    [0],
-                    marker="^",
-                    color="w",
-                    markerfacecolor=color,
-                    markeredgecolor="black",
-                    markersize=7,
-                    label=label,
-                )
-            )
-
-        # Negative effects (downward triangles)
-        for _, _, label, color in EQTL_NEGATIVE_BINS:
-            legend_elements.append(
-                Line2D(
-                    [0],
-                    [0],
-                    marker="v",
-                    color="w",
-                    markerfacecolor=color,
-                    markeredgecolor="black",
-                    markersize=7,
-                    label=label,
-                )
-            )
-
-        ax.legend(
-            handles=legend_elements,
-            loc="upper right",
-            fontsize=8,
-            frameon=True,
-            framealpha=0.9,
-            title="eQTL effect",
-            title_fontsize=9,
-            handlelength=1.2,
-            handleheight=1.0,
-            labelspacing=0.3,
-        )
-
     def _plot_finemapping(
         self,
         ax: Axes,
@@ -657,6 +607,23 @@ class LocusZoomPlotter:
             show_credible_sets: Whether to color points by credible set.
             pip_threshold: Minimum PIP to display as scatter point.
         """
+
+        def _build_finemapping_hover_data(
+            subset_df: pd.DataFrame,
+        ) -> Optional[pd.DataFrame]:
+            """Build hover data for interactive backends."""
+            hover_cols = {}
+            # Position
+            if pos_col in subset_df.columns:
+                hover_cols["Position"] = subset_df[pos_col].values
+            # PIP
+            if pip_col in subset_df.columns:
+                hover_cols["PIP"] = subset_df[pip_col].values
+            # Credible set
+            if cs_col and cs_col in subset_df.columns:
+                hover_cols["Credible Set"] = subset_df[cs_col].values
+            return pd.DataFrame(hover_cols) if hover_cols else None
+
         # Sort by position for line plotting
         df = df.sort_values(pos_col)
 
@@ -690,7 +657,7 @@ class LocusZoomPlotter:
                     edgecolor="black",
                     linewidth=0.5,
                     zorder=3,
-                    label=f"CS{cs_id}",
+                    hover_data=_build_finemapping_hover_data(cs_data),
                 )
             # Plot variants not in any credible set
             non_cs_data = df[(df[cs_col].isna()) | (df[cs_col] == 0)]
@@ -707,6 +674,7 @@ class LocusZoomPlotter:
                         edgecolor="black",
                         linewidth=0.3,
                         zorder=2,
+                        hover_data=_build_finemapping_hover_data(non_cs_data),
                     )
         else:
             # No credible sets - show all points above threshold
@@ -723,51 +691,9 @@ class LocusZoomPlotter:
                         edgecolor="black",
                         linewidth=0.5,
                         zorder=3,
+                        hover_data=_build_finemapping_hover_data(high_pip),
                     )
 
-    def _add_finemapping_legend(
-        self,
-        ax: Axes,
-        credible_sets: List[int],
-    ) -> None:
-        """Add fine-mapping legend showing credible sets.
-
-        Args:
-            ax: Matplotlib axes object.
-            credible_sets: List of credible set IDs to include.
-        """
-        if not credible_sets:
-            return
-
-        legend_elements = []
-        for cs_id in credible_sets:
-            color = get_credible_set_color(cs_id)
-            legend_elements.append(
-                Line2D(
-                    [0],
-                    [0],
-                    marker="o",
-                    color="w",
-                    markerfacecolor=color,
-                    markeredgecolor="black",
-                    markersize=7,
-                    label=f"CS{cs_id}",
-                )
-            )
-
-        ax.legend(
-            handles=legend_elements,
-            loc="upper right",
-            fontsize=8,
-            frameon=True,
-            framealpha=0.9,
-            title="Credible sets",
-            title_fontsize=9,
-            handlelength=1.2,
-            handleheight=1.0,
-            labelspacing=0.3,
-        )
-
     def plot_stacked(
         self,
         gwas_dfs: List[pd.DataFrame],
@@ -968,7 +894,9 @@ class LocusZoomPlotter:
                         panel_ld_col = "R2"
 
             # Plot association
-            self._plot_association(ax, df, pos_col, panel_ld_col, lead_pos, rs_col, p_col)
+            self._plot_association(
+                ax, df, pos_col, panel_ld_col, lead_pos, rs_col, p_col
+            )
 
             # Add significance line
             self._backend.axhline(
@@ -1080,10 +1008,12 @@ class LocusZoomPlotter:
                     pip_threshold=0.01,
                 )
 
-                # Add legend for credible sets
+                # Add legend for credible sets (all backends)
                 credible_sets = get_credible_sets(fm_data, finemapping_cs_col)
                 if credible_sets:
-                    self._add_finemapping_legend(ax, credible_sets)
+                    self._backend.add_finemapping_legend(
+                        ax, credible_sets, get_credible_set_color
+                    )
 
             self._backend.set_ylabel(ax, "PIP")
             self._backend.set_ylim(ax, -0.05, 1.05)
@@ -1111,30 +1041,70 @@ class LocusZoomPlotter:
                     eqtl_data["p_value"].clip(lower=1e-300)
                 )
 
+                def _build_eqtl_hover_data(
+                    subset_df: pd.DataFrame,
+                ) -> Optional[pd.DataFrame]:
+                    """Build hover data for eQTL interactive backends."""
+                    hover_cols = {}
+                    # Position
+                    if "pos" in subset_df.columns:
+                        hover_cols["Position"] = subset_df["pos"].values
+                    # P-value
+                    if "p_value" in subset_df.columns:
+                        hover_cols["P-value"] = subset_df["p_value"].values
+                    # Effect size
+                    if "effect_size" in subset_df.columns:
+                        hover_cols["Effect"] = subset_df["effect_size"].values
+                    # Gene
+                    if "gene" in subset_df.columns:
+                        hover_cols["Gene"] = subset_df["gene"].values
+                    return pd.DataFrame(hover_cols) if hover_cols else None
+
                 # Check if effect_size column exists for directional coloring
                 has_effect = "effect_size" in eqtl_data.columns
 
                 if has_effect:
-                    # Plot triangles by effect direction with color by magnitude
-                    for _, row in eqtl_data.iterrows():
-                        effect = row["effect_size"]
-                        color = get_eqtl_color(effect)
-                        marker = "^" if effect >= 0 else "v"
+                    # Plot triangles by effect direction (batch by sign for efficiency)
+                    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])
+                        self._backend.scatter(
+                            ax,
+                            pd.Series([row["pos"]]),
+                            pd.Series([row["neglog10p"]]),
+                            colors=get_eqtl_color(row["effect_size"]),
+                            sizes=50,
+                            marker="^",
+                            edgecolor="black",
+                            linewidth=0.5,
+                            zorder=2,
+                            hover_data=_build_eqtl_hover_data(row_df),
+                        )
+                    # Plot negative effects (down triangles)
+                    for _, row in neg_effects.iterrows():
+                        row_df = pd.DataFrame([row])
                         self._backend.scatter(
                             ax,
                             pd.Series([row["pos"]]),
                             pd.Series([row["neglog10p"]]),
-                            colors=color,
+                            colors=get_eqtl_color(row["effect_size"]),
                             sizes=50,
-                            marker=marker,
+                            marker="v",
                             edgecolor="black",
                             linewidth=0.5,
                             zorder=2,
+                            hover_data=_build_eqtl_hover_data(row_df),
                         )
-                    # Add eQTL effect legend
-                    self._add_eqtl_legend(ax)
+                    # Add eQTL effect legend (all backends)
+                    self._backend.add_eqtl_legend(
+                        ax, EQTL_POSITIVE_BINS, EQTL_NEGATIVE_BINS
+                    )
                 else:
                     # No effect sizes - plot as diamonds
+                    label = f"eQTL ({eqtl_gene})" if eqtl_gene else "eQTL"
                     self._backend.scatter(
                         ax,
                         eqtl_data["pos"],
@@ -1145,9 +1115,10 @@ class LocusZoomPlotter:
                         edgecolor="black",
                         linewidth=0.5,
                         zorder=2,
-                        label=f"eQTL ({eqtl_gene})" if eqtl_gene else "eQTL",
+                        label=label,
+                        hover_data=_build_eqtl_hover_data(eqtl_data),
                     )
-                    ax.legend(loc="upper right", fontsize=9)
+                    self._backend.add_simple_legend(ax, label, loc="upper right")
 
             self._backend.set_ylabel(ax, r"$-\log_{10}$ P (eQTL)")
             self._backend.axhline(

pylocuszoom/recombination.py

@@ -42,7 +42,7 @@ def _normalize_build(build: Optional[str]) -> Optional[str]:
     if build is None:
         return None
     build_lower = build.lower().replace(".", "").replace("_", "")
-    if "canfam4" in build_lower or "uucfamgsd" in build_lower:
+    if any(x in build_lower for x in ("canfam4", "uucfamgsd")):
         return "canfam4"
     if "canfam3" in build_lower:
         return "canfam3"
@@ -158,9 +158,9 @@ def get_default_data_dir() -> Path:
     """Get default directory for recombination map data.
 
     Returns platform-appropriate cache directory:
-    - macOS: ~/Library/Caches/snp-scope-plot
-    - Linux: ~/.cache/snp-scope-plot
+    - macOS/Linux: ~/.cache/snp-scope-plot (or $XDG_CACHE_HOME if set)
     - Windows: %LOCALAPPDATA%/snp-scope-plot
+    - Databricks: /dbfs/FileStore/reference_data/recombination_maps
     """
     if os.name == "nt":  # Windows
         base = Path(os.environ.get("LOCALAPPDATA", Path.home()))
@@ -207,7 +207,7 @@ def download_canine_recombination_maps(
     # Check if already downloaded
     if output_path.exists() and not force:
         existing_files = list(output_path.glob("chr*_recomb.tsv"))
-        if len(existing_files) >= 38:  # 38 autosomes + X
+        if len(existing_files) >= 39:  # 38 autosomes + X
             return output_path
 
     # Create output directory