gsMap3D 0.1.0a1__py3-none-any.whl

gsMap/config/base.py

@@ -0,0 +1,296 @@
+"""
+Base configuration classes and utilities for gsMap.
+"""
+import inspect
+import logging
+from dataclasses import asdict, dataclass
+from enum import Enum
+from functools import wraps
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+import yaml
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+
+def config_logger():
+    logger = logging.getLogger("gsMap")
+    # clean up existing handlers
+    if logger.hasHandlers():
+        logger.handlers.clear()
+
+    # Set logger to DEBUG to capture all messages
+    logger.setLevel(logging.DEBUG)
+
+    # Create rich console handler for INFO level messages
+    console = Console()
+    rich_handler = RichHandler(
+        console=console,
+        show_time=True,
+        show_path=False,
+        rich_tracebacks=True,
+        tracebacks_show_locals=True
+    )
+    rich_handler.setLevel(logging.INFO)
+    rich_handler.setFormatter(
+        logging.Formatter("{levelname:.5s} | {name} - {message}", style="{")
+    )
+    logger.addHandler(rich_handler)
+
+    # # Create file handler for DEBUG level messages with timestamp
+    # timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    # log_dir = Path("logs")
+    # log_dir.mkdir(exist_ok=True)
+    # log_file = log_dir / f"gsMap_{timestamp}.log"
+    #
+    # file_handler = logging.FileHandler(log_file, mode='a', encoding='utf-8')
+    # file_handler.setLevel(logging.DEBUG)
+    # file_handler.setFormatter(
+    #     logging.Formatter(
+    #         "[{asctime}] {levelname:.5s} | {name}:{funcName}:{lineno} - {message}",
+    #         style="{"
+    #     )
+    # )
+    # logger.addHandler(file_handler)
+    #
+    # # Log the setup
+    # logger.info(f"Logging configured - console: INFO+, file: DEBUG+ -> {log_file}")
+    #
+    return logger
+
+config_logger()
+
+def ensure_path_exists(func):
+    """Decorator to ensure path exists when accessing properties."""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        result = func(*args, **kwargs)
+        if isinstance(result, Path):
+            if result.suffix:
+                result.parent.mkdir(parents=True, exist_ok=True, mode=0o755)
+            else:  # It's a directory path
+                result.mkdir(parents=True, exist_ok=True, mode=0o755)
+        return result
+    return wrapper
+
+@dataclass
+class BaseConfig:
+    """Base configuration class with display and conversion utility."""
+
+    def to_dict_with_paths_as_strings(self) -> dict[str, Any]:
+        """
+        Convert the config object to a dictionary with all Path objects converted to strings.
+        Also handles nested Path and Enum objects in dictionaries and lists.
+
+        Returns:
+            Dictionary representation of the config with all Path objects as strings
+        """
+        # Convert config to dict
+        config_dict = asdict(self)
+
+        # Convert all Path and Enum objects in config to strings/values
+        for key, value in config_dict.items():
+            if isinstance(value, Path):
+                config_dict[key] = str(value)
+            elif isinstance(value, Enum):
+                config_dict[key] = value.value
+            elif isinstance(value, dict):
+                config_dict[key] = {
+                    k: (str(v) if isinstance(v, Path) else (v.value if isinstance(v, Enum) else v))
+                    for k, v in value.items()
+                }
+            elif isinstance(value, list):
+                config_dict[key] = [
+                    (str(v) if isinstance(v, Path) else (v.value if isinstance(v, Enum) else v))
+                    for v in value
+                ]
+
+        return config_dict
+
+    def show_config(self, cls: type | None = None):
+        """Show configuration in a nice way using rich."""
+        if cls is not None and type(self) is not cls:
+            return
+
+        config_dict = self.to_dict_with_paths_as_strings()
+        config_yaml = yaml.dump(config_dict, default_flow_style=False, sort_keys=False)
+
+        # Get title from docstring (first line)
+        doc = inspect.getdoc(type(self))
+        title = doc.split('\n')[0] if doc else "Configuration"
+
+        console = Console()
+        console.print(Panel(
+            Syntax(config_yaml, "yaml", theme="monokai", line_numbers=True),
+            title=f"[bold]{title}[/bold]",
+            expand=False
+        ))
+
+
+@dataclass
+class ConfigWithAutoPaths(BaseConfig):
+    """Base configuration class with automatic path generation."""
+
+    # Required from parent
+    workdir: Annotated[Path, typer.Option(
+        help="Path to the working directory",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True
+    )]
+
+    project_name: Annotated[str, typer.Option(
+        help="Name of the project"
+    )]
+
+    @property
+    @ensure_path_exists
+    def project_dir(self) -> Path:
+        """The main project directory, which is workdir / project_name."""
+        return Path(self.workdir) / self.project_name
+
+    def __post_init__(self):
+        if self.workdir is None:
+            raise ValueError('workdir must be provided.')
+
+    ## ---- Find latent representation paths
+    @property
+    @ensure_path_exists
+    def latent_dir(self) -> Path:
+        return self.project_dir / "find_latent_representations"
+
+    @property
+    @ensure_path_exists
+    def model_path(self) -> Path:
+        return self.latent_dir / 'LGCN_model' / 'gsMap_LGCN_.pt'
+
+    @property
+    def find_latent_metadata_path(self) -> Path:
+        return self.latent_dir / 'find_latent_metadata.yaml'
+
+    ## ---- Latent to gene paths
+
+    @property
+    @ensure_path_exists
+    def latent2gene_dir(self) -> Path:
+        """Directory for latent to gene outputs"""
+        return self.project_dir / "latent_to_gene"
+
+    @property
+    def concatenated_latent_adata_path(self) -> Path:
+        """Path to concatenated latent representations"""
+        return self.latent2gene_dir / "concatenated_latent_adata.h5ad"
+
+    @property
+    def rank_memmap_path(self) -> Path:
+        """Path to rank zarr file"""
+        return self.latent2gene_dir / "ranks.dat"
+
+    @property
+    def mean_frac_path(self) -> Path:
+        """Path to mean expression fraction parquet"""
+        return self.latent2gene_dir / "mean_frac.parquet"
+
+    @property
+    def marker_scores_memmap_path(self) -> Path:
+        """Path to marker scores zarr"""
+        return self.latent2gene_dir / "marker_scores.dat"
+
+    @property
+    def latent2gene_metadata_path(self) -> Path:
+        """Path to latent2gene metadata YAML"""
+        return self.latent2gene_dir / "metadata.yaml"
+
+
+    ## ---- Spatial LDSC paths
+
+    @property
+    @ensure_path_exists
+    def ldsc_save_dir(self) -> Path:
+        """Directory for spatial LDSC results"""
+        return self.project_dir / "spatial_ldsc"
+
+    def get_ldsc_result_file(self, trait_name: str) -> Path:
+        return Path(f"{self.ldsc_save_dir}/{self.project_name}_{trait_name}.csv.gz")
+
+    @property
+    @ensure_path_exists
+    def ldscore_save_dir(self) -> Path:
+        """Directory for LD score generation results"""
+        return self.project_dir / "generate_ldscore"
+
+    @property
+    @ensure_path_exists
+    def cauchy_save_dir(self) -> Path:
+        return self.project_dir / "cauchy_combination"
+
+    @property
+    @ensure_path_exists
+    def report_data_dir(self) -> Path:
+        """Directory for report data files (CSV, h5ad) - not needed for HTML viewing"""
+        return self.project_dir / "report_data"
+
+    @property
+    @ensure_path_exists
+    def web_report_dir(self) -> Path:
+        """Directory for self-contained web report (HTML, JS, images)"""
+        return self.project_dir / "gsmap_web_report"
+
+    @property
+    @ensure_path_exists
+    def report_dir(self) -> Path:
+        """Directory for gsMap report outputs - returns web_report_dir for backward compatibility"""
+        return self.web_report_dir
+
+    @ensure_path_exists
+    def get_report_dir(self, trait_name: str) -> Path:
+        """Deprecated: Use report_dir property instead"""
+        return self.report_dir
+
+    def get_gsMap_report_file(self, trait_name: str) -> Path:
+        """Path to main HTML report file"""
+        return self.report_dir / "index.html"
+
+    @ensure_path_exists
+    def get_manhattan_html_plot_path(self, trait_name: str) -> Path:
+        """Path for Manhattan plot CSV data"""
+        return self.report_data_dir / "manhattan_data" / f"{trait_name}_manhattan.csv"
+
+    @ensure_path_exists
+    def get_GSS_plot_dir(self, trait_name: str) -> Path:
+        """Directory for gene diagnostic plots"""
+        return self.report_dir / "gene_diagnostic_plots"
+
+    def get_GSS_plot_select_gene_file(self, trait_name: str) -> Path:
+        return self.get_GSS_plot_dir(trait_name) / "plot_genes.csv"
+
+    @property
+    def ldsc_combined_parquet_path(self) -> Path:
+        return self.cauchy_save_dir / f"{self.project_name}_combined_ldsc.parquet"
+
+    def get_cauchy_result_file(self, trait_name: str, annotation: str | None = None, all_samples: bool = False) -> Path:
+        if annotation is None:
+            annotation = getattr(self, 'annotation', 'unknown')
+        if all_samples:
+            return self.cauchy_save_dir / f"{self.project_name}_{trait_name}.{annotation}.cauchy.csv"
+        else:
+            return self.cauchy_save_dir / f"{self.project_name}_{trait_name}.{annotation}.sample_cauchy.csv"
+
+    @ensure_path_exists
+    def get_gene_diagnostic_info_save_path(self, trait_name: str) -> Path:
+        """Path for gene diagnostic info CSV - uses trait prefix in gss_stats subfolder"""
+        return self.report_data_dir / "gss_stats" / f"gene_trait_correlation_{trait_name}.csv"
+
+    @ensure_path_exists
+    def get_gsMap_plot_save_dir(self, trait_name: str) -> Path:
+        """Directory for spatial LDSC plots"""
+        return self.report_dir / "spatial_plots"
+
+    def get_gsMap_html_plot_save_path(self, trait_name: str) -> Path:
+        """Deprecated: Spatial plots are now PNG files in spatial_plots/"""
+        return self.get_gsMap_plot_save_dir(trait_name) / f"ldsc_{trait_name}.png"

