smftools 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

smftools/informatics/run_multiqc.py

@@ -1,16 +1,23 @@
-def run_multiqc(input_dir, output_dir):
-    """
-    Runs MultiQC on a given directory and saves the report to the specified output directory.
+from __future__ import annotations
+
+from pathlib import Path
+
+from smftools.logging_utils import get_logger
 
-    Parameters:
-    - input_dir (str): Path to the directory containing QC reports (e.g., FastQC, Samtools, bcftools outputs).
-    - output_dir (str): Path to the directory where MultiQC reports should be saved.
+logger = get_logger(__name__)
 
-    Returns:
-    - None: The function executes MultiQC and prints the status.
+
+def run_multiqc(input_dir: str | Path, output_dir: str | Path) -> None:
+    """Run MultiQC on a directory and save the report to the output directory.
+
+    Args:
+        input_dir: Path to the directory containing QC reports (e.g., FastQC, Samtools outputs).
+        output_dir: Path to the directory where MultiQC reports should be saved.
     """
-    from ..readwrite import make_dirs
     import subprocess
+
+    from ..readwrite import make_dirs
+
     # Ensure the output directory exists
     make_dirs(output_dir)
 
@@ -20,12 +27,11 @@ def run_multiqc(input_dir, output_dir):
     # Construct MultiQC command
     command = ["multiqc", input_dir, "-o", output_dir]
 
-    print(f"Running MultiQC on '{input_dir}' and saving results to '{output_dir}'...")
-    
+    logger.info(f"Running MultiQC on '{input_dir}' and saving results to '{output_dir}'...")
+
     # Run MultiQC
     try:
         subprocess.run(command, check=True)
-        print(f"MultiQC report generated successfully in: {output_dir}")
+        logger.info(f"MultiQC report generated successfully in: {output_dir}")
     except subprocess.CalledProcessError as e:
-        print(f"Error running MultiQC: {e}")
-
+        logger.error(f"Error running MultiQC: {e}")

smftools/logging_utils.py

@@ -0,0 +1,51 @@
+"""Logging utilities for smftools."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional, Union
+
+DEFAULT_LOG_FORMAT = "[%(asctime)s] [%(levelname)s] [%(name)s]: %(message)s"
+DEFAULT_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+def setup_logging(
+    level: int = logging.INFO,
+    fmt: str = DEFAULT_LOG_FORMAT,
+    datefmt: str = DEFAULT_DATE_FORMAT,
+    log_file: Optional[Union[str, Path]] = None,
+) -> None:
+    """
+    Configure logging for smftools.
+
+    Should be called once by the CLI entrypoint.
+    Safe to call multiple times.
+    """
+    logger = logging.getLogger("smftools")
+
+    if logger.handlers:
+        return
+
+    formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
+
+    # Console handler (stderr)
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(formatter)
+    logger.addHandler(stream_handler)
+
+    # Optional file handler
+    if log_file is not None:
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+
+        file_handler = logging.FileHandler(log_path)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    logger.setLevel(level)
+    logger.propagate = False
+
+
+def get_logger(name: str) -> logging.Logger:
+    return logging.getLogger(name)

smftools/machine_learning/__init__.py

@@ -1,12 +1,7 @@
-from . import models
-from . import data
-from . import utils
-from . import evaluation
-from . import inference
-from . import training
+from . import data, evaluation, inference, models, training, utils
 
 __all__ = [
     "calculate_relative_risk_on_activity",
     "evaluate_models_by_subgroup",
     "prepare_melted_model_data",
-]
+]

smftools/machine_learning/data/anndata_data_module.py

@@ -1,24 +1,34 @@
-import torch
-from torch.utils.data import DataLoader, TensorDataset, random_split, Dataset, Subset
-import pytorch_lightning as pl
 import numpy as np
 import pandas as pd
-from .preprocessing import random_fill_nans
+import pytorch_lightning as pl
+import torch
 from sklearn.utils.class_weight import compute_class_weight
