opencode-knowledge-work 0.0.0-stage → 0.1.1

package/content/bio-research/skills/bio-research-nextflow-development/scripts/utils/__init__.py

@@ -0,0 +1,69 @@
+"""
+Utility modules for nf-core pipeline deployment.
+
+Modules:
+    ncbi_utils: NCBI/GEO/SRA data fetching and download utilities
+    file_discovery: Find FASTQ, BAM, and CRAM files
+    sample_inference: Extract sample info, detect tumor/normal
+    validators: Validate samplesheets before writing
+"""
+
+# NCBI utilities for GEO/SRA data acquisition
+from .ncbi_utils import (
+    check_network_access,
+    fetch_geo_metadata,
+    fetch_sra_study_accession,
+    fetch_sra_run_info,
+    fetch_sra_run_info_detailed,
+    fetch_bioproject_from_geo,
+    fetch_ena_fastq_urls,
+    download_file,
+    fetch_pubmed_metadata,
+    format_file_size,
+    estimate_download_size,
+    group_samples_by_type,
+    format_sample_groups_table,
+)
+
+# File discovery utilities
+from .file_discovery import discover_files, FileInfo, count_files_by_type
+
+# Sample inference utilities
+from .sample_inference import (
+    extract_sample_info,
+    infer_tumor_normal_status,
+    match_read_pairs,
+    extract_replicate_number
+)
+
+# Validation utilities
+from .validators import validate_samplesheet, ValidationResult
+
+__all__ = [
+    # ncbi_utils
+    'check_network_access',
+    'fetch_geo_metadata',
+    'fetch_sra_study_accession',
+    'fetch_sra_run_info',
+    'fetch_sra_run_info_detailed',
+    'fetch_bioproject_from_geo',
+    'fetch_ena_fastq_urls',
+    'download_file',
+    'fetch_pubmed_metadata',
+    'format_file_size',
+    'estimate_download_size',
+    'group_samples_by_type',
+    'format_sample_groups_table',
+    # file_discovery
+    'discover_files',
+    'FileInfo',
+    'count_files_by_type',
+    # sample_inference
+    'extract_sample_info',
+    'infer_tumor_normal_status',
+    'match_read_pairs',
+    'extract_replicate_number',
+    # validators
+    'validate_samplesheet',
+    'ValidationResult',
+]

package/content/bio-research/skills/bio-research-nextflow-development/scripts/utils/file_discovery.py

@@ -0,0 +1,189 @@
+"""
+File discovery utilities for FASTQ, BAM, and CRAM files.
+
+This module provides functions to recursively discover sequencing data files
+in a directory structure.
+"""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+@dataclass
+class FileInfo:
+    """Information about a discovered file."""
+    path: str
+    name: str
+    stem: str
+    extension: str
+    size: int
+    file_type: str  # fastq, bam, cram
+
+    def __repr__(self):
+        return f"FileInfo({self.name}, type={self.file_type})"
+
+
+# Supported file extensions by type
+EXTENSIONS = {
+    "fastq": [".fastq.gz", ".fq.gz", ".fastq", ".fq"],
+    "bam": [".bam"],
+    "cram": [".cram"],
+}
+
+# Index file extensions
+INDEX_EXTENSIONS = {
+    "bam": [".bam.bai", ".bai"],
+    "cram": [".cram.crai", ".crai"],
+}
+
+
+def discover_files(
+    directory: str,
+    file_type: str = "fastq",
+    follow_symlinks: bool = True
+) -> List[FileInfo]:
+    """
+    Recursively discover files of specified type.
+
+    Args:
+        directory: Root directory to search
+        file_type: One of 'fastq', 'bam', 'cram'
+        follow_symlinks: Whether to follow symbolic links
+
+    Returns:
+        List of FileInfo objects sorted by path
+    """
+    if file_type not in EXTENSIONS:
+        raise ValueError(f"Unknown file type: {file_type}. Supported: {list(EXTENSIONS.keys())}")
+
+    directory = os.path.abspath(directory)
+    if not os.path.isdir(directory):
+        raise ValueError(f"Not a directory: {directory}")
+
+    extensions = EXTENSIONS[file_type]
+    files = []
+    seen_paths = set()  # Avoid duplicates from symlinks
+
+    for root, _, filenames in os.walk(directory, followlinks=follow_symlinks):
+        for filename in filenames:
+            # Check each extension
+            for ext in extensions:
+                if filename.lower().endswith(ext.lower()):
+                    full_path = os.path.join(root, filename)
+
+                    # Resolve to handle symlinks
+                    try:
+                        real_path = os.path.realpath(full_path)
+                    except OSError:
+                        real_path = full_path
+
+                    if real_path in seen_paths:
+                        continue
+                    seen_paths.add(real_path)
+
+                    try:
+                        size = os.path.getsize(full_path)
+                    except OSError:
+                        size = 0
+
+                    # Extract stem (remove extension)
+                    stem = filename
+                    for e in extensions:
+                        if stem.lower().endswith(e.lower()):
+                            stem = stem[:-len(e)]
+                            break
+
+                    files.append(FileInfo(
+                        path=full_path,
+                        name=filename,
+                        stem=stem,
+                        extension=ext,
+                        size=size,
+                        file_type=file_type
+                    ))
+                    break  # Found matching extension, no need to check others
+
+    return sorted(files, key=lambda f: f.path)
+
+
+def count_files_by_type(directory: str) -> Dict[str, int]:
+    """
+    Count files by type in directory.
+
+    Args:
+        directory: Directory to scan
+
+    Returns:
+        Dict mapping file_type to count
+    """
+    counts = {}
+    for file_type in EXTENSIONS:
+        try:
+            files = discover_files(directory, file_type)
+            counts[file_type] = len(files)
+        except (ValueError, PermissionError):
+            counts[file_type] = 0
+    return counts
+
+
+def find_index_file(alignment_file: str) -> Optional[str]:
+    """
+    Find index file for a BAM or CRAM file.
+
+    Args:
+        alignment_file: Path to BAM or CRAM file
+
+    Returns:
+        Path to index file if found, None otherwise
+    """
+    path = Path(alignment_file)
+
+    # Determine file type
+    if path.suffix.lower() == ".bam":
+        index_exts = INDEX_EXTENSIONS["bam"]
+    elif path.suffix.lower() == ".cram":
+        index_exts = INDEX_EXTENSIONS["cram"]
+    else:
+        return None
+
+    # Try common index file patterns
+    for ext in index_exts:
+        # Pattern: file.bam.bai or file.bai
+        if ext.startswith(".bam") or ext.startswith(".cram"):
+            candidate = Path(str(path) + ext.split(".")[-1])
+        else:
+            candidate = path.with_suffix(ext)
+
+        if candidate.exists():
+            return str(candidate)
+
+        # Also try: file.bam -> file.bam.bai
+        candidate = Path(str(path) + "." + ext.lstrip("."))
+        if candidate.exists():
+            return str(candidate)
+
+    return None
+
+
+def detect_input_type(directory: str) -> str:
+    """
+    Auto-detect predominant input file type in directory.
+
+    Prioritizes: FASTQ > BAM > CRAM
+
+    Args:
+        directory: Directory to scan
+
+    Returns:
+        Detected file type ('fastq', 'bam', or 'cram')
+    """
+    counts = count_files_by_type(directory)
+
+    # Prioritize by preference
+    for file_type in ["fastq", "bam", "cram"]:
+        if counts.get(file_type, 0) > 0:
+            return file_type
+
+    return "fastq"  # Default