Merge pull request #346 from jkmckenna/0.3.2

format/lint

Author: jkmckenna

src/smftools/cli/chimeric_adata.py

@@ -403,9 +403,7 @@ def chimeric_adata_core(
                         max_segments_per_read=getattr(
                             cfg, "rolling_nn_zero_pairs_max_segments_per_read", None
                         ),
-                        max_segment_overlap=getattr(
-                            cfg, "rolling_nn_zero_pairs_max_overlap", None
-                        ),
+                        max_segment_overlap=getattr(cfg, "rolling_nn_zero_pairs_max_overlap", None),
                     )
                     adata.uns.setdefault(
                         f"{cfg.rolling_nn_obsm_key}_zero_pairs_map", {}
@@ -457,19 +455,15 @@ def chimeric_adata_core(
                                 dtype=object,
                             )
                         if not filtered_df.empty:
-                            for read_id, read_df in filtered_df.groupby(
-                                "read_id", sort=False
-                            ):
+                            for read_id, read_df in filtered_df.groupby("read_id", sort=False):
                                 read_index = int(read_id)
                                 if read_index < 0 or read_index >= subset.n_obs:
                                     continue
                                 tuples = _build_top_segments_obs_tuples(
                                     read_df,
                                     subset.obs_names,
                                 )
-                                per_read_obs_series.at[
-                                    subset.obs_names[read_index]
-                                ] = tuples
+                                per_read_obs_series.at[subset.obs_names[read_index]] = tuples
                         adata.obs[per_read_obs_key] = per_read_obs_series
                         _build_zero_hamming_span_layer_from_obs(
                             adata=adata,
@@ -536,10 +530,7 @@ def chimeric_adata_core(
                     parent_obsm_key
                 )
                 out_png = rolling_nn_dir / f"{safe_sample}__{safe_ref}.png"
-                title = (
-                    f"{sample} {reference} (n={subset.n_obs})"
-                    f" | window={cfg.rolling_nn_window}"
-                )
+                title = f"{sample} {reference} (n={subset.n_obs}) | window={cfg.rolling_nn_window}"
                 try:
                     plot_rolling_nn_and_layer(
                         subset,
@@ -748,8 +739,7 @@ def chimeric_adata_core(
 
                     out_png = rolling_nn_layers_dir / f"{safe_sample}__{safe_ref}.png"
                     title = (
-                        f"{sample} {reference} (n={subset.n_obs})"
-                        f" | window={cfg.rolling_nn_window}"
+                        f"{sample} {reference} (n={subset.n_obs}) | window={cfg.rolling_nn_window}"
                     )
                     try:
                         plot_rolling_nn_and_two_layers(
@@ -789,11 +779,7 @@ def chimeric_adata_core(
                 .astype("category")
                 .cat.categories.tolist()
             )
-            references = (
-                adata.obs[cfg.reference_column]
-                .astype("category")
-                .cat.categories.tolist()
-            )
+            references = adata.obs[cfg.reference_column].astype("category").cat.categories.tolist()
             rng = np.random.RandomState(getattr(cfg, "cross_sample_random_seed", 42))
 
             for reference in references:
@@ -814,22 +800,15 @@ def chimeric_adata_core(
                 site_mask = mod_site_mask & adata.var[position_col].fillna(False)
 
                 for sample in samples:
-                    sample_mask = (
-                        (adata.obs[cfg.sample_name_col_for_plotting] == sample) & ref_mask
-                    )
+                    sample_mask = (adata.obs[cfg.sample_name_col_for_plotting] == sample) & ref_mask
                     if not sample_mask.any():
                         continue
 
                     # Build cross-sample pool
                     grouping_col = getattr(cfg, "cross_sample_grouping_col", None)
                     if grouping_col and grouping_col in adata.obs.columns:
-                        sample_group_val = (
-                            adata.obs.loc[sample_mask, grouping_col].iloc[0]
-                        )
-                        pool_mask = (
-                            ref_mask
-                            & (adata.obs[grouping_col] == sample_group_val)
-                        )
+                        sample_group_val = adata.obs.loc[sample_mask, grouping_col].iloc[0]
+                        pool_mask = ref_mask & (adata.obs[grouping_col] == sample_group_val)
                     else:
                         pool_mask = ref_mask
 
@@ -856,7 +835,7 @@ def chimeric_adata_core(
 
                     # Build sample_labels: 0 = current sample, 1 = other
                     cross_labels = np.zeros(len(combined_indices), dtype=np.int32)
-                    cross_labels[len(sample_indices):] = 1
+                    cross_labels[len(sample_indices) :] = 1
 
                     cross_obsm_key = "cross_sample_rolling_nn_dist"
                     try:
@@ -995,18 +974,23 @@ def chimeric_adata_core(
 
                     # Copy cross-sample obsm into plot_subset
                     if parent_obsm_key in adata.obsm:
-                        plot_subset.obsm[cfg.rolling_nn_obsm_key] = (
-                            adata[sample_mask].obsm.get(parent_obsm_key)
+                        plot_subset.obsm[cfg.rolling_nn_obsm_key] = adata[sample_mask].obsm.get(
+                            parent_obsm_key
                         )
                         for suffix in (
-                            "starts", "centers", "window", "step", "min_overlap",
-                            "return_fraction", "layer",
+                            "starts",
+                            "centers",
+                            "window",
+                            "step",
+                            "min_overlap",
+                            "return_fraction",
+                            "layer",
                         ):
                             parent_key = f"{parent_obsm_key}_{suffix}"
                             if parent_key in adata.uns:
-                                plot_subset.uns[f"{cfg.rolling_nn_obsm_key}_{suffix}"] = (
-                                    adata.uns[parent_key]
-                                )
+                                plot_subset.uns[f"{cfg.rolling_nn_obsm_key}_{suffix}"] = adata.uns[
+                                    parent_key
+                                ]
 
                     if grouping_col and grouping_col in adata.obs.columns:
                         cross_pool_desc = f"cross-sample ({grouping_col}={sample_group_val})"
@@ -1109,11 +1093,7 @@ def chimeric_adata_core(
                 .astype("category")
                 .cat.categories.tolist()
             )
-            references = (
-                adata.obs[cfg.reference_column]
-                .astype("category")
-                .cat.categories.tolist()
-            )
+            references = adata.obs[cfg.reference_column].astype("category").cat.categories.tolist()
 
             # Build delta layer: within - cross, clamped at 0
             if (
@@ -1139,13 +1119,9 @@ def chimeric_adata_core(
                 for reference in references:
                     ref_mask = adata.obs[cfg.reference_column] == reference
                     position_col = f"position_in_{reference}"
-                    site_cols = [
-                        f"{reference}_{st}_site" for st in cfg.rolling_nn_site_types
-                    ]
+                    site_cols = [f"{reference}_{st}_site" for st in cfg.rolling_nn_site_types]
                     missing_cols = [
-                        col
-                        for col in [position_col, *site_cols]
-                        if col not in adata.var.columns
+                        col for col in [position_col, *site_cols] if col not in adata.var.columns
                     ]
                     if missing_cols:
                         continue
@@ -1154,9 +1130,8 @@ def chimeric_adata_core(
 
                     for sample in samples:
                         sample_mask = (
-                            (adata.obs[cfg.sample_name_col_for_plotting] == sample)
-                            & ref_mask
-                        )
+                            adata.obs[cfg.sample_name_col_for_plotting] == sample
+                        ) & ref_mask
                         if not sample_mask.any():
                             continue
 
@@ -1201,14 +1176,17 @@ def chimeric_adata_core(
                             (cross_obsm_key, cross_nn_key),
                         ):
                             for suffix in (
-                                "starts", "centers", "window", "step",
-                                "min_overlap", "return_fraction", "layer",
+                                "starts",
+                                "centers",
+                                "window",
+                                "step",
+                                "min_overlap",
+                                "return_fraction",
+                                "layer",
                             ):
                                 src_k = f"{src_obsm}_{suffix}"
                                 if src_k in adata.uns:
-                                    plot_subset.uns[f"{dst_obsm}_{suffix}"] = (
-                                        adata.uns[src_k]
-                                    )
+                                    plot_subset.uns[f"{dst_obsm}_{suffix}"] = adata.uns[src_k]
 
                         # Check required span layers
                         required_layers = [
@@ -1282,20 +1260,14 @@ def chimeric_adata_core(
                     .cat.categories.tolist()
                 )
                 references = (
-                    adata.obs[cfg.reference_column]
-                    .astype("category")
-                    .cat.categories.tolist()
+                    adata.obs[cfg.reference_column].astype("category").cat.categories.tolist()
                 )
                 for reference in references:
                     ref_mask = adata.obs[cfg.reference_column] == reference
                     position_col = f"position_in_{reference}"
-                    site_cols = [
-                        f"{reference}_{st}_site" for st in cfg.rolling_nn_site_types
-                    ]
+                    site_cols = [f"{reference}_{st}_site" for st in cfg.rolling_nn_site_types]
                     missing_cols = [
-                        col
-                        for col in [position_col, *site_cols]
-                        if col not in adata.var.columns
+                        col for col in [position_col, *site_cols] if col not in adata.var.columns
                     ]
                     if missing_cols:
                         continue
@@ -1304,9 +1276,8 @@ def chimeric_adata_core(
 
                     for sample in samples:
                         sample_mask = (
-                            (adata.obs[cfg.sample_name_col_for_plotting] == sample)
-                            & ref_mask
-                        )
+                            adata.obs[cfg.sample_name_col_for_plotting] == sample
+                        ) & ref_mask
                         if not sample_mask.any():
                             continue
 
@@ -1338,9 +1309,7 @@ def chimeric_adata_core(
                                 exc,
                             )
             else:
-                logger.debug(
-                    "Span length distribution: missing required layers, skipping."
-                )
+                logger.debug("Span length distribution: missing required layers, skipping.")
 
     # ============================================================
     # 4) Save AnnData

src/smftools/cli/latent_adata.py

@@ -75,10 +75,12 @@ def _build_shared_valid_non_mod_sites_mask(
             raise KeyError(f"var_filters not found in adata.var: {missing}")
 
         mod_masks = [np.asarray(adata.var[col].values, dtype=bool) for col in mod_site_cols]
-        ref_mod_masks.append(mod_masks[0] if len(mod_masks) == 1 else np.logical_or.reduce(mod_masks))
+        ref_mod_masks.append(
+            mod_masks[0] if len(mod_masks) == 1 else np.logical_or.reduce(mod_masks)
+        )
 
-    any_mod_mask = np.logical_or.reduce(ref_mod_masks) if ref_mod_masks else np.zeros(
-        adata.n_vars, dtype=bool
+    any_mod_mask = (
+        np.logical_or.reduce(ref_mod_masks) if ref_mod_masks else np.zeros(adata.n_vars, dtype=bool)
     )
     return np.logical_and(shared_position_mask, np.logical_not(any_mod_mask))
 

src/smftools/config/experiment_config.py

@@ -1405,16 +1405,12 @@ def from_var_dict(
             ),
             rolling_nn_zero_pairs_layer_key=merged.get("rolling_nn_zero_pairs_layer_key", None),
             rolling_nn_zero_pairs_refine=merged.get("rolling_nn_zero_pairs_refine", True),
-            rolling_nn_zero_pairs_max_nan_run=merged.get(
-                "rolling_nn_zero_pairs_max_nan_run", None
-            ),
+            rolling_nn_zero_pairs_max_nan_run=merged.get("rolling_nn_zero_pairs_max_nan_run", None),
             rolling_nn_zero_pairs_merge_gap=merged.get("rolling_nn_zero_pairs_merge_gap", 0),
             rolling_nn_zero_pairs_max_segments_per_read=merged.get(
                 "rolling_nn_zero_pairs_max_segments_per_read", None
             ),
-            rolling_nn_zero_pairs_max_overlap=merged.get(
-                "rolling_nn_zero_pairs_max_overlap", None
-            ),
+            rolling_nn_zero_pairs_max_overlap=merged.get("rolling_nn_zero_pairs_max_overlap", None),
             rolling_nn_zero_pairs_layer_overlap_mode=merged.get(
                 "rolling_nn_zero_pairs_layer_overlap_mode", "binary"
             ),

src/smftools/plotting/chimeric_plotting.py

@@ -445,7 +445,9 @@ def _format_labels(values):
     def _layer_df_for_key(layer_key: str) -> pd.DataFrame:
         layer = subset.layers[layer_key]
         layer = layer.toarray() if hasattr(layer, "toarray") else np.asarray(layer)
-        layer_df = pd.DataFrame(layer[valid], index=subset.obs_names[valid], columns=subset.var_names)
+        layer_df = pd.DataFrame(
+            layer[valid], index=subset.obs_names[valid], columns=subset.var_names
+        )
         layer_df.index = layer_df.index.astype(str)
         if layer_var_mask is not None:
             layer_df = layer_df.loc[:, layer_var_mask]
@@ -1108,20 +1110,35 @@ def _nn_df(obsm_key):
     nn_cmap.set_bad(nn_nan_color)
 
     sns.heatmap(
-        self_nn_ord, ax=ax_self_nn, cmap=nn_cmap,
-        xticklabels=False, yticklabels=False, robust=robust, cbar_ax=ax_self_nn_cbar,
+        self_nn_ord,
+        ax=ax_self_nn,
+        cmap=nn_cmap,
+        xticklabels=False,
+        yticklabels=False,
+        robust=robust,
+        cbar_ax=ax_self_nn_cbar,
     )
     sns.heatmap(
-        cross_nn_ord, ax=ax_cross_nn, cmap=nn_cmap,
-        xticklabels=False, yticklabels=False, robust=robust, cbar_ax=ax_cross_nn_cbar,
+        cross_nn_ord,
+        ax=ax_cross_nn,
+        cmap=nn_cmap,
+        xticklabels=False,
+        yticklabels=False,
+        robust=robust,
+        cbar_ax=ax_cross_nn_cbar,
     )
 
     layer_cmap = plt.get_cmap("coolwarm").copy()
     if read_span_outside is not None:
         layer_cmap.set_bad(outside_read_color)
     sns.heatmap(
-        layer_plot, ax=ax_signal, cmap=layer_cmap,
-        xticklabels=False, yticklabels=False, robust=robust, cbar_ax=ax_signal_cbar,
+        layer_plot,
+        ax=ax_signal,
+        cmap=layer_cmap,
+        xticklabels=False,
+        yticklabels=False,
+        robust=robust,
+        cbar_ax=ax_signal_cbar,
     )
 
     # NN x-tick labels
@@ -1181,16 +1198,34 @@ def _nn_df(obsm_key):
     delta_cmap.set_bad(outside_read_color)
 
     sns.heatmap(
-        self_span_plot, ax=ax_self_span, cmap=self_span_cmap, norm=self_span_norm,
-        xticklabels=False, yticklabels=False, robust=robust, cbar_ax=ax_self_span_cbar,
+        self_span_plot,
+        ax=ax_self_span,
+        cmap=self_span_cmap,
+        norm=self_span_norm,
+        xticklabels=False,
+        yticklabels=False,
+        robust=robust,
+        cbar_ax=ax_self_span_cbar,
     )
     sns.heatmap(
-        cross_span_plot, ax=ax_cross_span, cmap=cross_span_cmap, norm=cross_span_norm,
-        xticklabels=False, yticklabels=False, robust=robust, cbar_ax=ax_cross_span_cbar,
+        cross_span_plot,
+        ax=ax_cross_span,
+        cmap=cross_span_cmap,
+        norm=cross_span_norm,
+        xticklabels=False,
+        yticklabels=False,
+        robust=robust,
+        cbar_ax=ax_cross_span_cbar,
     )
     sns.heatmap(
-        delta_span_plot, ax=ax_delta_span, cmap=delta_cmap, norm=delta_norm,
-        xticklabels=False, yticklabels=False, robust=robust, cbar_ax=ax_delta_span_cbar,
+        delta_span_plot,
+        ax=ax_delta_span,
+        cmap=delta_cmap,
+        norm=delta_norm,
+        xticklabels=False,
+        yticklabels=False,
+        robust=robust,
+        cbar_ax=ax_delta_span_cbar,
     )
 
     col_labels = [str(x) for x in self_span_ord.columns]

tests/unit/test_chimeric_adata_span_layer.py

@@ -1,8 +1,7 @@
+import anndata as ad
 import numpy as np
 import pandas as pd
 
-import anndata as ad
-
 from smftools.cli.chimeric_adata import _build_zero_hamming_span_layer_from_obs