+from torch.utils.data import DataLoader, Dataset, Subset
+
+from .preprocessing import random_fill_nans
+
 
-    
 class AnnDataDataset(Dataset):
     """
     Generic PyTorch Dataset from AnnData.
     """
-    def __init__(self, adata, tensor_source="X", tensor_key=None, label_col=None, window_start=None, window_size=None):
+
+    def __init__(
+        self,
+        adata,
+        tensor_source="X",
+        tensor_key=None,
+        label_col=None,
+        window_start=None,
+        window_size=None,
+    ):
         self.adata = adata
         self.tensor_source = tensor_source
         self.tensor_key = tensor_key
         self.label_col = label_col
         self.window_start = window_start
         self.window_size = window_size
-        
+
         if tensor_source == "X":
             X = adata.X
         elif tensor_source == "layers":
@@ -29,17 +39,17 @@ class AnnDataDataset(Dataset):
             X = adata.obsm[tensor_key]
         else:
             raise ValueError(f"Invalid tensor_source: {tensor_source}")
-        
+
         if self.window_start is not None and self.window_size is not None:
             X = X[:, self.window_start : self.window_start + self.window_size]
-        
+
         X = random_fill_nans(X)
 
         self.X_tensor = torch.tensor(X, dtype=torch.float32)
 
         if label_col is not None:
             y = adata.obs[label_col]
-            if y.dtype.name == 'category':
+            if y.dtype.name == "category":
                 y = y.cat.codes
             self.y_tensor = torch.tensor(y.values, dtype=torch.long)
         else:
@@ -47,7 +57,7 @@ class AnnDataDataset(Dataset):
 
     def numpy(self, indices):
         return self.X_tensor[indices].numpy(), self.y_tensor[indices].numpy()
-    
+
     def __len__(self):
         return len(self.X_tensor)
 
@@ -60,9 +70,17 @@ class AnnDataDataset(Dataset):
             return (x,)
 
 
-def split_dataset(adata, dataset, train_frac=0.6, val_frac=0.1, test_frac=0.3, 
-                                 random_seed=42, split_col="train_val_test_split", 
-                                 load_existing_split=False, split_save_path=None):
+def split_dataset(
+    adata,
+    dataset,
+    train_frac=0.6,
+    val_frac=0.1,
+    test_frac=0.3,
+    random_seed=42,
+    split_col="train_val_test_split",
+    load_existing_split=False,
+    split_save_path=None,
+):
     """
     Perform split and record assignment into adata.obs[split_col].
     """