gsMap/config/cauchy_config.py

@@ -0,0 +1,79 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .base import ConfigWithAutoPaths
+from .spatial_ldsc_config import GWASSumstatsConfig
+
+
+@dataclass
+class CauchyCombinationConfig(GWASSumstatsConfig,ConfigWithAutoPaths):
+    """Cauchy Combination Configuration"""
+
+    annotation: Annotated[str | None, typer.Option(
+        help="Name of the annotation in adata.obs to use",
+    )] = None
+
+    cauchy_annotations: Annotated[list[str] | None, typer.Option(
+        help="List of annotations in adata.obs to use",
+    )] = field(default_factory=list)
+
+    annotation_list: list[str] = field(default_factory=list, init=False, repr=False)
+
+    def __post_init__(self):
+        super().__post_init__()
+        self._init_annotation_list()
+        self.show_config(CauchyCombinationConfig)
+
+    def _init_annotation_list(self):
+        """Build the unique list of annotations from 'annotation' and 'cauchy_annotations'."""
+        if not self.annotation and not self.cauchy_annotations:
+            raise ValueError("At least one of 'annotation' or 'cauchy_annotations' must be provided.")
+
+        # Build unique list of annotations
+        from collections import OrderedDict
+        self.annotation_list = []
+        if self.annotation:
+            self.annotation_list.append(self.annotation)
+        if self.cauchy_annotations:
+            self.annotation_list.extend(self.cauchy_annotations)
+        self.annotation_list = list(OrderedDict.fromkeys(self.annotation_list))
+
+
+
+    @property
+    def ldsc_traits_result_path_dict(self) -> dict[str, Path]:
+        """
+        Discover LDSC result files for the configured traits and return a dictionary mapping trait names to file paths.
+        """
+        traits_dict = {}
+
+        for trait in self.trait_name_list:
+            ldsc_input_file = self.get_ldsc_result_file(trait)
+            if ldsc_input_file.exists():
+                traits_dict[trait] = ldsc_input_file
+            else:
+                raise FileNotFoundError(f"LDSC result file not found for {trait}: {ldsc_input_file}")
+
+        if not traits_dict:
+            raise FileNotFoundError(f"No valid LDSC result files found for the specified traits in {self.ldsc_save_dir}")
+
+        return traits_dict
+
+
+def check_cauchy_done(config: CauchyCombinationConfig, trait_name: str) -> bool:
+    """
+    Check if cauchy step is done for a specific trait.
+    Checks both annotation-level and sample-level results for all configured annotations.
+    """
+    if not config.annotation_list:
+        return False
+
+    for annotation in config.annotation_list:
+        anno_result = config.get_cauchy_result_file(trait_name, annotation=annotation, all_samples=True)
+        sample_result = config.get_cauchy_result_file(trait_name, annotation=annotation, all_samples=False)
+        if not (anno_result.exists() and sample_result.exists()):
+            return False
+    return True

