smftools 0.2.4__py3-none-any.whl → 0.3.0__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,23 @@
-from . import models
-from . import data
-from . import utils
-from . import evaluation
-from . import inference
-from . import training
-
-__all__ = [
-    "calculate_relative_risk_on_activity",
-    "evaluate_models_by_subgroup",
-    "prepare_melted_model_data",
-]
+from __future__ import annotations
+
+from importlib import import_module
+
+_LAZY_MODULES = {
+    "data": "smftools.machine_learning.data",
+    "evaluation": "smftools.machine_learning.evaluation",
+    "inference": "smftools.machine_learning.inference",
+    "models": "smftools.machine_learning.models",
+    "training": "smftools.machine_learning.training",
+    "utils": "smftools.machine_learning.utils",
+}
+
+
+def __getattr__(name: str):
+    if name in _LAZY_MODULES:
+        module = import_module(_LAZY_MODULES[name])
+        globals()[name] = module
+        return module
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+__all__ = list(_LAZY_MODULES.keys())

smftools/machine_learning/data/__init__.py

@@ -1,2 +1,4 @@
+from __future__ import annotations
+
 from .anndata_data_module import AnnDataModule, build_anndata_loader
 from .preprocessing import random_fill_nans

smftools/machine_learning/data/anndata_data_module.py

@@ -1,24 +1,48 @@
-import torch
-from torch.utils.data import DataLoader, TensorDataset, random_split, Dataset, Subset
-import pytorch_lightning as pl
+from __future__ import annotations
+
 import numpy as np
 import pandas as pd
+
+from smftools.optional_imports import require
+
 from .preprocessing import random_fill_nans
-from sklearn.utils.class_weight import compute_class_weight
 
-    
+pl = require("pytorch_lightning", extra="ml-extended", purpose="Lightning data modules")
+torch = require("torch", extra="ml-base", purpose="ML data loading")
+sklearn_class_weight = require(
+    "sklearn.utils.class_weight",
+    extra="ml-base",
+    purpose="class weighting",
+)
+torch_utils_data = require("torch.utils.data", extra="ml-base", purpose="ML data loading")
+
+compute_class_weight = sklearn_class_weight.compute_class_weight
+DataLoader = torch_utils_data.DataLoader
+Dataset = torch_utils_data.Dataset
+Subset = torch_utils_data.Subset
+
+
 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 +53,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 +71,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 +84,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 +119,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 +136,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 +183,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 +265,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 +280,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 +302,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,9 @@
+from __future__ import annotations
+
 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,4 @@
+from __future__ import annotations
+
+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,13 @@
+from __future__ import annotations
+
 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 +15,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