@@ -87,7 +105,7 @@ def split_dataset(adata, dataset, train_frac=0.6, val_frac=0.1, test_frac=0.3,
 
         split_array = np.full(total_len, "test", dtype=object)
         split_array[indices[:n_train]] = "train"
-        split_array[indices[n_train:n_train + n_val]] = "val"
+        split_array[indices[n_train : n_train + n_val]] = "val"
         adata.obs[split_col] = split_array
 
         if split_save_path:
@@ -104,14 +122,32 @@ def split_dataset(adata, dataset, train_frac=0.6, val_frac=0.1, test_frac=0.3,
 
     return train_set, val_set, test_set
 
+
 class AnnDataModule(pl.LightningDataModule):
     """
     Unified LightningDataModule version of AnnDataDataset + splitting with adata.obs recording.
     """
-    def __init__(self, adata, tensor_source="X", tensor_key=None, label_col="labels",
-                 batch_size=64, train_frac=0.6, val_frac=0.1, test_frac=0.3, random_seed=42,
-                 inference_mode=False, split_col="train_val_test_split", split_save_path=None,
-                 load_existing_split=False, window_start=None, window_size=None, num_workers=None, persistent_workers=False):
+
+    def __init__(
+        self,
+        adata,
+        tensor_source="X",
+        tensor_key=None,
+        label_col="labels",
+        batch_size=64,
+        train_frac=0.6,
+        val_frac=0.1,
+        test_frac=0.3,
+        random_seed=42,
+        inference_mode=False,
+        split_col="train_val_test_split",
+        split_save_path=None,
+        load_existing_split=False,
+        window_start=None,
+        window_size=None,
+        num_workers=None,
+        persistent_workers=False,
+    ):
         super().__init__()
         self.adata = adata
         self.tensor_source = tensor_source
@@ -133,52 +169,80 @@ class AnnDataModule(pl.LightningDataModule):
         self.persistent_workers = persistent_workers
 
     def setup(self, stage=None):
-        dataset = AnnDataDataset(self.adata, self.tensor_source, self.tensor_key, 
-                                  None if self.inference_mode else self.label_col,
-                                    window_start=self.window_start, window_size=self.window_size)
+        dataset = AnnDataDataset(
+            self.adata,
+            self.tensor_source,
+            self.tensor_key,
+            None if self.inference_mode else self.label_col,
+            window_start=self.window_start,
+            window_size=self.window_size,
+        )
 
         if self.inference_mode:
             self.infer_dataset = dataset
             return
 
         self.train_set, self.val_set, self.test_set = split_dataset(
-            self.adata, dataset, train_frac=self.train_frac, val_frac=self.val_frac, 
-            test_frac=self.test_frac, random_seed=self.random_seed, 
-            split_col=self.split_col, split_save_path=self.split_save_path, 
-            load_existing_split=self.load_existing_split
+            self.adata,
+            dataset,
+            train_frac=self.train_frac,
+            val_frac=self.val_frac,
+            test_frac=self.test_frac,
+            random_seed=self.random_seed,
+            split_col=self.split_col,
+            split_save_path=self.split_save_path,
+            load_existing_split=self.load_existing_split,
         )
 
     def train_dataloader(self):
         if self.num_workers:
-            return DataLoader(self.train_set, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers, persistent_workers=self.persistent_workers)
+            return DataLoader(
+                self.train_set,
+                batch_size=self.batch_size,
+                shuffle=True,
+                num_workers=self.num_workers,
+                persistent_workers=self.persistent_workers,
+            )
         else:
             return DataLoader(self.train_set, batch_size=self.batch_size, shuffle=True)
 
     def val_dataloader(self):
         if self.num_workers:
-            return DataLoader(self.val_set, batch_size=self.batch_size, num_workers=self.num_workers, persistent_workers=self.persistent_workers)
+            return DataLoader(
+                self.val_set,
+                batch_size=self.batch_size,
+                num_workers=self.num_workers,
+                persistent_workers=self.persistent_workers,
+            )
         else:
             return DataLoader(self.train_set, batch_size=self.batch_size, shuffle=False)
-        
+
     def test_dataloader(self):
         if self.num_workers:
-            return DataLoader(self.test_set, batch_size=self.batch_size, num_workers=self.num_workers, persistent_workers=self.persistent_workers)
+            return DataLoader(
+                self.test_set,
+                batch_size=self.batch_size,
+                num_workers=self.num_workers,
+                persistent_workers=self.persistent_workers,
+            )
         else:
             return DataLoader(self.train_set, batch_size=self.batch_size, shuffle=False)
-        
+
     def predict_dataloader(self):
         if not self.inference_mode:
             raise RuntimeError("Only valid in inference mode")
         return DataLoader(self.infer_dataset, batch_size=self.batch_size)
-    
+
     def compute_class_weights(self):
-        train_indices = self.train_set.indices # get the indices of the training set
-        y_all = self.train_set.dataset.y_tensor # get labels for the entire dataset (We are pulling from a Subset object, so this syntax can be confusing)
-        y_train = y_all[train_indices].cpu().numpy() # get the labels for the training set and move to a numpy array
-        
-        class_weights = compute_class_weight('balanced', classes=np.unique(y_train), y=y_train)
+        train_indices = self.train_set.indices  # get the indices of the training set
+        y_all = self.train_set.dataset.y_tensor  # get labels for the entire dataset (We are pulling from a Subset object, so this syntax can be confusing)
+        y_train = (
+            y_all[train_indices].cpu().numpy()
+        )  # get the labels for the training set and move to a numpy array
+
+        class_weights = compute_class_weight("balanced", classes=np.unique(y_train), y=y_train)
         return torch.tensor(class_weights, dtype=torch.float32)
-    
+
     def inference_numpy(self):
         """
         Return inference data as numpy for use in sklearn inference.
@@ -187,7 +251,7 @@ class AnnDataModule(pl.LightningDataModule):
             raise RuntimeError("Must be in inference_mode=True to use inference_numpy()")
         X_np = self.infer_dataset.X_tensor.numpy()
         return X_np
-    
+
     def to_numpy(self):
         """
         Move the AnnDataModule tensors into numpy arrays
@@ -202,9 +266,20 @@ class AnnDataModule(pl.LightningDataModule):
 
 
 def build_anndata_loader(
-    adata, tensor_source="X", tensor_key=None, label_col=None, train_frac=0.6, val_frac=0.1, 
-    test_frac=0.3, random_seed=42, batch_size=64, lightning=True, inference_mode=False, 
-    split_col="train_val_test_split", split_save_path=None, load_existing_split=False
+    adata,
+    tensor_source="X",
+    tensor_key=None,
+    label_col=None,
+    train_frac=0.6,
+    val_frac=0.1,
+    test_frac=0.3,
+    random_seed=42,
+    batch_size=64,
+    lightning=True,
+    inference_mode=False,
+    split_col="train_val_test_split",
+    split_save_path=None,
+    load_existing_split=False,
 ):
     """
     Unified pipeline for both Lightning and raw PyTorch.
@@ -213,22 +288,40 @@ def build_anndata_loader(
     """
     if lightning:
         return AnnDataModule(
-            adata, tensor_source=tensor_source, tensor_key=tensor_key, label_col=label_col,
-            batch_size=batch_size, train_frac=train_frac, val_frac=val_frac, test_frac=test_frac,
-            random_seed=random_seed, inference_mode=inference_mode,
-            split_col=split_col, split_save_path=split_save_path, load_existing_split=load_existing_split
+            adata,
+            tensor_source=tensor_source,
+            tensor_key=tensor_key,
+            label_col=label_col,
+            batch_size=batch_size,
+            train_frac=train_frac,
+            val_frac=val_frac,
+            test_frac=test_frac,
+            random_seed=random_seed,
+            inference_mode=inference_mode,
+            split_col=split_col,
+            split_save_path=split_save_path,
+            load_existing_split=load_existing_split,
         )
     else:
         var_names = adata.var_names.copy()
-        dataset = AnnDataDataset(adata, tensor_source, tensor_key, None if inference_mode else label_col)
+        dataset = AnnDataDataset(
+            adata, tensor_source, tensor_key, None if inference_mode else label_col
+        )
         if inference_mode:
             return DataLoader(dataset, batch_size=batch_size)
         else:
             train_set, val_set, test_set = split_dataset(
-                adata, dataset, train_frac, val_frac, test_frac, random_seed, 
-                split_col, split_save_path, load_existing_split
+                adata,
+                dataset,
+                train_frac,
+                val_frac,
+                test_frac,
+                random_seed,
+                split_col,
+                split_save_path,
+                load_existing_split,
             )
             train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)
             val_loader = DataLoader(val_set, batch_size=batch_size)
             test_loader = DataLoader(test_set, batch_size=batch_size)
-            return train_loader, val_loader, test_loader
+            return train_loader, val_loader, test_loader

smftools/machine_learning/data/preprocessing.py

@@ -1,6 +1,7 @@
 import numpy as np
 
+
 def random_fill_nans(X):
     nan_mask = np.isnan(X)
     X[nan_mask] = np.random.rand(*X[nan_mask].shape)
-    return X
+    return X

smftools/machine_learning/evaluation/__init__.py

@@ -1,2 +1,2 @@
+from .eval_utils import flatten_sliding_window_results
 from .evaluators import ModelEvaluator, PostInferenceModelEvaluator
-from .eval_utils import flatten_sliding_window_results

smftools/machine_learning/evaluation/eval_utils.py

@@ -1,10 +1,11 @@
 import pandas as pd
 
+
 def flatten_sliding_window_results(results_dict):
     """
     Flatten nested sliding window results into pandas DataFrame.
-    
-    Expects structure: 
+
+    Expects structure:
         results[model_name][window_size][window_center]['metrics'][metric_name]
     """
     records = []
@@ -12,20 +13,16 @@ def flatten_sliding_window_results(results_dict):
     for model_name, model_results in results_dict.items():
         for window_size, window_results in model_results.items():
             for center_var, result in window_results.items():
-                metrics = result['metrics']
-                record = {
-                    'model': model_name,
-                    'window_size': window_size,
-                    'center_var': center_var
-                }
+                metrics = result["metrics"]
+                record = {"model": model_name, "window_size": window_size, "center_var": center_var}
                 # Add all metrics
                 record.update(metrics)
                 records.append(record)
-                
+
     df = pd.DataFrame.from_records(records)
-    
+
     # Convert center_var to numeric if possible (optional but helpful for plotting)
-    df['center_var'] = pd.to_numeric(df['center_var'], errors='coerce')
-    df = df.sort_values(['model', 'window_size', 'center_var'])
-    
-    return df
+    df["center_var"] = pd.to_numeric(df["center_var"], errors="coerce")
+    df = df.sort_values(["model", "window_size", "center_var"])
+
+    return df

smftools/machine_learning/evaluation/evaluators.py

@@ -1,15 +1,21 @@
+import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import matplotlib.pyplot as plt
-
 from sklearn.metrics import (
-    roc_auc_score, precision_recall_curve, auc, f1_score, confusion_matrix, roc_curve
+    auc,
+    confusion_matrix,
+    f1_score,
+    precision_recall_curve,
+    roc_auc_score,
+    roc_curve,
 )
 
+
 class ModelEvaluator:
     """
     A model evaluator for consolidating Sklearn and Lightning model evaluation metrics on testing data
     """
+
     def __init__(self):
         self.results = []
         self.pos_freq = None
@@ -21,41 +27,45 @@ class ModelEvaluator:
         """
         if is_torch:
             entry = {
-                'name': name,
-                'f1': model.test_f1,
-                'auc': model.test_roc_auc,
-                'pr_auc': model.test_pr_auc,
-                'pr_auc_norm': model.test_pr_auc / model.test_pos_freq if model.test_pos_freq > 0 else np.nan,
-                'pr_curve': model.test_pr_curve,
-                'roc_curve': model.test_roc_curve,
-                'num_pos': model.test_num_pos,
-                'pos_freq': model.test_pos_freq
+                "name": name,
+                "f1": model.test_f1,
+                "auc": model.test_roc_auc,
+                "pr_auc": model.test_pr_auc,
+                "pr_auc_norm": model.test_pr_auc / model.test_pos_freq
+                if model.test_pos_freq > 0
+                else np.nan,
+                "pr_curve": model.test_pr_curve,
+                "roc_curve": model.test_roc_curve,
+                "num_pos": model.test_num_pos,
+                "pos_freq": model.test_pos_freq,
             }
         else:
             entry = {
-                'name': name,
-                'f1': model.test_f1,
-                'auc': model.test_roc_auc,
-                'pr_auc': model.test_pr_auc,
-                'pr_auc_norm': model.test_pr_auc / model.test_pos_freq if model.test_pos_freq > 0 else np.nan,
-                'pr_curve': model.test_pr_curve,
-                'roc_curve': model.test_roc_curve,
-                'num_pos': model.test_num_pos,
-                'pos_freq': model.test_pos_freq
+                "name": name,
+                "f1": model.test_f1,
+                "auc": model.test_roc_auc,
+                "pr_auc": model.test_pr_auc,
+                "pr_auc_norm": model.test_pr_auc / model.test_pos_freq
+                if model.test_pos_freq > 0
+                else np.nan,
+                "pr_curve": model.test_pr_curve,
+                "roc_curve": model.test_roc_curve,
+                "num_pos": model.test_num_pos,
+                "pos_freq": model.test_pos_freq,
             }
-        
+
         self.results.append(entry)
 
         if not self.pos_freq:
-            self.pos_freq = entry['pos_freq']
-            self.num_pos = entry['num_pos']
+            self.pos_freq = entry["pos_freq"]
+            self.num_pos = entry["num_pos"]
 
     def get_metrics_dataframe(self):
         """
         Return all metrics as pandas DataFrame.
         """
         df = pd.DataFrame(self.results)
-        return df[['name', 'f1', 'auc', 'pr_auc', 'pr_auc_norm', 'num_pos', 'pos_freq']]
+        return df[["name", "f1", "auc", "pr_auc", "pr_auc_norm", "num_pos", "pos_freq"]]
 
     def plot_all_curves(self):
         """
@@ -66,30 +76,31 @@ class ModelEvaluator:
         # ROC
         plt.subplot(1, 2, 1)
         for res in self.results:
-            fpr, tpr = res['roc_curve']
+            fpr, tpr = res["roc_curve"]
             plt.plot(fpr, tpr, label=f"{res['name']} (AUC={res['auc']:.3f})")
         plt.plot([0, 1], [0, 1], linestyle="--", color="gray")
         plt.xlabel("False Positive Rate")
         plt.ylabel("True Positive Rate")
-        plt.ylim(0,1.05)
+        plt.ylim(0, 1.05)
         plt.title(f"ROC Curves - {self.num_pos} positive instances")
         plt.legend()
 
         # PR
         plt.subplot(1, 2, 2)
         for res in self.results:
-            rc, pr = res['pr_curve']
+            rc, pr = res["pr_curve"]
             plt.plot(rc, pr, label=f"{res['name']} (AUPRC={res['pr_auc']:.3f})")
         plt.xlabel("Recall")
         plt.ylabel("Precision")
-        plt.ylim(0,1.05)
-        plt.axhline(self.pos_freq, linestyle='--', color='grey')
+        plt.ylim(0, 1.05)
+        plt.axhline(self.pos_freq, linestyle="--", color="grey")
         plt.title(f"Precision-Recall Curves - {self.num_pos} positive instances")
         plt.legend()
 
         plt.tight_layout()
         plt.show()
 
+
 class PostInferenceModelEvaluator:
     def __init__(self, adata, models, target_eval_freq=None, max_eval_positive=None):
         """
@@ -179,12 +190,14 @@ class PostInferenceModelEvaluator:
             "pos_freq": pos_freq,
             "confusion_matrix": cm,
             "pr_rc_curve": (pr, rc),
-            "roc_curve": (tpr, fpr)
+            "roc_curve": (tpr, fpr),
         }
 
         return metrics
-    
-    def _subsample_for_fixed_positive_frequency(self, binary_labels, target_freq=0.3, max_positive=None):
+
+    def _subsample_for_fixed_positive_frequency(
+        self, binary_labels, target_freq=0.3, max_positive=None
+    ):
         pos_idx = np.where(binary_labels == 1)[0]
         neg_idx = np.where(binary_labels == 0)[0]
 

smftools/machine_learning/inference/__init__.py

@@ -1,3 +1,3 @@
 from .lightning_inference import run_lightning_inference
+from .sklearn_inference import run_sklearn_inference
 from .sliding_window_inference import sliding_window_inference
-from .sklearn_inference import run_sklearn_inference