gsMap/config/dataclasses.py

@@ -0,0 +1,235 @@
+"""
+Configuration dataclasses for gsMap commands.
+"""
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .base import ConfigWithAutoPaths
+
+# Import module-specific configs for orchestration
+from .find_latent_config import FindLatentRepresentationsConfig
+from .latent2gene_config import LatentToGeneConfig
+from .spatial_ldsc_config import SpatialLDSCConfig
+from .utils import (
+    verify_homolog_file_format,
+)
+
+logger = logging.getLogger("gsMap.config")
+
+@dataclass
+class CreateSliceMeanConfig:
+    """Configuration for creating slice mean from multiple h5ad files."""
+
+    slice_mean_output_file: Annotated[Path, typer.Option(
+        help="Path to the output file for the slice mean",
+        dir_okay=False,
+        resolve_path=True
+    )]
+
+    sample_name_list: Annotated[str | list[str], typer.Option(
+        help="Space-separated list of sample names"
+    )]
+
+    h5ad_list: Annotated[str | list[str], typer.Option(
+        help="Space-separated list of h5ad file paths"
+    )]
+
+    # Optional parameters
+    h5ad_yaml: Annotated[Path | None, typer.Option(
+        help="Path to YAML file with sample names and h5ad paths",
+        exists=True,
+        file_okay=True,
+        dir_okay=False
+    )] = None
+
+    homolog_file: Annotated[Path | None, typer.Option(
+        help="Path to homologous gene conversion file",
+        exists=True,
+        file_okay=True,
+        dir_okay=False
+    )] = None
+
+    data_layer: Annotated[str, typer.Option(
+        help="Data layer for gene expression"
+    )] = "counts"
+
+    species: str | None = None
+    h5ad_dict: dict | None = None
+
+    def __post_init__(self):
+        # Parse lists if provided as strings
+        if isinstance(self.sample_name_list, str):
+            self.sample_name_list = self.sample_name_list.split()
+        if isinstance(self.h5ad_list, str):
+            self.h5ad_list = self.h5ad_list.split()
+
+        if self.h5ad_list is None and self.h5ad_yaml is None:
+            raise ValueError("At least one of --h5ad_list or --h5ad_yaml must be provided.")
+
+        import yaml
+        if self.h5ad_yaml is not None:
+            if isinstance(self.h5ad_yaml, str | Path):
+                logger.info(f"Reading h5ad yaml file: {self.h5ad_yaml}")
+                with open(self.h5ad_yaml) as f:
+                    h5ad_dict = yaml.safe_load(f)
+            else:
+                h5ad_dict = self.h5ad_yaml
+        elif self.sample_name_list and self.h5ad_list:
+            logger.info("Reading sample name list and h5ad list")
+            h5ad_dict = dict(zip(self.sample_name_list, self.h5ad_list, strict=False))
+        else:
+            raise ValueError(
+                "Please provide either h5ad_yaml or both sample_name_list and h5ad_list."
+            )
+
+        # Check if sample names are unique
+        assert len(h5ad_dict) == len(set(h5ad_dict)), "Sample names must be unique."
+        assert len(h5ad_dict) > 1, "At least two samples are required."
+
+        logger.info(f"Input h5ad files: {h5ad_dict}")
+
+        # Check if all files exist
+        self.h5ad_dict = {}
+        for sample_name, h5ad_file in h5ad_dict.items():
+            h5ad_file = Path(h5ad_file)
+            if not h5ad_file.exists():
+                raise FileNotFoundError(f"{h5ad_file} does not exist.")
+            self.h5ad_dict[sample_name] = h5ad_file
+
+        self.slice_mean_output_file = Path(self.slice_mean_output_file)
+        self.slice_mean_output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Verify homolog file format if provided
+        if self.homolog_file is not None:
+            verify_homolog_file_format(self)
+
+
+
+@dataclass
+class DiagnosisConfig(ConfigWithAutoPaths):
+    """Configuration for diagnosis command."""
+    trait_name: Annotated[str, typer.Option(help="Name of the trait")]
+    annotation: Annotated[str, typer.Option(help="Annotation layer name")]
+
+    sumstats_file: Annotated[Path | None, typer.Option(
+        help="Path to GWAS summary statistics file",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        resolve_path=True
+    )] = None
+
+    top_corr_genes: Annotated[int, typer.Option(help="Number of top correlated genes to display")] = 50
+    selected_genes: Annotated[str | None, typer.Option(help="Comma-separated list of specific genes to include")] = None
+
+    fig_width: Annotated[int | None, typer.Option(help="Width of figures")] = None
+    fig_height: Annotated[int | None, typer.Option(help="Height of figures")] = None
+    point_size: Annotated[int | None, typer.Option(help="Point size")] = None
+
+    plot_type: Annotated[str, typer.Option(help="Plot type (gsMap, manhattan, GSS, all)")] = "all"
+    plot_origin: Annotated[str, typer.Option(help="Plot origin for spatial plots (upper or lower)")] = "upper"
+
+    @property
+    def customize_fig(self) -> bool:
+        return any([self.fig_width, self.fig_height, self.point_size])
+
+    @property
+    def hdf5_with_latent_path(self) -> Path:
+        return self.concatenated_latent_adata_path
+
+    @property
+    def mkscore_feather_path(self) -> Path:
+        # Fallback to a default name in the latent2gene directory
+        return self.latent2gene_dir / f"{self.project_name}_marker_score.feather"
+
+
+@dataclass
+class VisualizeConfig(ConfigWithAutoPaths):
+    """Configuration for visualization command."""
+    trait_name: Annotated[str, typer.Option(help="Name of the trait")]
+    annotation: Annotated[str | None, typer.Option(help="Annotation layer name")] = None
+
+    fig_title: Annotated[str | None, typer.Option(help="Title for the figure")] = None
+    fig_style: Annotated[str, typer.Option(help="Style of the figures (light/dark)")] = "light"
+    point_size: Annotated[int | None, typer.Option(help="Point size")] = None
+    fig_width: Annotated[int, typer.Option(help="Figure width")] = 800
+    fig_height: Annotated[int, typer.Option(help="Figure height")] = 600
+
+    output_dir: Annotated[Path | None, typer.Option(help="Directory to save output files")] = None
+    hdf5_with_latent_path: Annotated[Path | None, typer.Option(help="Path to HDF5 with latent")] = None
+    plot_origin: Annotated[str, typer.Option(help="Plot origin for spatial plots (upper or lower)")] = "upper"
+
+    def __post_init__(self):
+        super().__post_init__()
+        if self.hdf5_with_latent_path is None:
+            self.hdf5_with_latent_path = self.concatenated_latent_adata_path
+        if self.output_dir is None:
+            self.output_dir = self.get_report_dir(self.trait_name)
+
+
+@dataclass
+class ThreeDCombineConfig:
+    workdir: str
+    trait_name: str | None = None
+    adata_3d: str | None = None
+    project_name: str | None = None
+    st_id: str | None = None
+    annotation: str | None = None
+    spatial_key: str = 'spatial'
+    cmap: str | None = None
+    point_size: float = 0.01
+    background_color: str = 'white'
+    n_snapshot: int = 200
+    show_outline: bool = False
+    save_mp4: bool = False
+    save_gif: bool = False
+
+    def __post_init__(self):
+        if self.workdir is None:
+            raise ValueError('workdir must be provided.')
+        work_dir = Path(self.workdir)
+        if self.project_name is not None:
+            self.project_dir = work_dir / self.project_name
+        else:
+            self.project_dir = work_dir
+
+
+@dataclass
+class RunLinkModeConfig(ConfigWithAutoPaths):
+    """Configuration for running gsMap with linked mode."""
+    # Placeholder for link mode config fields
+    pass
+
+
+@dataclass
+class gsMapPipelineConfig(ConfigWithAutoPaths):
+    """Unified configuration for the complete gsMap pipeline"""
+
+    # Component configurations
+    find_latent: FindLatentRepresentationsConfig | None = None
+    latent2gene: LatentToGeneConfig | None = None
+    spatial_ldsc: SpatialLDSCConfig | None = None
+
+    def __post_init__(self):
+        super().__post_init__()
+        # Initialize component configs if they weren't provided
+        if self.find_latent is None:
+            self.find_latent = FindLatentRepresentationsConfig(
+                workdir=self.workdir,
+                project_name=self.project_name
+            )
+        if self.latent2gene is None:
+            self.latent2gene = LatentToGeneConfig(
+                workdir=self.workdir,
+                project_name=self.project_name
+            )
+        if self.spatial_ldsc is None:
+            self.spatial_ldsc = SpatialLDSCConfig(
+                workdir=self.workdir,
+                project_name=self.project_name
+            )