From cbd99ab10960062be58dcdc736958412d95a4eb0 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Thu, 27 Nov 2025 10:20:31 -0800
Subject: [PATCH 01/87] remove excel section

---
 book/workflows.md | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index 7955729..1717223 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -5,26 +5,19 @@
 https://workflowhub.eu/
 
 
-### Russ's First Law of Scientific Data Management
+ - use narps as the working example 
 
-> "Don't use spreadsheets to manage scientific data."
+ 
+## Simple workflow management with Makefiles
 
-In this chapter I will talk in detail about best practices for data management, but I start by discussing a data management "anti-pattern", which is the use of spreadsheets for data management.  Spreadsheet software such as Microsoft Excel is commonly used by researchers for all sorts of data management and processing operations.  Why are spreadsheets problematic?
 
-- They encourage manual manipulation of the data, which makes the operations non-reproducible by definition.
-- Spreadsheet tools will often automatically format data, sometimes changing things in important but unwanted ways.  For example, gene names such as "SEPT2" and "MARCH1" are converted to dates by Microsoft Excel, and some accession numbers (e.g. "2310009E13") are converted to floating point numbers.  An analysis of published genomics papers {cite:p}`Ziemann:2016aa` found that roughly twenty percent of supplementary gene lists created using Excel contained errors in gene names due to these conversions.
-- It is very easy to make errors when performing operations on a spreadsheet, and these errors can often go unnoticed.  A well known example occurred in the paper  ["Growth in the time of debt"](https://www.nber.org/papers/w15639) by the prominent economists Carmen Reinhart and Kenneth Rogoff. This paper claimed to have found that high levels of national debt led to decreased economic growth, and was used as a basis for promoting austerity programs after the 2008 financial crisis.  However, [researchers subsequently discovered](https://academic.oup.com/cje/article/38/2/257/1714018) that the authors had made an error in their Excel spreadsheet, excluding data from several countries; when the full data were used, the relationship between growth and debt became much weaker. 
-- Spreadsheet software can sometimes have limitations that can cause problems.  For example, the use of an outdated Microsoft Excel file format (.xls) [caused underreporting of COVID-19 cases](https://www.bbc.com/news/technology-54423988) due to limitations on the number of rows in that file format, and the lack of any warnings when additional rows in the imported data files were ignored.
-- Spreadsheets do not easily lend themselves to version control and change tracking, although some spreadsheet tools (such as Google Sheets) do provide the ability to clearly label versions of the data.
+## Workflow management systems for complex workflows
 
-I will occasionally use Microsoft Excel to examine a data file, but I think that spreadsheet tools should *never* be used as part of a scientific data workflow.
 
+## Building a workflow management system from scratch
 
 
-## Simple workflow management with Makefiles
 
-
-## Workflow management systems for complex workflows
+## Tracking provenance
 
 
-## Building a workflow management system from scratch

From 5887fa597ac9e638aacce8d4f041aae4afa3031c Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Fri, 28 Nov 2025 09:40:56 -0800
Subject: [PATCH 02/87] initial section on desiderata

---
 book/workflows.md | 122 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 120 insertions(+), 2 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index 1717223..1b56b8e 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -1,5 +1,85 @@
 # Workflow Management
 
+In most parts of science today, data processing and analysis comprises many different steps.  We will refer to such a set of steps as a computational *workflow* (or, interchangeably, *pipeline*). If you have been doing science for very long, you have very likely encountered a *mega-script* that implements such a workflow. Usually written in a scripting language like *Bash*, this is a script that may be hundreds or even thousands of lines long that runs a single workflow from start to end.  Often these scripts are handed down to new trainees over generations, such that users become afraid to make any changes lest the entire house of cards comes crashing down.  I think that most of us can agree that this is not an optimal workflow, and in this chapter I will discuss in detail how to move from a mega-script to a workflow that will meet all of the requirements that are required to provide robust and reliable answers to our scientific questions.
+
+## What do we want from a scientific workflow?
+
+First let's ask: What do we want from a computational scientific workflow?  Here are some of the factors that I think are important.  First, we care about the *correctness* of the workflow, which includes the following factors:
+
+- *Verifiability*:  The workflow includes validation procedures to ensure against known problems or edge cases.
+- *Reproducibility*:  The workflow can be rerun from scratch on the same data and get the same answer, at least within the limits of uncontrollable factors such as floating point imprecision.
+- *Robustness*: When there is a problem, the workflow fails quickly with explicit error messages, or degrades gracefully when possible.
+
+Second, we care about the *usability* of the workflow. Factors related to usability include:
+
+- *Configurability*: The workflow uses smart defaults, but allows the user to easily change the configuration in a way that is traceable.
+- *Parameterizability*: Multiple runs of the workflow can be executed with different parameters, and the separate outputs can be tracked.
+- *Standards compliance*:  The workflow leverages common standards to easily read in data and generates output using community standards for file formats and organization when available.
+
+Third, we care about the *engineering quality* of the code, which includes:
+
+- *Maintainability*: The workflow is structured and documented so that others (including your future self) can easily maintain, update, and extend it in the future.
+- *Modularity*: The workflow is composed of a set of independently testable modules, which can be swapped in or out relatively easily.
+- *Idempotency*: This term from computer science means that running the workflow multiple times gives the same result as running it once, which allows safely rerunning the workflow when there is a failure.
+- *Traceability*:  All operations are logged, and provenance information is stored for outputs.
+
+Finally, we care about the *efficiency* of the workflow implementation. This includes:
+
+- *Incremental execution*: The workflow only reruns a module if necessary, such as when an input changes.
+- *Amortized computation*: The workflow pre-computes and reuses results from expensive operations when possible.
+
+It's worth noting that these different desiderata will sometimes conflict with one another (such as configurability versus maintainability), and that no workflow will be perfect.  
+
+
+
+### Breaking a workflow into stages
+
+good breakpoints between workflow modules include:
+
+- conceptual logic - different stages do different things 
+- points where one might need to restart the computation (e.g. due to computational cost)
+- sections where one might wish to swap in a new method
+- points where the output could be reusable elsewhere
+
+the workflow should be stateless when possible
+
+- allows each state to be run independently
+
+but sometimes state is required
+
+- e.g. training a neural network, one needs to know where you are in the process
+
+
+
+## Modularity and reusability
+
+- separate analysis logic from workflow orchestration
+- analysis modules should be tested (e.g. with synthetic data)
+
+
+
+## Idempotency
+
+- running it multiple time should give same answer as running it once
+- 
+
+## Precomputing expensive/common operations
+
+
+## Tracking provenance
+
+
+
+### Configuration management
+
+- how to configure a workflow
+
+    - configuration files
+    - command line arguments
+    - defaults
+
+- interaction with provenance
+
 - discuss fit-transform model somewhere
 
 https://workflowhub.eu/
@@ -7,17 +87,55 @@ https://workflowhub.eu/
 
  - use narps as the working example 
 
+
+## Error handling and robustness
+
+- Fail fast
+- Gracefully handle missing data
+- Checkpointing for long-running workflows
+- write tests for common edge cases
+  - use a small toy dataset for testing
+- unit vs integration tests
+
+
+## Logging
+
+
  
 ## Simple workflow management with Makefiles
 
 
+
+## Python workflow management with checkpoints
+
+
+
 ## Workflow management systems for complex workflows
 
+- introduce DAGs
 
-## Building a workflow management system from scratch
+- general purpose vs domain specific
+    - overview various engines
 
 
 
-## Tracking provenance
 
+## Scaling workflows
+
+- maybe leave this to the HPC chapter?
+
+
+## FAIR-inspired practices for workflows
+    - FAIR workflows 
+        - https://pmc.ncbi.nlm.nih.gov/articles/PMC10538699/
+        - https://www.nature.com/articles/s41597-025-04451-9
+        - this seems really heavyweight.  
+    - 80/20 approach to reproducible workflows
+        - version control + documentation
+        - requirements file or container
+        - clear workflow structure
+        - standard file formats
+    - The full FAIR approach may be necessary in some contexts
+
+    
 

From 18e0e9a9da0e9c638078f4f80f13b86945b7068e Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 09:08:52 -0800
Subject: [PATCH 03/87] initial add

---
 tests/narps/test_bids.py | 267 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 267 insertions(+)
 create mode 100644 tests/narps/test_bids.py

diff --git a/tests/narps/test_bids.py b/tests/narps/test_bids.py
new file mode 100644
index 0000000..40f0540
--- /dev/null
+++ b/tests/narps/test_bids.py
@@ -0,0 +1,267 @@
+"""Tests for BIDS utility functions."""
+
+import pytest
+from pathlib import Path
+import tempfile
+import shutil
+
+from BetterCodeBetterScience.narps.bids_utils import (
+    parse_bids_filename,
+    find_bids_files,
+)
+
+
+# Tests for parse_bids_filename
+
+
+def test_parse_bids_filename_basic_string():
+    """Test parsing a basic BIDS filename from a string."""
+    filename = "sub-01_task-rest_bold.nii.gz"
+    result = parse_bids_filename(filename)
+    
+    assert result['sub'] == '01'
+    assert result['task'] == 'rest'
+    assert result['suffix'] == 'bold'
+    assert 'path' in result
+    assert result['path'] == filename
+
+
+def test_parse_bids_filename_path_object():
+    """Test parsing a BIDS filename from a Path object."""
+    filepath = Path("/data/sub-02_ses-01_T1w.nii.gz")
+    result = parse_bids_filename(filepath)
+    
+    assert result['sub'] == '02'
+    assert result['ses'] == '01'
+    assert result['suffix'] == 'T1w'
+    assert result['path'] == str(filepath)
+
+
+def test_parse_bids_filename_complex():
+    """Test parsing a complex BIDS filename with multiple entities."""
+    filename = "sub-01_ses-02_task-rest_acq-mb_run-01_bold.nii.gz"
+    result = parse_bids_filename(filename)
+    
+    assert result['sub'] == '01'
+    assert result['ses'] == '02'
+    assert result['task'] == 'rest'
+    assert result['acq'] == 'mb'
+    assert result['run'] == '01'
+    assert result['suffix'] == 'bold'
+
+
+def test_parse_bids_filename_with_hyphen_in_value():
+    """Test parsing when a value contains a hyphen."""
+    filename = "sub-control-01_task-go-nogo_bold.nii"
+    result = parse_bids_filename(filename)
+    
+    # Should split only on first hyphen
+    assert result['sub'] == 'control-01'
+    assert result['task'] == 'go-nogo'
+    assert result['suffix'] == 'bold'
+
+
+def test_parse_bids_filename_narps_format():
+    """Test parsing NARPS-specific filename format."""
+    filename = "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz"
+    result = parse_bids_filename(filename)
+    
+    assert result['sub'] == 'team01'
+    assert result['hyp'] == '1'
+    assert result['type'] == 'thresh'
+    assert result['desc'] == 'orig'
+    assert result['suffix'] == 'stat'
+
+
+def test_parse_bids_filename_with_full_path():
+    """Test parsing with a full absolute path."""
+    filepath = Path("/home/user/data/sub-03_T2w.nii.gz")
+    result = parse_bids_filename(filepath)
+    
+    assert result['sub'] == '03'
+    assert result['suffix'] == 'T2w'
+    assert result['path'] == str(filepath)
+    # Should only parse the filename, not the directory
+    assert 'home' not in result
+    assert 'user' not in result
+
+
+def test_parse_bids_filename_minimal():
+    """Test parsing a minimal BIDS filename."""
+    filename = "sub-01_bold.nii"
+    result = parse_bids_filename(filename)
+    
+    assert result['sub'] == '01'
+    assert result['suffix'] == 'bold'
+    assert len(result) == 3  # sub, suffix, path
+
+
+def test_parse_bids_filename_no_extension():
+    """Test parsing a filename without extension."""
+    filename = "sub-01_task-rest_bold"
+    result = parse_bids_filename(filename)
+    
+    assert result['sub'] == '01'
+    assert result['task'] == 'rest'
+    assert result['suffix'] == 'bold'
+
+
+# Tests for find_bids_files
+
+
+@pytest.fixture
+def temp_bids_dir():
+    """Create a temporary BIDS-like directory structure for testing."""
+    tmpdir = tempfile.mkdtemp()
+    basedir = Path(tmpdir)
+    
+    # Create test files
+    files = [
+        "sub-01_task-rest_bold.nii.gz",
+        "sub-01_task-rest_T1w.nii.gz",
+        "sub-01_task-memory_bold.nii.gz",
+        "sub-02_task-rest_bold.nii.gz",
+        "sub-02_task-memory_bold.nii.gz",
+        "sub-03_ses-01_task-rest_bold.nii.gz",
+        "sub-03_ses-02_task-rest_bold.nii.gz",
+    ]
+    
+    for filename in files:
+        filepath = basedir / filename
+        filepath.touch()
+    
+    yield basedir
+    
+    # Cleanup
+    shutil.rmtree(tmpdir)
+
+
+def test_find_bids_files_single_tag(temp_bids_dir):
+    """Test finding files with a single BIDS tag."""
+    results = find_bids_files(temp_bids_dir, sub='01')
+    
+    assert len(results) == 3
+    assert all('sub-01' in r.name for r in results)
+
+
+def test_find_bids_files_multiple_tags(temp_bids_dir):
+    """Test finding files with multiple BIDS tags."""
+    results = find_bids_files(temp_bids_dir, sub='01', task='rest')
+    
+    assert len(results) == 2
+    filenames = [r.name for r in results]
+    assert "sub-01_task-rest_bold.nii.gz" in filenames
+    assert "sub-01_task-rest_T1w.nii.gz" in filenames
+
+
+def test_find_bids_files_with_suffix(temp_bids_dir):
+    """Test finding files filtered by suffix."""
+    results = find_bids_files(temp_bids_dir, suffix='bold')
+    
+    assert len(results) == 6
+    assert all('bold' in r.name for r in results)
+
+
+def test_find_bids_files_no_matches(temp_bids_dir):
+    """Test finding files when no matches exist."""
+    results = find_bids_files(temp_bids_dir, sub='99')
+    
+    assert len(results) == 0
+
+
+def test_find_bids_files_all_tags_must_match(temp_bids_dir):
+    """Test that all specified tags must match."""
+    results = find_bids_files(temp_bids_dir, sub='01', task='rest', suffix='bold')
+    
+    assert len(results) == 1
+    assert results[0].name == "sub-01_task-rest_bold.nii.gz"
+
+
+def test_find_bids_files_with_session(temp_bids_dir):
+    """Test finding files with session tag."""
+    results = find_bids_files(temp_bids_dir, sub='03', ses='01')
+    
+    assert len(results) == 1
+    assert results[0].name == "sub-03_ses-01_task-rest_bold.nii.gz"
+
+
+def test_find_bids_files_string_basedir(temp_bids_dir):
+    """Test that basedir can be a string."""
+    results = find_bids_files(str(temp_bids_dir), sub='02')
+    
+    assert len(results) == 2
+    assert all('sub-02' in r.name for r in results)
+
+
+def test_find_bids_files_no_tags(temp_bids_dir):
+    """Test finding files with no tag filters returns all files."""
+    results = find_bids_files(temp_bids_dir)
+    
+    assert len(results) == 7
+
+
+def test_find_bids_files_nonexistent_tag(temp_bids_dir):
+    """Test filtering by a tag that doesn't exist in any files."""
+    results = find_bids_files(temp_bids_dir, run='01')
+    
+    assert len(results) == 0
+
+
+@pytest.fixture
+def temp_narps_dir():
+    """Create a temporary NARPS-like directory structure."""
+    tmpdir = tempfile.mkdtemp()
+    basedir = Path(tmpdir)
+    
+    # Create NARPS-style test files
+    files = [
+        "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz",
+        "sub-team01_hyp-1_type-unthresh_desc-orig_stat.nii.gz",
+        "sub-team01_hyp-2_type-thresh_desc-orig_stat.nii.gz",
+        "sub-team02_hyp-1_type-thresh_desc-orig_stat.nii.gz",
+        "sub-team02_hyp-1_type-thresh_desc-rect_stat.nii.gz",
+    ]
+    
+    for filename in files:
+        filepath = basedir / filename
+        filepath.touch()
+    
+    yield basedir
+    
+    shutil.rmtree(tmpdir)
+
+
+def test_find_bids_files_narps_format(temp_narps_dir):
+    """Test finding NARPS-formatted files."""
+    results = find_bids_files(temp_narps_dir, sub='team01', hyp='1')
+    
+    assert len(results) == 2
+
+
+def test_find_bids_files_narps_by_type(temp_narps_dir):
+    """Test finding NARPS files by type."""
+    results = find_bids_files(temp_narps_dir, type='thresh')
+    
+    assert len(results) == 4
+
+
+def test_find_bids_files_narps_by_desc(temp_narps_dir):
+    """Test finding NARPS files by description."""
+    results = find_bids_files(temp_narps_dir, desc='rect')
+    
+    assert len(results) == 1
+    assert results[0].name == "sub-team02_hyp-1_type-thresh_desc-rect_stat.nii.gz"
+
+
+def test_find_bids_files_narps_complex_filter(temp_narps_dir):
+    """Test complex filtering on NARPS files."""
+    results = find_bids_files(
+        temp_narps_dir, 
+        sub='team01', 
+        hyp='1', 
+        type='thresh',
+        desc='orig'
+    )
+    
+    assert len(results) == 1
+    assert results[0].name == "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz"

From 9b5f867795a39192afd4cdf2bbee2e194da9201b Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 10:28:11 -0800
Subject: [PATCH 04/87] add summary function

---
 .../narps/bids_utils.py                       | 229 ++++++++++++++++++
 1 file changed, 229 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/narps/bids_utils.py

diff --git a/src/BetterCodeBetterScience/narps/bids_utils.py b/src/BetterCodeBetterScience/narps/bids_utils.py
new file mode 100644
index 0000000..1a41efe
--- /dev/null
+++ b/src/BetterCodeBetterScience/narps/bids_utils.py
@@ -0,0 +1,229 @@
+from typing import Dict, List, Union
+from pathlib import Path
+
+
+def parse_bids_filename(filename) -> Dict[str, str]:
+    """
+    Parse a BIDS-like filename into its components.
+
+    Parameters
+    ----------
+    filename : str or Path
+        BIDS-like filename (string or Path object)
+
+    Returns
+    -------
+    dict
+        Dictionary with components of the filename, including 'path' key
+    """
+    if isinstance(filename, str):
+        filepath = Path(filename)
+    else:
+        filepath = filename
+    
+    base = filepath.name
+    parts = base.split('_')
+    # take the last element which is the suffix
+    suffix = parts[-1].split('.')[0]
+    parts = parts[:-1]  # remove suffix part
+    components = {'path': str(filepath), 'suffix': suffix}
+    for part in parts:
+        if '-' in part:
+            key, value = part.split('-', 1)
+            components[key] = value
+    return components
+
+
+# take in a set of bids tags (defined as kwargs) and find all files matching them
+def find_bids_files(basedir: Union[str, Path], **bids_tags) -> List[Path]:
+    """
+    Find all files in a BIDS-like directory that match specified tags.
+
+    Parameters
+    ----------
+    basedir : str or Path
+        Base directory to search
+    **bids_tags : dict
+        Key-value pairs of BIDS tags to match
+
+    Returns
+    -------
+    list of Path
+        List of Path objects for files matching the specified tags
+    """
+    if isinstance(basedir, str):
+        basedir = Path(basedir)
+    
+    matched_files = []
+    for filepath in basedir.rglob('*'):
+        if filepath.is_file():
+            components = parse_bids_filename(filepath)
+            if all(components.get(k) == v for k, v in bids_tags.items()):
+                matched_files.append(filepath)
+    return matched_files
+
+
+def modify_bids_filename(filename: Union[str, Path], **bids_tags) -> Union[str, Path]:
+    """
+    Modify a BIDS-like filename by replacing specified tag values.
+
+    Parameters
+    ----------
+    filename : str or Path
+        Original BIDS-like filename (string or Path object)
+    **bids_tags : dict
+        Key-value pairs of BIDS tags to modify
+
+    Returns
+    -------
+    str or Path
+        Modified filename with updated tag values, returned in the same type
+        as the input (str or Path). Full directory path is preserved.
+
+    Examples
+    --------
+    >>> modify_bids_filename("sub-123_desc-test_type-1_stat.nii.gz", desc="real")
+    'sub-123_desc-real_type-1_stat.nii.gz'
+    
+    >>> modify_bids_filename("sub-01_task-rest_bold.nii", task="memory", run="02")
+    'sub-01_task-memory_run-02_bold.nii'
+    """
+    # Track input type
+    input_is_string = isinstance(filename, str)
+    
+    if input_is_string:
+        filepath = Path(filename)
+    else:
+        filepath = filename
+    
+    # Get directory and original filename
+    parent_dir = filepath.parent
+    original_name = filepath.name
+    
+    # Get the file extension(s)
+    if '.' in original_name:
+        # Handle both .nii.gz and .nii cases
+        ext_parts = original_name.split('.')
+        extension = '.' + '.'.join(ext_parts[1:])
+    else:
+        extension = ''
+    
+    # Parse original filename to extract key-value pairs in order
+    base = original_name
+    if '.' in base:
+        base = base.split('.')[0]  # Remove extension
+    
+    parts = base.split('_')
+    suffix = parts[-1]  # Last part is the suffix
+    kv_parts = parts[:-1]  # Everything before suffix
+    
+    # Build ordered list of (key, value) tuples, preserving original order
+    ordered_pairs = []
+    existing_keys = set()
+    
+    for part in kv_parts:
+        if '-' in part:
+            key, value = part.split('-', 1)
+            # Update value if modification requested
+            if key in bids_tags:
+                value = bids_tags[key]
+            ordered_pairs.append((key, value))
+            existing_keys.add(key)
+    
+    # Add any new keys from bids_tags that weren't in original
+    for key, value in bids_tags.items():
+        if key not in existing_keys:
+            ordered_pairs.append((key, value))
+    
+    # Reconstruct filename maintaining order
+    new_parts = [f"{key}-{value}" for key, value in ordered_pairs]
+    new_filename = '_'.join(new_parts) + f"_{suffix}{extension}"
+    
+    # Reconstruct full path
+    new_filepath = parent_dir / new_filename
+    
+    # Return in same type as input
+    if input_is_string:
+        return str(new_filepath)
+    else:
+        return new_filepath
+
+
+def bids_summary(
+    basedir: Union[str, Path],
+    extension: str = ".nii.gz",
+    verbose: bool = True
+) -> Dict[str, Dict[str, int]]:
+    """
+    Summarize BIDS files in a directory by counting images for each type within each desc.
+
+    Parameters
+    ----------
+    basedir : str or Path
+        Base directory containing BIDS files
+    extension : str, optional
+        File extension to filter (default: ".nii.gz")
+    verbose : bool, optional
+        Whether to print summary to screen (default: True)
+
+    Returns
+    -------
+    dict
+        Nested dictionary with structure:
+        {desc_value: {type_value: count, ...}, ...}
+        If desc is not present, uses 'no_desc' as key.
+        If type is not present, uses 'no_type' as key.
+
+    Examples
+    --------
+    >>> summary = bids_summary("/data/narps", extension=".nii.gz", verbose=True)
+    Summary of BIDS files in /data/narps (*.nii.gz):
+    desc-orig:
+      type-thresh: 10 files
+      type-unthresh: 10 files
+    desc-rect:
+      type-thresh: 5 files
+    """
+    if isinstance(basedir, str):
+        basedir = Path(basedir)
+    
+    # Find all files with the specified extension
+    if extension.startswith('.'):
+        pattern = f"*{extension}"
+    else:
+        pattern = f"*.{extension}"
+    
+    all_files = list(basedir.rglob(pattern))
+    
+    # Count by desc and type
+    summary_dict = {}
+    
+    for filepath in all_files:
+        components = parse_bids_filename(filepath)
+        
+        # Get desc and type, with defaults if missing
+        desc_value = components.get('desc', 'no_desc')
+        type_value = components.get('type', 'no_type')
+        
+        # Initialize nested dict if needed
+        if desc_value not in summary_dict:
+            summary_dict[desc_value] = {}
+        
+        if type_value not in summary_dict[desc_value]:
+            summary_dict[desc_value][type_value] = 0
+        
+        summary_dict[desc_value][type_value] += 1
+    
+    # Print summary if verbose
+    if verbose:
+        print(f"Summary of BIDS files in {basedir} (*{extension}):")
+        if not summary_dict:
+            print("  No files found")
+        else:
+            for desc, type_counts in sorted(summary_dict.items()):
+                print(f"  desc-{desc}:")
+                for type_val, count in sorted(type_counts.items()):
+                    print(f"    type-{type_val}: {count} files")
+    
+    return summary_dict
+

From 67a0b25bc61aa526ad695ed3a78d22512f68616c Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 10:28:30 -0800
Subject: [PATCH 05/87] add summary function

---
 tests/narps/test_bids.py | 341 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 341 insertions(+)

diff --git a/tests/narps/test_bids.py b/tests/narps/test_bids.py
index 40f0540..6961659 100644
--- a/tests/narps/test_bids.py
+++ b/tests/narps/test_bids.py
@@ -8,6 +8,8 @@
 from BetterCodeBetterScience.narps.bids_utils import (
     parse_bids_filename,
     find_bids_files,
+    modify_bids_filename,
+    bids_summary,
 )
 
 
@@ -265,3 +267,342 @@ def test_find_bids_files_narps_complex_filter(temp_narps_dir):
     
     assert len(results) == 1
     assert results[0].name == "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz"
+
+
+# Tests for modify_bids_filename
+
+
+def test_modify_bids_filename_single_tag():
+    """Test modifying a single BIDS tag."""
+    original = "sub-123_desc-test_type-1_stat.nii.gz"
+    result = modify_bids_filename(original, desc="real")
+    
+    # Should preserve order and return same type
+    assert result == "sub-123_desc-real_type-1_stat.nii.gz"
+    assert isinstance(result, str)
+
+
+def test_modify_bids_filename_multiple_tags():
+    """Test modifying multiple BIDS tags at once."""
+    original = "sub-01_task-rest_bold.nii"
+    result = modify_bids_filename(original, task="memory", run="02")
+    
+    # Should add run and modify task, preserving original order
+    assert result == "sub-01_task-memory_run-02_bold.nii"
+    assert isinstance(result, str)
+
+
+def test_modify_bids_filename_path_object():
+    """Test that function works with Path objects."""
+    original = Path("sub-01_ses-01_T1w.nii.gz")
+    result = modify_bids_filename(original, ses="02")
+    
+    # Should return Path object when input is Path
+    assert isinstance(result, Path)
+    assert result.name == "sub-01_ses-02_T1w.nii.gz"
+
+
+def test_modify_bids_filename_add_new_tag():
+    """Test adding a tag that wasn't in the original filename."""
+    original = "sub-01_task-rest_bold.nii.gz"
+    result = modify_bids_filename(original, run="01", acq="mb")
+    
+    # New tags should be added at the end (after existing tags)
+    assert result == "sub-01_task-rest_run-01_acq-mb_bold.nii.gz"
+    assert isinstance(result, str)
+
+
+def test_modify_bids_filename_preserve_extension():
+    """Test that file extensions are preserved."""
+    original = "sub-01_bold.nii.gz"
+    result = modify_bids_filename(original, sub="02")
+    
+    assert result.endswith(".nii.gz")
+    assert result == "sub-02_bold.nii.gz"
+
+
+def test_modify_bids_filename_simple_extension():
+    """Test with simple extension (not .nii.gz)."""
+    original = "sub-01_task-rest_bold.nii"
+    result = modify_bids_filename(original, task="memory")
+    
+    assert result.endswith(".nii")
+    assert "task-memory" in result
+
+
+def test_modify_bids_filename_no_extension():
+    """Test with no file extension."""
+    original = "sub-01_task-rest_bold"
+    result = modify_bids_filename(original, task="memory")
+    
+    assert "task-memory" in result
+    assert not result.endswith(".")
+
+
+def test_modify_bids_filename_narps_format():
+    """Test modifying NARPS-specific fields."""
+    original = "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz"
+    result = modify_bids_filename(original, desc="rect", type="unthresh")
+    
+    assert "desc-rect" in result
+    assert "type-unthresh" in result
+    assert "hyp-1" in result
+    assert "sub-team01" in result
+
+
+def test_modify_bids_filename_change_subject():
+    """Test changing the subject ID."""
+    original = "sub-01_task-rest_bold.nii.gz"
+    result = modify_bids_filename(original, sub="99")
+    
+    # Should preserve order with modified subject
+    assert result == "sub-99_task-rest_bold.nii.gz"
+
+
+def test_modify_bids_filename_preserve_suffix():
+    """Test that suffix is preserved when modifying other tags."""
+    original = "sub-01_task-rest_bold.nii.gz"
+    result = modify_bids_filename(original, task="memory")
+    
+    assert result.endswith("_bold.nii.gz")
+
+
+def test_modify_bids_filename_complex_modification():
+    """Test complex modification with many changes."""
+    original = "sub-01_ses-01_task-rest_acq-mb_bold.nii.gz"
+    result = modify_bids_filename(
+        original,
+        sub="02",
+        ses="03",
+        task="memory",
+        run="01"
+    )
+    
+    # Should preserve original order and append new tag
+    assert result == "sub-02_ses-03_task-memory_acq-mb_run-01_bold.nii.gz"
+
+
+def test_modify_bids_filename_hyphenated_value():
+    """Test that hyphenated values are handled correctly."""
+    original = "sub-control-01_task-go_bold.nii"
+    result = modify_bids_filename(original, task="go-nogo")
+    
+    # Should preserve order with hyphenated values
+    assert result == "sub-control-01_task-go-nogo_bold.nii"
+
+
+def test_modify_bids_filename_empty_modification():
+    """Test that calling with no modifications returns identical filename."""
+    original = "sub-01_task-rest_bold.nii.gz"
+    result = modify_bids_filename(original)
+    
+    # Should return exactly the same filename
+    assert result == original
+
+
+def test_modify_bids_filename_with_full_path():
+    """Test modification preserves full directory path."""
+    original = Path("/data/bids/sub-01_task-rest_bold.nii.gz")
+    result = modify_bids_filename(original, task="memory")
+    
+    # Result should preserve the full directory path
+    assert isinstance(result, Path)
+    assert result == Path("/data/bids/sub-01_task-memory_bold.nii.gz")
+    assert result.parent == Path("/data/bids")
+    assert result.name == "sub-01_task-memory_bold.nii.gz"
+
+
+def test_modify_bids_filename_string_with_path():
+    """Test that string input with directory path preserves the path."""
+    original = "/data/bids/sub-01_task-rest_bold.nii.gz"
+    result = modify_bids_filename(original, task="memory")
+    
+    # Should return string and preserve directory path
+    assert isinstance(result, str)
+    assert result == "/data/bids/sub-01_task-memory_bold.nii.gz"
+
+
+def test_modify_bids_filename_order_preservation():
+    """Test that original key order is strictly preserved."""
+    original = "sub-01_desc-orig_type-thresh_hyp-1_stat.nii.gz"
+    result = modify_bids_filename(original, type="unthresh")
+    
+    # Order should be exactly: sub, desc, type, hyp
+    assert result == "sub-01_desc-orig_type-unthresh_hyp-1_stat.nii.gz"
+
+
+def test_modify_bids_filename_relative_path():
+    """Test with relative path."""
+    original = Path("data/sub-01_task-rest_bold.nii.gz")
+    result = modify_bids_filename(original, task="memory")
+    
+    assert isinstance(result, Path)
+    assert result == Path("data/sub-01_task-memory_bold.nii.gz")
+    assert result.parent == Path("data")
+
+
+# Tests for bids_summary
+
+
+@pytest.fixture
+def temp_summary_dir():
+    """Create a temporary directory with various BIDS files for summary testing."""
+    tmpdir = tempfile.mkdtemp()
+    basedir = Path(tmpdir)
+    
+    # Create test files with different desc and type combinations
+    files = [
+        "sub-team01_desc-orig_type-thresh_hyp-1_stat.nii.gz",
+        "sub-team01_desc-orig_type-thresh_hyp-2_stat.nii.gz",
+        "sub-team01_desc-orig_type-unthresh_hyp-1_stat.nii.gz",
+        "sub-team01_desc-orig_type-unthresh_hyp-2_stat.nii.gz",
+        "sub-team02_desc-orig_type-thresh_hyp-1_stat.nii.gz",
+        "sub-team02_desc-rect_type-thresh_hyp-1_stat.nii.gz",
+        "sub-team02_desc-rect_type-unthresh_hyp-1_stat.nii.gz",
+        "sub-team03_desc-rect_type-thresh_hyp-1_stat.nii.gz",
+        # Files without desc or type
+        "sub-team04_hyp-1_stat.nii.gz",
+        "sub-team05_desc-orig_hyp-1_stat.nii.gz",
+        # Different extension (should be excluded by default)
+        "sub-team01_desc-orig_type-thresh_hyp-1_stat.nii",
+    ]
+    
+    for filename in files:
+        filepath = basedir / filename
+        filepath.touch()
+    
+    yield basedir
+    
+    shutil.rmtree(tmpdir)
+
+
+def test_bids_summary_basic(temp_summary_dir, capsys):
+    """Test basic summary functionality."""
+    result = bids_summary(temp_summary_dir, verbose=False)
+    
+    # Check the structure
+    assert 'orig' in result
+    assert 'rect' in result
+    
+    # Check counts for orig
+    assert result['orig']['thresh'] == 3
+    assert result['orig']['unthresh'] == 2
+    
+    # Check counts for rect
+    assert result['rect']['thresh'] == 2
+    assert result['rect']['unthresh'] == 1
+
+
+def test_bids_summary_verbose_output(temp_summary_dir, capsys):
+    """Test that verbose mode prints summary."""
+    result = bids_summary(temp_summary_dir, verbose=True)
+    
+    captured = capsys.readouterr()
+    assert "Summary of BIDS files" in captured.out
+    assert "desc-orig:" in captured.out
+    assert "desc-rect:" in captured.out
+    assert "type-thresh:" in captured.out
+    assert "type-unthresh:" in captured.out
+
+
+def test_bids_summary_no_verbose(temp_summary_dir, capsys):
+    """Test that verbose=False suppresses output."""
+    result = bids_summary(temp_summary_dir, verbose=False)
+    
+    captured = capsys.readouterr()
+    assert captured.out == ""
+
+
+def test_bids_summary_different_extension(temp_summary_dir):
+    """Test filtering by different extension."""
+    result = bids_summary(temp_summary_dir, extension=".nii", verbose=False)
+    
+    # Should find only the .nii file
+    assert 'orig' in result
+    assert result['orig']['thresh'] == 1
+    # Should not find .nii.gz files
+    assert result['orig'].get('unthresh') is None
+
+
+def test_bids_summary_no_desc(temp_summary_dir):
+    """Test handling of files without desc tag."""
+    result = bids_summary(temp_summary_dir, verbose=False)
+    
+    # Files without desc should be grouped under 'no_desc'
+    assert 'no_desc' in result
+
+
+def test_bids_summary_no_type(temp_summary_dir):
+    """Test handling of files without type tag."""
+    result = bids_summary(temp_summary_dir, verbose=False)
+    
+    # Check for files with desc but no type
+    assert 'orig' in result
+    assert 'no_type' in result['orig']
+    assert result['orig']['no_type'] == 1
+
+
+def test_bids_summary_empty_directory():
+    """Test summary on empty directory."""
+    tmpdir = tempfile.mkdtemp()
+    try:
+        result = bids_summary(tmpdir, verbose=False)
+        assert result == {}
+    finally:
+        shutil.rmtree(tmpdir)
+
+
+def test_bids_summary_string_path(temp_summary_dir):
+    """Test that function accepts string paths."""
+    result = bids_summary(str(temp_summary_dir), verbose=False)
+    
+    assert isinstance(result, dict)
+    assert 'orig' in result
+
+
+def test_bids_summary_extension_with_dot(temp_summary_dir):
+    """Test that extension works with or without leading dot."""
+    result1 = bids_summary(temp_summary_dir, extension=".nii.gz", verbose=False)
+    result2 = bids_summary(temp_summary_dir, extension="nii.gz", verbose=False)
+    
+    # Both should produce same results
+    assert result1 == result2
+
+
+def test_bids_summary_nested_directories():
+    """Test summary works with nested directory structures."""
+    tmpdir = tempfile.mkdtemp()
+    basedir = Path(tmpdir)
+    
+    try:
+        # Create nested structure
+        subdir1 = basedir / "sub-01"
+        subdir2 = basedir / "sub-02" / "nested"
+        subdir1.mkdir(parents=True)
+        subdir2.mkdir(parents=True)
+        
+        (subdir1 / "sub-01_desc-orig_type-thresh_stat.nii.gz").touch()
+        (subdir2 / "sub-02_desc-orig_type-thresh_stat.nii.gz").touch()
+        
+        result = bids_summary(basedir, verbose=False)
+        
+        # Should find files in nested directories
+        assert result['orig']['thresh'] == 2
+        
+    finally:
+        shutil.rmtree(tmpdir)
+
+
+def test_bids_summary_return_structure(temp_summary_dir):
+    """Test that return structure is correct type."""
+    result = bids_summary(temp_summary_dir, verbose=False)
+    
+    assert isinstance(result, dict)
+    for desc_key, type_dict in result.items():
+        assert isinstance(desc_key, str)
+        assert isinstance(type_dict, dict)
+        for type_key, count in type_dict.items():
+            assert isinstance(type_key, str)
+            assert isinstance(count, int)
+            assert count > 0
+

From bb65968aa668458b42e08d9522ba296561f08e8e Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 10:28:46 -0800
Subject: [PATCH 06/87] add deps

---
 pyproject.toml |  1 +
 uv.lock        | 22 ++++++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index 1fa8704..8f8d3ec 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -59,6 +59,7 @@ dependencies = [
     "ols-client>=0.2.1",
     "statsmodels>=0.14.5",
     "blue>=0.9.1",
+    "nilearn>=0.12.1",
 ]
 
 [build-system]
diff --git a/uv.lock b/uv.lock
index bed2c1b..dde3a40 100644
--- a/uv.lock
+++ b/uv.lock
@@ -327,6 +327,7 @@ dependencies = [
     { name = "neo4j" },
     { name = "networkx" },
     { name = "nibabel" },
+    { name = "nilearn" },
     { name = "numba" },
     { name = "numpy" },
     { name = "ols-client" },
@@ -385,6 +386,7 @@ requires-dist = [
     { name = "neo4j", specifier = ">=6.0.3" },
     { name = "networkx", specifier = ">=3.4.2" },
     { name = "nibabel", specifier = ">=5.3.2" },
+    { name = "nilearn", specifier = ">=0.12.1" },
     { name = "numba", specifier = ">=0.61.0" },
     { name = "numpy", specifier = ">=2.1.2" },
     { name = "ols-client", specifier = ">=0.2.1" },
@@ -3005,6 +3007,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/43/b2/dc384197be44e2a640bb43311850e23c2c30f3b82ce7c8cdabbf0e53045e/nibabel-5.3.2-py3-none-any.whl", hash = "sha256:52970a5a8a53b1b55249cba4d9bcfaa8cc57e3e5af35a29d7352237e8680a6f8", size = 3293839, upload-time = "2024-10-23T14:19:52.65Z" },
 ]
 
+[[package]]
+name = "nilearn"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "joblib" },
+    { name = "lxml" },
+    { name = "nibabel" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "requests" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4f/1c/5d6ef3f80145889bee1c7abbf107c88e7adea7d5b498633f8644910c673c/nilearn-0.12.1.tar.gz", hash = "sha256:a08bbfae94d0fac5ba0aebbbcd864b7f91d1ef5725d1c309ce643dd64b2391b9", size = 25134624, upload-time = "2025-09-03T06:00:40.631Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/90/f17ebc6914b9ed0b577475a17a0b8d31e929897f7002bae1b03438852dad/nilearn-0.12.1-py3-none-any.whl", hash = "sha256:2112e1cdf9f7b96e0af87d679997e834ee36534fc0a970811a703700820edc4c", size = 12743284, upload-time = "2025-09-03T06:00:18.625Z" },
+]
+
 [[package]]
 name = "nodeenv"
 version = "1.9.1"

From 34165578daeb036b0ef00b60d64537775358259e Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 10:30:13 -0800
Subject: [PATCH 07/87] initial add

---
 .../narps/image_utils.py                      | 134 ++++++++
 .../narps/narps_megascript.py                 | 285 ++++++++++++++++++
 2 files changed, 419 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/narps/image_utils.py
 create mode 100644 src/BetterCodeBetterScience/narps/narps_megascript.py

diff --git a/src/BetterCodeBetterScience/narps/image_utils.py b/src/BetterCodeBetterScience/narps/image_utils.py
new file mode 100644
index 0000000..7a9e950
--- /dev/null
+++ b/src/BetterCodeBetterScience/narps/image_utils.py
@@ -0,0 +1,134 @@
+
+import os
+from typing import Dict, Optional, Union
+from pathlib import Path
+
+import numpy as np
+import nibabel as nib
+
+
+def compare_thresh_unthresh_values(
+    thresh_image_path: Union[str, Path],
+    unthresh_image_path: Union[str, Path],
+    hyp_num: int,
+    team_id: Optional[str] = None,
+    collection_id: Optional[str] = None,
+    error_thresh: float = 0.05,
+    verbose: bool = True,
+    logger=None,
+) -> Dict:
+    """
+    Examine unthresholded values within thresholded map voxels
+    to check direction of maps and determine if rectification is needed.
+
+    If more than error_thresh percent of voxels are in opposite direction,
+    then flag a problem. We allow a few to bleed over due to interpolation.
+
+    Parameters
+    ----------
+    thresh_image_path : str or Path
+        Path to thresholded image
+    unthresh_image_path : str or Path
+        Path to unthresholded image
+    hyp_num : int
+        Hypothesis number
+    team_id : str, optional
+        Team identifier
+    collection_id : str, optional
+        Collection identifier
+    error_thresh : float
+        Threshold for flagging problems (proportion of voxels in wrong direction)
+    verbose : bool
+        Whether to print diagnostic messages
+
+    Returns
+    -------
+    dict
+        Dictionary containing diagnostic information:
+        - autorectify: bool, whether image should be rectified
+        - problem: bool, whether there's a problem with the image
+        - n_thresh_vox: int, number of thresholded voxels
+        - min_unthresh: float, minimum unthresholded value within mask
+        - max_unthresh: float, maximum unthresholded value within mask
+        - p_pos_unthresh: float, proportion of positive unthresholded values
+        - p_neg_unthresh: float, proportion of negative unthresholded values
+    """
+    result = {
+        "hyp": hyp_num,
+        "team_id": team_id,
+        "collection_id": collection_id,
+        "autorectify": False,
+        "problem": False,
+        "n_thresh_vox": 0,
+        "min_unthresh": np.nan,
+        "max_unthresh": np.nan,
+        "p_pos_unthresh": np.nan,
+        "p_neg_unthresh": np.nan,
+    }
+
+    # Check if files exist
+    if not os.path.exists(thresh_image_path):
+        if verbose and logger:
+            logger.warning("Threshold image not found: %s", thresh_image_path)
+        return result
+
+    if not os.path.exists(unthresh_image_path):
+        if verbose and logger:
+            logger.warning("Unthreshold image not found: %s", unthresh_image_path)
+        return result
+
+    # Load images
+    thresh_img = nib.load(thresh_image_path)
+    thresh_data = thresh_img.get_fdata().flatten()
+    thresh_data = np.nan_to_num(thresh_data)
+
+    unthresh_img = nib.load(unthresh_image_path)
+    unthresh_data = unthresh_img.get_fdata().flatten()
+    unthresh_data = np.nan_to_num(unthresh_data)
+
+    # Check shape compatibility
+    if thresh_data.shape != unthresh_data.shape:
+        if verbose and logger:
+            logger.error("thresh/unthresh size mismatch for hyp %d", hyp_num)
+        result["problem"] = True
+        return result
+
+    # Count thresholded voxels
+    n_thresh_vox = np.sum(thresh_data > 0)
+    result["n_thresh_vox"] = int(n_thresh_vox)
+
+    if n_thresh_vox == 0:
+        if verbose and logger:
+            logger.warning("hyp %d - empty mask", hyp_num)
+        return result
+
+    # Analyze values within the mask
+    inmask_unthresh_data = unthresh_data[thresh_data > 0]
+
+    min_val = float(np.min(inmask_unthresh_data))
+    max_val = float(np.max(inmask_unthresh_data))
+    p_pos_unthresh = float(np.mean(inmask_unthresh_data > 0))
+    p_neg_unthresh = float(np.mean(inmask_unthresh_data < 0))
+
+    result["min_unthresh"] = min_val
+    result["max_unthresh"] = max_val
+    result["p_pos_unthresh"] = p_pos_unthresh
+    result["p_neg_unthresh"] = p_neg_unthresh
+
+    # Check if rectification is needed
+    if max_val < 0:  # All values are negative
+        result["autorectify"] = True
+        if verbose and logger:
+            logger.info("Autorectify needed: hyp %d", hyp_num)
+
+    # Check for problems
+    min_p_direction = min(p_pos_unthresh, p_neg_unthresh)
+    if min_p_direction > error_thresh:
+        if verbose and logger:
+            logger.warning(
+                "hyp %d invalid in-mask values (neg: %.3f, pos: %.3f)",
+                hyp_num, p_neg_unthresh, p_pos_unthresh
+            )
+        result["problem"] = True
+
+    return result
diff --git a/src/BetterCodeBetterScience/narps/narps_megascript.py b/src/BetterCodeBetterScience/narps/narps_megascript.py
new file mode 100644
index 0000000..a696657
--- /dev/null
+++ b/src/BetterCodeBetterScience/narps/narps_megascript.py
@@ -0,0 +1,285 @@
+## This is a megascript to run the NARPS preprocessing workflow
+## This will serve as the basis for refactoring into a more modular workflow later.
+
+import os
+import dotenv
+from pathlib import Path
+import tarfile
+import urllib.request
+from typing import Dict, List, Union
+import shutil
+from BetterCodeBetterScience.narps.bids_utils import (
+    parse_bids_filename,
+    find_bids_files,
+    modify_bids_filename
+)
+from nilearn.maskers import NiftiMasker
+import nibabel as nib
+import numpy as np
+
+dotenv.load_dotenv()
+
+
+
+
+## Download data
+# - the organized data are available from https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz
+
+assert 'NARPS_DATADIR' in os.environ, "Please set NARPS_DATADIR in your environment variables or .env file"
+basedir = Path(os.environ['NARPS_DATADIR'])
+if not basedir.exists():
+    basedir.mkdir(parents=True, exist_ok=True)
+
+narps_data_url = "https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz"
+narps_data_archive = basedir / "narps_origdata_1.0.tgz"
+
+overwrite_data = False
+
+if not narps_data_archive.exists() or overwrite_data:
+
+    print(f"Downloading NARPS data from {narps_data_url}...")
+    urllib.request.urlretrieve(narps_data_url, narps_data_archive)
+    print("Download complete.")
+
+origdir = basedir / "orig"
+if not origdir.exists() or overwrite_data:
+    print("Extracting data...")
+    with tarfile.open(narps_data_archive, "r:gz") as tar:
+        tar.extractall(path=basedir)
+    print("Extraction complete.")
+
+
+## Get info about teams and hypotheses
+## team dirs are in orig, starting with numeric team IDs
+
+teamdirs = sorted([d for d in origdir.iterdir() if d.is_dir() and d.name[0].isdigit()])
+print(f"Found {len(teamdirs)} team directories.")
+team_dict = {d.name: {'orig': d} for d in teamdirs}
+
+# convert orig data to a BIDS-like organization
+
+overwrite = False
+datadir = basedir / "data"
+if datadir.exists() and overwrite:
+    shutil.rmtree(datadir)
+
+if not datadir.exists():
+    datadir.mkdir(parents=True, exist_ok=True)
+
+for team_id, paths in team_dict.items():
+    # only use the team number
+    team_id_short = team_id.split('_')[0]
+    team_orig_dir = paths['orig']
+    # include "thresh" to prevent some additional files from being detected
+    for type in ['thresh', 'unthresh']:
+        for img_file in team_orig_dir.glob(f"*_{type}.nii.gz"):
+            hyp, imgtype = img_file.name.split('.')[0].replace('hypo','').split('_')
+            dest_file = datadir / f"team-{team_id_short}_hyp-{hyp}_type-{imgtype}_desc-orig_stat.nii.gz"
+            if not dest_file.exists():
+                print(f"Copying {img_file} to {dest_file}")
+                shutil.copy(img_file.resolve(), dest_file)
+            assert parse_bids_filename(dest_file)['team'] == team_id_short
+            assert parse_bids_filename(dest_file)['hyp'] == hyp
+            assert parse_bids_filename(dest_file)['type'] == imgtype
+
+# - Create rectified images - narps.create_rectified_images()
+#     - input: original image (thresh and unthresh versions)
+#     - output: rectified images for reverse contrasts
+#     - NOTE: see logic within get_binarized_thresh_masks 
+
+print("Creating rectified images...")
+unthresh_images_to_rectify = find_bids_files(
+    datadir, type='unthresh', desc='orig')
+
+for unthresh_img_path in unthresh_images_to_rectify:
+    components = parse_bids_filename(unthresh_img_path)
+    hyp_num = int(components['hyp'])
+    team_id = components['team']
+    result = {
+        "hyp": hyp_num,
+        "team_id": team_id,
+    }
+    thresh_img_path = modify_bids_filename(
+        unthresh_img_path,
+        type='thresh'
+    )
+    if not Path(thresh_img_path).exists():
+        print(f"Thresholded image not found for hyp {hyp_num}, team {team_id}, skipping rectification.")
+        result["problem"] = 'thresholded image not found'
+        continue
+
+    output_path = Path(modify_bids_filename(
+        unthresh_img_path,
+        desc='rectified'
+    ))
+    result["output_path"] = str(output_path)
+    if output_path.exists() and not overwrite:
+        print(f"Rectified image already exists: {output_path}, skipping.")
+        continue
+
+    # recitification involves looking at the values of the unthresh
+    # image within the mask defined by the thresholded image
+    unthresh_img = nib.load(str(unthresh_img_path))
+    thresh_img = nib.load(str(thresh_img_path))
+
+    # check image dimensions
+    if unthresh_img.shape != thresh_img.shape:
+        print(f"Image shape mismatch for hyp {components['hyp']}, team {components['team']}, skipping rectification.")
+        result["problem"] = 'image shape mismatch'
+        continue
+    thresh_data = thresh_img.get_fdata().flatten()
+    thresh_data = np.nan_to_num(thresh_data)
+    n_thresh_vox = np.sum(thresh_data > 0)
+    result["n_thresh_vox"] = int(n_thresh_vox)
+    if n_thresh_vox == 0:
+        print(f"Empty mask for hyp {components['hyp']}, team {components['team']}, skipping rectification.")
+        continue
+
+    masker = NiftiMasker(mask_img=thresh_img)
+    masker.fit()
+    unthresh_data = masker.transform(str(unthresh_img_path)).flatten()
+
+ljksadf
+
+
+# - Get binarized thresholded maps (narps.get_binarized_thresh_masks())
+#     - input: thresholded original image
+#     - output: binarized version
+
+
+# - Get resampled images (narps.get_resampled_images())
+#     - input: all image types (thresh, bin, unthresh)
+#     - output: resampled image in MNI space
+
+
+# - Create concatenated versions of all images - narps.create_concat_imag
+#     - input: individual 3d images
+#     - output: combined 4d images for each image type
+
+
+# - Check image values - narps.check_image_values()
+#     - input: thresholded images
+#     - output: data frame with number of NA and nonzero voxels 
+
+
+# - Create mean thresholded images - narps.create_mean_thresholded_images()
+#     - input: contact thresh image
+#     - output: mean thresholded image
+
+
+# - Convert to zscores - narps.convert_to_zscores()
+#     - input: unthresh rectified images
+#     - output: zscore images
+
+
+# - Create concatenated utnhresh zstat images - narps.create_concat_images(datatype='zstat', imgtypes=['unthresh'],
+#                                create_voxel_map=True)
+#         input: zstat images
+#         output: concatenated 4d zstat image
+#         NOTE: maynbe consider using the concatenated unthresh image to compute zstats
+
+
+## Analyses
+
+# - Compute image stats - narps.compute_image_stats()
+#     input: unthresholded concatenated files
+#     output: range and std images
+
+# - Estimate smoothness - narps.estimate_smoothness() - relies upon FSL smoothest
+#     input: individual 3d team zstat images
+#     output: dataframe containing smoothness estimates for each team
+
+
+# ### Map analysis functions
+
+# NOTE: the following three are largely duplicative
+# - Create overlap maps - AnalyzeMaps.mk_overlap_maps
+#     input: mean thresholded images
+#     output: pdf and png files with rendering of map on anatomy
+# - Create range maps - AnalyzeMaps.mk_range_maps
+#     input: range images
+#     output: pdf/png files with rendering of range map on anatomy
+# - Create std maps - AnalyzeMaps.mk_std_maps
+#     input: std images
+#     output: pdf/png files with rendering of std map on anatomy
+
+# - Unthresholded correlation analysis - test_unthresh_correlation_analysis
+# - Create correlation maps for unthresholded images - AnalyzeMaps.mk_correlation_maps_unthresh
+#     input: concatenated unthresholded images
+#     output: 
+#         - median pattern correlation (?)
+#         - df containing correlation matrix between datasets for each hypothesis
+#         - png/pdf images of clustermap based on correlation matrix
+#         - cluster membership (saved as json)
+#         - reordered correlation matrix based on ward clustering
+#         - dendrograms for each hypothesis
+#     NOTE: this one has WAY too much going on - good candidate for refactoring example!
+# - Analyze clusters - AnalyzeMaps.analyze_clusters
+#     input: dendrograms and membership dict 
+#     output:
+#         - mean unthresholded map for each cluster/hypothesis
+#         - various stats output to logfile
+#         -pdf/png files with rendered thresholded map for each cluster
+#         - cluster metadata saved to csv
+#         - cluster similarity (rand scores) saved to csv
+#         - consistency of cluster membership across hypotheses
+# - Plot distance from mean - AnalyzeMaps.plot_distance_from_mean(narps)
+#     input: median pattern correlation
+#     output:
+#         - pdf with bar plot of correlations across teams
+#         - pdf of bar plot excluding teams above .2 correlation (i.e. only bad teams)
+# - Get similarity of thresholded images - AnalyzeMaps.get_thresh_similarity(narps)
+#     input: concatenated thresholded data
+#     output:
+#         - df with percent agreement
+#         - pdf/png with cluster map of percent agreement
+#         - mean jaccard for nonzero voxels
+# - Get thresholded z-stat maps - utils.get_thresholded_Z_maps(narps)
+#     input: unthresholded z maps and thresholded binarized maps
+#     output: thresholded Z maps
+#     NOTE: currently done on individual maps, probably should do on concatenated
+# - Get diagnostics on thresholded maps - ThreshVoxelStatistics.get_zstat_diagnostics(narps)
+#     input: thresholded and unthresholded maps
+#     output: diagnostic data comparing thresh and unthresh for each team
+# - Get stats on thresholded maps - ThreshVoxelStatistics.get_thresh_voxel_stats(narps.basedir)
+#     input: individual diagnostic data frames
+#     output:
+#         - df with all diagnostic data combined
+#         - df with statistics on thresholded maps
+# - Get similarity summary - GetMeanSimilarity.get_similarity_summary()
+#     input:  correlation data frames, cluster membership json
+#     output:
+#         - png with histogram of correlations
+#         - pngs with hisrogram of correlations for each cluster
+#         - data frame with correlation results by hyp/group
+
+
+# ### Consensus analysis functions
+
+# - run t-tests - ConsensusAnalysis.run_ttests
+#     input: unthresholded zstat images
+#     output:
+#         - t, pval, and fdr image for each hypothesis
+#         - tau image for each hypothesis
+# - make figures - ConsensusAnalysis.mk_figures()
+#     input: t and fdr images
+#     output: 
+#         - pdf with rendered consensus images
+#         - pdf with rendered tau maps
+#         - pdf with rendered tau histograms
+
+# - Compute cluster similarity for Tom et al. and mean activation - ClusterImageCorrelation.cluster_image_correlation
+#     input: cluster images and target image (mean or tom et al)
+#     output: 
+#         - correlation maps for each cluster vs target for each hyp
+#         - df with cluster correlations for each hyp
+
+# - Make combined cluster figures - MakeCombinedClusterFigures.make_combined_cluster_figures
+#     input: pngs for corr map and cluster means
+#     output: png with combined cluster images
+# - Make supp figure 1 - MakeSupplementaryFigure1.mk_supp_figure1
+#     input: metadata
+#     output: 
+#         - csv tables with merged metadata, decision data, and confidence data
+#         - png image with confidence data and modeling info
+

From 25ae638effd4876df13e80ec7389be8796ec3da2 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 17:30:09 -0800
Subject: [PATCH 08/87] working version

---
 .../narps/narps_megascript.py                 | 421 +++++++++++-------
 1 file changed, 257 insertions(+), 164 deletions(-)

diff --git a/src/BetterCodeBetterScience/narps/narps_megascript.py b/src/BetterCodeBetterScience/narps/narps_megascript.py
index a696657..98abaed 100644
--- a/src/BetterCodeBetterScience/narps/narps_megascript.py
+++ b/src/BetterCodeBetterScience/narps/narps_megascript.py
@@ -16,12 +16,12 @@
 from nilearn.maskers import NiftiMasker
 import nibabel as nib
 import numpy as np
+import json
+import templateflow.api as tflow
+from nilearn.image import resample_to_img
 
 dotenv.load_dotenv()
 
-
-
-
 ## Download data
 # - the organized data are available from https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz
 
@@ -48,6 +48,9 @@
         tar.extractall(path=basedir)
     print("Extraction complete.")
 
+logdir = basedir / "logs"
+if not logdir.exists():
+    logdir.mkdir(parents=True, exist_ok=True)
 
 ## Get info about teams and hypotheses
 ## team dirs are in orig, starting with numeric team IDs
@@ -59,7 +62,7 @@
 # convert orig data to a BIDS-like organization
 
 overwrite = False
-datadir = basedir / "data"
+datadir = basedir / "data-teams"
 if datadir.exists() and overwrite:
     shutil.rmtree(datadir)
 
@@ -74,7 +77,12 @@
     for type in ['thresh', 'unthresh']:
         for img_file in team_orig_dir.glob(f"*_{type}.nii.gz"):
             hyp, imgtype = img_file.name.split('.')[0].replace('hypo','').split('_')
-            dest_file = datadir / f"team-{team_id_short}_hyp-{hyp}_type-{imgtype}_desc-orig_stat.nii.gz"
+            try:
+                int(hyp)
+            except ValueError:
+                print(f"Unexpected hypothesis number format in file {img_file}, skipping.")
+                continue
+            dest_file = datadir / f"team-{team_id_short}_hyp-{hyp}_type-{imgtype}_space-native_desc-orig_stat.nii.gz"
             if not dest_file.exists():
                 print(f"Copying {img_file} to {dest_file}")
                 shutil.copy(img_file.resolve(), dest_file)
@@ -82,204 +90,289 @@
             assert parse_bids_filename(dest_file)['hyp'] == hyp
             assert parse_bids_filename(dest_file)['type'] == imgtype
 
-# - Create rectified images - narps.create_rectified_images()
-#     - input: original image (thresh and unthresh versions)
-#     - output: rectified images for reverse contrasts
-#     - NOTE: see logic within get_binarized_thresh_masks 
+# QC to identify bad data and move them to excluded data dir
+# look for:
+#  - different image dimensions or affine between thresh and unthresh images for a given team/hyp
+# - missing thresholded images
+# - need for rectification (i.e. mostly negative values in unthresh image within the mask defined by the thresh image)
+#  - invalid in-mask values (i.e. both positive and negative values in unthresh image within the mask defined by the thresh image) - don't exclude, just note in log
 
-print("Creating rectified images...")
-unthresh_images_to_rectify = find_bids_files(
-    datadir, type='unthresh', desc='orig')
+datadir_excluded = basedir / "data-teams-excluded"
+if not datadir_excluded.exists():
+    datadir_excluded.mkdir(parents=True, exist_ok=True)
+
+qc_results = {}
+error_thresh = 0.1  # proportion of invalid in-mask values to flag problem
 
-for unthresh_img_path in unthresh_images_to_rectify:
+print("Running QC on original images...")
+unthresh_images = find_bids_files(datadir, type='unthresh', desc='orig')
+print (f"Found {len(unthresh_images)} unthresh original images to QC.")
+
+for unthresh_img_path in unthresh_images:
     components = parse_bids_filename(unthresh_img_path)
     hyp_num = int(components['hyp'])
     team_id = components['team']
     result = {
         "hyp": hyp_num,
         "team_id": team_id,
+        'infile': str(unthresh_img_path)
     }
     thresh_img_path = modify_bids_filename(
         unthresh_img_path,
         type='thresh'
     )
     if not Path(thresh_img_path).exists():
-        print(f"Thresholded image not found for hyp {hyp_num}, team {team_id}, skipping rectification.")
-        result["problem"] = 'thresholded image not found'
+        print(f"Thresholded image not found for hyp {hyp_num}, team {team_id}, moving to excluded data.")
+        shutil.move(unthresh_img_path, datadir_excluded / unthresh_img_path.name)
+        result["exclusion"] = 'thresholded image not found'
+        qc_results[str(unthresh_img_path)] = result
         continue
 
-    output_path = Path(modify_bids_filename(
-        unthresh_img_path,
-        desc='rectified'
-    ))
-    result["output_path"] = str(output_path)
-    if output_path.exists() and not overwrite:
-        print(f"Rectified image already exists: {output_path}, skipping.")
-        continue
-
-    # recitification involves looking at the values of the unthresh
-    # image within the mask defined by the thresholded image
+    # Load images
     unthresh_img = nib.load(str(unthresh_img_path))
     thresh_img = nib.load(str(thresh_img_path))
 
-    # check image dimensions
-    if unthresh_img.shape != thresh_img.shape:
-        print(f"Image shape mismatch for hyp {components['hyp']}, team {components['team']}, skipping rectification.")
-        result["problem"] = 'image shape mismatch'
+    # check image dimensions and affine
+    if unthresh_img.shape != thresh_img.shape or not np.allclose(unthresh_img.affine, thresh_img.affine):
+        print(f"Image shape or affine mismatch for hyp {components['hyp']}, team {components['team']}, moving to excluded data.")
+        shutil.move(unthresh_img_path, datadir_excluded / unthresh_img_path.name)
+        shutil.move(thresh_img_path, datadir_excluded / Path(thresh_img_path).name)
+        result["exclusion"] = 'image shape or affine mismatch'
+        qc_results[str(unthresh_img_path)] = result
         continue
+
     thresh_data = thresh_img.get_fdata().flatten()
     thresh_data = np.nan_to_num(thresh_data)
     n_thresh_vox = np.sum(thresh_data > 0)
+    # check for min_p_direction > error_thresh
     result["n_thresh_vox"] = int(n_thresh_vox)
-    if n_thresh_vox == 0:
-        print(f"Empty mask for hyp {components['hyp']}, team {components['team']}, skipping rectification.")
-        continue
 
-    masker = NiftiMasker(mask_img=thresh_img)
-    masker.fit()
-    unthresh_data = masker.transform(str(unthresh_img_path)).flatten()
 
-ljksadf
+    if n_thresh_vox > 0:
+        masker = NiftiMasker(mask_img=thresh_img)
+        masker.fit()
+        unthresh_data_masked = masker.transform(str(unthresh_img_path))
+
+        min_val = float(np.min(unthresh_data_masked.flatten()))
+        max_val = float(np.max(unthresh_data_masked.flatten()))
+        p_pos_unthresh = float(np.mean(unthresh_data_masked.flatten() > 0))
+        p_neg_unthresh = float(np.mean(unthresh_data_masked.flatten() < 0))
+        result["min_unthresh"] = min_val
+        result["max_unthresh"] = max_val
+        result["p_pos_unthresh"] = p_pos_unthresh
+        result["p_neg_unthresh"] = p_neg_unthresh
+
+        if p_neg_unthresh > (1 - error_thresh):
+            # mostly negative values, rectify
+            result["autorectify"] = True
+        else:
+            result["autorectify"] = False
+
+        # Check for problems - note these in QC but don't exclude
+        min_p_direction = min(p_pos_unthresh, p_neg_unthresh)
+        if min_p_direction > error_thresh:
+            result["problem"] = 'invalid in-mask values'
+            print(f"hyp {hyp_num}, team {team_id} - invalid in-mask values (neg: {p_neg_unthresh:.3f}, pos: {p_pos_unthresh:.3f})")
+
+    qc_results[str(unthresh_img_path)] = result
+
+with open(logdir / "qc_log.json", "w") as f:
+    json.dump(qc_results, f, indent=4)
 
 
 # - Get binarized thresholded maps (narps.get_binarized_thresh_masks())
 #     - input: thresholded original image
 #     - output: binarized version
 
+# Create binarized versions of thresholded images
+
+print("Creating binarized images...")
+thresh_images_to_binarize = find_bids_files(
+    datadir, type='thresh', desc='orig')
+print (f"Found {len(thresh_images_to_binarize)} thresh binarized images to process.")
+
+results = {}
+overwrite = False
+thresh = 1e-4
+for thresh_img_path in thresh_images_to_binarize:
+    outfile = Path(modify_bids_filename(
+        thresh_img_path,
+        desc='binarized', suffix='mask'
+    ))
+    if outfile.exists() and not overwrite:
+        continue
+
+    thresh_img = nib.load(str(thresh_img_path))
+    thresh_data = thresh_img.get_fdata()
+    thresh_data = np.nan_to_num(thresh_data)
+    binarized_data = (np.abs(thresh_data) > thresh).astype(np.float32)
+    binarized_img = nib.Nifti1Image(
+        binarized_data,
+        thresh_img.affine,
+        thresh_img.header
+    )
+    binarized_img.to_filename(str(outfile)) 
+    results[str(outfile)] = {
+        'infile': str(thresh_img_path),
+        'n_nonzero_voxels': int(np.sum(binarized_data))
+    }
+
+with open(logdir / "binarization_log.json", "w") as f:
+    json.dump(results, f, indent=4)
+
+
+# - Create rectified images - narps.create_rectified_images()
+#     - input: original image (thresh and unthresh versions)
+#     - output: rectified images for reverse contrasts
+#     - NOTE: see logic within get_binarized_thresh_masks 
+
+print("Creating rectified images...")
+results = {}
+overwrite = False
+
+for unthresh_img_path, values in qc_results.items():
+    if not Path(unthresh_img_path).exists():
+        continue
+
+    output_path = Path(modify_bids_filename(
+        unthresh_img_path,
+        desc='rectified'
+    ))
+
+    if output_path.exists() and not overwrite:
+        print(f"Rectified image already exists: {output_path}, skipping.")
+        continue
+
+    unthresh_img = nib.load(str(unthresh_img_path))
+    unthresh_data = unthresh_img.get_fdata()
+
+    if values.get("autorectify", False):
+        # mostly negative values, rectify
+        print(f"Rectifying unthresh image for hyp {hyp_num}, team {team_id}")
+        rectified_data = -1 * unthresh_data
+        qc_results[unthresh_img_path]["rectified"] = True
+    else:
+        rectified_data = unthresh_data
+        qc_results[unthresh_img_path]["rectified"] = False
+
+    rectified_img = nib.Nifti1Image(
+        rectified_data,
+        unthresh_img.affine,
+        unthresh_img.header
+    )
+    rectified_img.to_filename(str(output_path))
+
+    results[str(unthresh_img_path)] = result
+
+with open(logdir / "rectification_log.json", "w") as f:
+    json.dump(qc_results, f, indent=4)
+
 
 # - Get resampled images (narps.get_resampled_images())
 #     - input: all image types (thresh, bin, unthresh)
 #     - output: resampled image in MNI space
 
+## first get MNI152NLin2009cAsym template from templateflow
+mni_template = tflow.get("MNI152NLin2009cAsym", resolution=2, suffix="T1w", desc=None)
+
+print("Resampling images to MNI space...")
+results = {}
+overwrite = False
+all_images_to_resample = find_bids_files(
+    datadir, type='thresh', space='native', desc='binarized') + find_bids_files(
+    datadir, type='unthresh', space='native', desc='rectified') 
+
+print (f"Found {len(all_images_to_resample)} images to resample.")
+
+for img_path in all_images_to_resample:
+    components = parse_bids_filename(img_path)
+    output_path = Path(modify_bids_filename(
+        img_path,
+        space='MNI152NLin2009cAsym'
+    ))
+    results [str(output_path)] = {
+        'infile': str(img_path),
+    }
+    if output_path.exists() and not overwrite:
+        continue
+
+    img = nib.load(str(img_path))
+    # use linear interpolation for binarized maps, then threshold at 0.5
+    # this avoids empty voxels that can occur with NN interpolation
+    # resample to MNI space
+    if components['desc'] == 'binarized':
+        interpolation = 'linear'
+    else:
+        interpolation = 'continuous'
+    
+    resampled_img = resample_to_img(img, mni_template, 
+        interpolation=interpolation,
+        force_resample=True, copy_header=True)
+
+    if components['desc'] == 'binarized':
+        interpolation = 'linear'
+        # re-binarize
+        resampled_data = resampled_img.get_fdata()
+        binarized_data = (resampled_data > 0.5).astype(np.float32)
+        resampled_img = nib.Nifti1Image(
+            binarized_data,
+            resampled_img.affine,
+            resampled_img.header
+        )
+
+
+    resampled_img.to_filename(str(output_path))
+
+with open(logdir / "resampling_log.json", "w") as f:
+    json.dump(results, f, indent=4)
+
+
+
 
 # - Create concatenated versions of all images - narps.create_concat_imag
 #     - input: individual 3d images
 #     - output: combined 4d images for each image type
 
-
-# - Check image values - narps.check_image_values()
-#     - input: thresholded images
-#     - output: data frame with number of NA and nonzero voxels 
-
-
-# - Create mean thresholded images - narps.create_mean_thresholded_images()
-#     - input: contact thresh image
-#     - output: mean thresholded image
-
-
-# - Convert to zscores - narps.convert_to_zscores()
-#     - input: unthresh rectified images
-#     - output: zscore images
-
-
-# - Create concatenated utnhresh zstat images - narps.create_concat_images(datatype='zstat', imgtypes=['unthresh'],
-#                                create_voxel_map=True)
-#         input: zstat images
-#         output: concatenated 4d zstat image
-#         NOTE: maynbe consider using the concatenated unthresh image to compute zstats
-
-
-## Analyses
-
-# - Compute image stats - narps.compute_image_stats()
-#     input: unthresholded concatenated files
-#     output: range and std images
-
-# - Estimate smoothness - narps.estimate_smoothness() - relies upon FSL smoothest
-#     input: individual 3d team zstat images
-#     output: dataframe containing smoothness estimates for each team
-
-
-# ### Map analysis functions
-
-# NOTE: the following three are largely duplicative
-# - Create overlap maps - AnalyzeMaps.mk_overlap_maps
-#     input: mean thresholded images
-#     output: pdf and png files with rendering of map on anatomy
-# - Create range maps - AnalyzeMaps.mk_range_maps
-#     input: range images
-#     output: pdf/png files with rendering of range map on anatomy
-# - Create std maps - AnalyzeMaps.mk_std_maps
-#     input: std images
-#     output: pdf/png files with rendering of std map on anatomy
-
-# - Unthresholded correlation analysis - test_unthresh_correlation_analysis
-# - Create correlation maps for unthresholded images - AnalyzeMaps.mk_correlation_maps_unthresh
-#     input: concatenated unthresholded images
-#     output: 
-#         - median pattern correlation (?)
-#         - df containing correlation matrix between datasets for each hypothesis
-#         - png/pdf images of clustermap based on correlation matrix
-#         - cluster membership (saved as json)
-#         - reordered correlation matrix based on ward clustering
-#         - dendrograms for each hypothesis
-#     NOTE: this one has WAY too much going on - good candidate for refactoring example!
-# - Analyze clusters - AnalyzeMaps.analyze_clusters
-#     input: dendrograms and membership dict 
-#     output:
-#         - mean unthresholded map for each cluster/hypothesis
-#         - various stats output to logfile
-#         -pdf/png files with rendered thresholded map for each cluster
-#         - cluster metadata saved to csv
-#         - cluster similarity (rand scores) saved to csv
-#         - consistency of cluster membership across hypotheses
-# - Plot distance from mean - AnalyzeMaps.plot_distance_from_mean(narps)
-#     input: median pattern correlation
-#     output:
-#         - pdf with bar plot of correlations across teams
-#         - pdf of bar plot excluding teams above .2 correlation (i.e. only bad teams)
-# - Get similarity of thresholded images - AnalyzeMaps.get_thresh_similarity(narps)
-#     input: concatenated thresholded data
-#     output:
-#         - df with percent agreement
-#         - pdf/png with cluster map of percent agreement
-#         - mean jaccard for nonzero voxels
-# - Get thresholded z-stat maps - utils.get_thresholded_Z_maps(narps)
-#     input: unthresholded z maps and thresholded binarized maps
-#     output: thresholded Z maps
-#     NOTE: currently done on individual maps, probably should do on concatenated
-# - Get diagnostics on thresholded maps - ThreshVoxelStatistics.get_zstat_diagnostics(narps)
-#     input: thresholded and unthresholded maps
-#     output: diagnostic data comparing thresh and unthresh for each team
-# - Get stats on thresholded maps - ThreshVoxelStatistics.get_thresh_voxel_stats(narps.basedir)
-#     input: individual diagnostic data frames
-#     output:
-#         - df with all diagnostic data combined
-#         - df with statistics on thresholded maps
-# - Get similarity summary - GetMeanSimilarity.get_similarity_summary()
-#     input:  correlation data frames, cluster membership json
-#     output:
-#         - png with histogram of correlations
-#         - pngs with hisrogram of correlations for each cluster
-#         - data frame with correlation results by hyp/group
-
-
-# ### Consensus analysis functions
-
-# - run t-tests - ConsensusAnalysis.run_ttests
-#     input: unthresholded zstat images
-#     output:
-#         - t, pval, and fdr image for each hypothesis
-#         - tau image for each hypothesis
-# - make figures - ConsensusAnalysis.mk_figures()
-#     input: t and fdr images
-#     output: 
-#         - pdf with rendered consensus images
-#         - pdf with rendered tau maps
-#         - pdf with rendered tau histograms
-
-# - Compute cluster similarity for Tom et al. and mean activation - ClusterImageCorrelation.cluster_image_correlation
-#     input: cluster images and target image (mean or tom et al)
-#     output: 
-#         - correlation maps for each cluster vs target for each hyp
-#         - df with cluster correlations for each hyp
-
-# - Make combined cluster figures - MakeCombinedClusterFigures.make_combined_cluster_figures
-#     input: pngs for corr map and cluster means
-#     output: png with combined cluster images
-# - Make supp figure 1 - MakeSupplementaryFigure1.mk_supp_figure1
-#     input: metadata
-#     output: 
-#         - csv tables with merged metadata, decision data, and confidence data
-#         - png image with confidence data and modeling info
-
+concat_dir = basedir / "data-concat"
+if not concat_dir.exists():
+    concat_dir.mkdir(parents=True, exist_ok=True)
+
+results = {}
+for hyp in range(1,10):
+    print(f"Creating concatenated images for hypothesis {hyp}...")
+    
+    resampled_images = {'unthresh': find_bids_files(
+        datadir, type='unthresh', space='MNI152NLin2009cAsym', hyp=str(hyp)), 
+        'thresh': []}
+    team_ids = []
+    for img_path in resampled_images['unthresh']:
+        components = parse_bids_filename(img_path)
+        team_ids.append(components['team'])
+        thresh_img_path = modify_bids_filename(
+            img_path,
+            type='thresh', desc='binarized', suffix='mask'
+        )
+        assert Path(thresh_img_path).exists(), f"Binarized thresholded image not found for {img_path}"
+        resampled_images['thresh'].append(thresh_img_path)
+    assert len(resampled_images['thresh']) == len(resampled_images['unthresh']), "Mismatch in number of unthresh and thresh images"
+    print (f"Found {len(team_ids)} unthresh resampled images to concatenate for hypothesis {hyp}.")
+
+
+    suffix_dict = {'unthresh': 'stat', 'thresh': 'mask'}
+    for imgtype in ['unthresh', 'thresh']:
+        img_list = []
+        for img_path in resampled_images[imgtype]:
+            img = nib.load(str(img_path))
+            img_list.append(img)
+        # concatenate along 4th dimension
+        concat_img = nilearn.image.concat_imgs(img_list)
+
+        output_path = concat_dir / f"hyp-{hyp}_type-{imgtype}_space-MNI152NLin2009cAsym_desc-concat_{suffix_dict[imgtype]}.nii.gz"
+        concat_img.to_filename(str(output_path))
+        print(f"Saved concatenated {imgtype} image for hypothesis {hyp} to {output_path}")
+        results[str(output_path)] = {
+            'team_ids': team_ids
+        }
+
+with open(logdir / "concatenation_log.json", "w") as f:
+    json.dump(results, f, indent=4)
\ No newline at end of file

From ac742f6e9566c5beda9befe5fd9f8bdadd22c369 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 17:30:28 -0800
Subject: [PATCH 09/87] Add words

---
 project-words.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/project-words.txt b/project-words.txt
index 4b02c83..54f60e7 100644
--- a/project-words.txt
+++ b/project-words.txt
@@ -1,4 +1,5 @@
 # New Words
+ttests
 pheno
 tsim
 keepdims

From aaf1818955563a3da16b6272b45b7476675dc124 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 29 Nov 2025 17:33:38 -0800
Subject: [PATCH 10/87] ruff/blue fixes

---
 .../narps/narps_megascript.py                 | 264 ++++++++++--------
 1 file changed, 147 insertions(+), 117 deletions(-)

diff --git a/src/BetterCodeBetterScience/narps/narps_megascript.py b/src/BetterCodeBetterScience/narps/narps_megascript.py
index 98abaed..b4d3024 100644
--- a/src/BetterCodeBetterScience/narps/narps_megascript.py
+++ b/src/BetterCodeBetterScience/narps/narps_megascript.py
@@ -6,14 +6,14 @@
 from pathlib import Path
 import tarfile
 import urllib.request
-from typing import Dict, List, Union
 import shutil
 from BetterCodeBetterScience.narps.bids_utils import (
     parse_bids_filename,
     find_bids_files,
-    modify_bids_filename
+    modify_bids_filename,
 )
 from nilearn.maskers import NiftiMasker
+import nilearn.image
 import nibabel as nib
 import numpy as np
 import json
@@ -25,44 +25,50 @@
 ## Download data
 # - the organized data are available from https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz
 
-assert 'NARPS_DATADIR' in os.environ, "Please set NARPS_DATADIR in your environment variables or .env file"
+assert (
+    'NARPS_DATADIR' in os.environ
+), 'Please set NARPS_DATADIR in your environment variables or .env file'
 basedir = Path(os.environ['NARPS_DATADIR'])
 if not basedir.exists():
     basedir.mkdir(parents=True, exist_ok=True)
 
-narps_data_url = "https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz"
-narps_data_archive = basedir / "narps_origdata_1.0.tgz"
+narps_data_url = (
+    'https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz'
+)
+narps_data_archive = basedir / 'narps_origdata_1.0.tgz'
 
 overwrite_data = False
 
 if not narps_data_archive.exists() or overwrite_data:
 
-    print(f"Downloading NARPS data from {narps_data_url}...")
+    print(f'Downloading NARPS data from {narps_data_url}...')
     urllib.request.urlretrieve(narps_data_url, narps_data_archive)
-    print("Download complete.")
+    print('Download complete.')
 
-origdir = basedir / "orig"
+origdir = basedir / 'orig'
 if not origdir.exists() or overwrite_data:
-    print("Extracting data...")
-    with tarfile.open(narps_data_archive, "r:gz") as tar:
+    print('Extracting data...')
+    with tarfile.open(narps_data_archive, 'r:gz') as tar:
         tar.extractall(path=basedir)
-    print("Extraction complete.")
+    print('Extraction complete.')
 
-logdir = basedir / "logs"
+logdir = basedir / 'logs'
 if not logdir.exists():
     logdir.mkdir(parents=True, exist_ok=True)
 
 ## Get info about teams and hypotheses
 ## team dirs are in orig, starting with numeric team IDs
 
-teamdirs = sorted([d for d in origdir.iterdir() if d.is_dir() and d.name[0].isdigit()])
-print(f"Found {len(teamdirs)} team directories.")
+teamdirs = sorted(
+    [d for d in origdir.iterdir() if d.is_dir() and d.name[0].isdigit()]
+)
+print(f'Found {len(teamdirs)} team directories.')
 team_dict = {d.name: {'orig': d} for d in teamdirs}
 
 # convert orig data to a BIDS-like organization
 
 overwrite = False
-datadir = basedir / "data-teams"
+datadir = basedir / 'data-teams'
 if datadir.exists() and overwrite:
     shutil.rmtree(datadir)
 
@@ -75,16 +81,23 @@
     team_orig_dir = paths['orig']
     # include "thresh" to prevent some additional files from being detected
     for type in ['thresh', 'unthresh']:
-        for img_file in team_orig_dir.glob(f"*_{type}.nii.gz"):
-            hyp, imgtype = img_file.name.split('.')[0].replace('hypo','').split('_')
+        for img_file in team_orig_dir.glob(f'*_{type}.nii.gz'):
+            hyp, imgtype = (
+                img_file.name.split('.')[0].replace('hypo', '').split('_')
+            )
             try:
                 int(hyp)
             except ValueError:
-                print(f"Unexpected hypothesis number format in file {img_file}, skipping.")
+                print(
+                    f'Unexpected hypothesis number format in file {img_file}, skipping.'
+                )
                 continue
-            dest_file = datadir / f"team-{team_id_short}_hyp-{hyp}_type-{imgtype}_space-native_desc-orig_stat.nii.gz"
+            dest_file = (
+                datadir
+                / f'team-{team_id_short}_hyp-{hyp}_type-{imgtype}_space-native_desc-orig_stat.nii.gz'
+            )
             if not dest_file.exists():
-                print(f"Copying {img_file} to {dest_file}")
+                print(f'Copying {img_file} to {dest_file}')
                 shutil.copy(img_file.resolve(), dest_file)
             assert parse_bids_filename(dest_file)['team'] == team_id_short
             assert parse_bids_filename(dest_file)['hyp'] == hyp
@@ -97,34 +110,35 @@
 # - need for rectification (i.e. mostly negative values in unthresh image within the mask defined by the thresh image)
 #  - invalid in-mask values (i.e. both positive and negative values in unthresh image within the mask defined by the thresh image) - don't exclude, just note in log
 
-datadir_excluded = basedir / "data-teams-excluded"
+datadir_excluded = basedir / 'data-teams-excluded'
 if not datadir_excluded.exists():
     datadir_excluded.mkdir(parents=True, exist_ok=True)
 
 qc_results = {}
 error_thresh = 0.1  # proportion of invalid in-mask values to flag problem
 
-print("Running QC on original images...")
+print('Running QC on original images...')
 unthresh_images = find_bids_files(datadir, type='unthresh', desc='orig')
-print (f"Found {len(unthresh_images)} unthresh original images to QC.")
+print(f'Found {len(unthresh_images)} unthresh original images to QC.')
 
 for unthresh_img_path in unthresh_images:
     components = parse_bids_filename(unthresh_img_path)
     hyp_num = int(components['hyp'])
     team_id = components['team']
     result = {
-        "hyp": hyp_num,
-        "team_id": team_id,
-        'infile': str(unthresh_img_path)
+        'hyp': hyp_num,
+        'team_id': team_id,
+        'infile': str(unthresh_img_path),
     }
-    thresh_img_path = modify_bids_filename(
-        unthresh_img_path,
-        type='thresh'
-    )
+    thresh_img_path = modify_bids_filename(unthresh_img_path, type='thresh')
     if not Path(thresh_img_path).exists():
-        print(f"Thresholded image not found for hyp {hyp_num}, team {team_id}, moving to excluded data.")
-        shutil.move(unthresh_img_path, datadir_excluded / unthresh_img_path.name)
-        result["exclusion"] = 'thresholded image not found'
+        print(
+            f'Thresholded image not found for hyp {hyp_num}, team {team_id}, moving to excluded data.'
+        )
+        shutil.move(
+            unthresh_img_path, datadir_excluded / unthresh_img_path.name
+        )
+        result['exclusion'] = 'thresholded image not found'
         qc_results[str(unthresh_img_path)] = result
         continue
 
@@ -133,11 +147,19 @@
     thresh_img = nib.load(str(thresh_img_path))
 
     # check image dimensions and affine
-    if unthresh_img.shape != thresh_img.shape or not np.allclose(unthresh_img.affine, thresh_img.affine):
-        print(f"Image shape or affine mismatch for hyp {components['hyp']}, team {components['team']}, moving to excluded data.")
-        shutil.move(unthresh_img_path, datadir_excluded / unthresh_img_path.name)
-        shutil.move(thresh_img_path, datadir_excluded / Path(thresh_img_path).name)
-        result["exclusion"] = 'image shape or affine mismatch'
+    if unthresh_img.shape != thresh_img.shape or not np.allclose(
+        unthresh_img.affine, thresh_img.affine
+    ):
+        print(
+            f"Image shape or affine mismatch for hyp {components['hyp']}, team {components['team']}, moving to excluded data."
+        )
+        shutil.move(
+            unthresh_img_path, datadir_excluded / unthresh_img_path.name
+        )
+        shutil.move(
+            thresh_img_path, datadir_excluded / Path(thresh_img_path).name
+        )
+        result['exclusion'] = 'image shape or affine mismatch'
         qc_results[str(unthresh_img_path)] = result
         continue
 
@@ -145,8 +167,7 @@
     thresh_data = np.nan_to_num(thresh_data)
     n_thresh_vox = np.sum(thresh_data > 0)
     # check for min_p_direction > error_thresh
-    result["n_thresh_vox"] = int(n_thresh_vox)
-
+    result['n_thresh_vox'] = int(n_thresh_vox)
 
     if n_thresh_vox > 0:
         masker = NiftiMasker(mask_img=thresh_img)
@@ -157,26 +178,28 @@
         max_val = float(np.max(unthresh_data_masked.flatten()))
         p_pos_unthresh = float(np.mean(unthresh_data_masked.flatten() > 0))
         p_neg_unthresh = float(np.mean(unthresh_data_masked.flatten() < 0))
-        result["min_unthresh"] = min_val
-        result["max_unthresh"] = max_val
-        result["p_pos_unthresh"] = p_pos_unthresh
-        result["p_neg_unthresh"] = p_neg_unthresh
+        result['min_unthresh'] = min_val
+        result['max_unthresh'] = max_val
+        result['p_pos_unthresh'] = p_pos_unthresh
+        result['p_neg_unthresh'] = p_neg_unthresh
 
         if p_neg_unthresh > (1 - error_thresh):
             # mostly negative values, rectify
-            result["autorectify"] = True
+            result['autorectify'] = True
         else:
-            result["autorectify"] = False
+            result['autorectify'] = False
 
         # Check for problems - note these in QC but don't exclude
         min_p_direction = min(p_pos_unthresh, p_neg_unthresh)
         if min_p_direction > error_thresh:
-            result["problem"] = 'invalid in-mask values'
-            print(f"hyp {hyp_num}, team {team_id} - invalid in-mask values (neg: {p_neg_unthresh:.3f}, pos: {p_pos_unthresh:.3f})")
+            result['problem'] = 'invalid in-mask values'
+            print(
+                f'hyp {hyp_num}, team {team_id} - invalid in-mask values (neg: {p_neg_unthresh:.3f}, pos: {p_pos_unthresh:.3f})'
+            )
 
     qc_results[str(unthresh_img_path)] = result
 
-with open(logdir / "qc_log.json", "w") as f:
+with open(logdir / 'qc_log.json', 'w') as f:
     json.dump(qc_results, f, indent=4)
 
 
@@ -186,19 +209,21 @@
 
 # Create binarized versions of thresholded images
 
-print("Creating binarized images...")
+print('Creating binarized images...')
 thresh_images_to_binarize = find_bids_files(
-    datadir, type='thresh', desc='orig')
-print (f"Found {len(thresh_images_to_binarize)} thresh binarized images to process.")
+    datadir, type='thresh', desc='orig'
+)
+print(
+    f'Found {len(thresh_images_to_binarize)} thresh binarized images to process.'
+)
 
 results = {}
 overwrite = False
 thresh = 1e-4
 for thresh_img_path in thresh_images_to_binarize:
-    outfile = Path(modify_bids_filename(
-        thresh_img_path,
-        desc='binarized', suffix='mask'
-    ))
+    outfile = Path(
+        modify_bids_filename(thresh_img_path, desc='binarized', suffix='mask')
+    )
     if outfile.exists() and not overwrite:
         continue
 
@@ -207,26 +232,24 @@
     thresh_data = np.nan_to_num(thresh_data)
     binarized_data = (np.abs(thresh_data) > thresh).astype(np.float32)
     binarized_img = nib.Nifti1Image(
-        binarized_data,
-        thresh_img.affine,
-        thresh_img.header
+        binarized_data, thresh_img.affine, thresh_img.header
     )
-    binarized_img.to_filename(str(outfile)) 
+    binarized_img.to_filename(str(outfile))
     results[str(outfile)] = {
         'infile': str(thresh_img_path),
-        'n_nonzero_voxels': int(np.sum(binarized_data))
+        'n_nonzero_voxels': int(np.sum(binarized_data)),
     }
 
-with open(logdir / "binarization_log.json", "w") as f:
+with open(logdir / 'binarization_log.json', 'w') as f:
     json.dump(results, f, indent=4)
 
 
 # - Create rectified images - narps.create_rectified_images()
 #     - input: original image (thresh and unthresh versions)
 #     - output: rectified images for reverse contrasts
-#     - NOTE: see logic within get_binarized_thresh_masks 
+#     - NOTE: see logic within get_binarized_thresh_masks
 
-print("Creating rectified images...")
+print('Creating rectified images...')
 results = {}
 overwrite = False
 
@@ -234,37 +257,34 @@
     if not Path(unthresh_img_path).exists():
         continue
 
-    output_path = Path(modify_bids_filename(
-        unthresh_img_path,
-        desc='rectified'
-    ))
+    output_path = Path(
+        modify_bids_filename(unthresh_img_path, desc='rectified')
+    )
 
     if output_path.exists() and not overwrite:
-        print(f"Rectified image already exists: {output_path}, skipping.")
+        print(f'Rectified image already exists: {output_path}, skipping.')
         continue
 
     unthresh_img = nib.load(str(unthresh_img_path))
     unthresh_data = unthresh_img.get_fdata()
 
-    if values.get("autorectify", False):
+    if values.get('autorectify', False):
         # mostly negative values, rectify
-        print(f"Rectifying unthresh image for hyp {hyp_num}, team {team_id}")
+        print(f'Rectifying unthresh image for hyp {hyp_num}, team {team_id}')
         rectified_data = -1 * unthresh_data
-        qc_results[unthresh_img_path]["rectified"] = True
+        qc_results[unthresh_img_path]['rectified'] = True
     else:
         rectified_data = unthresh_data
-        qc_results[unthresh_img_path]["rectified"] = False
+        qc_results[unthresh_img_path]['rectified'] = False
 
     rectified_img = nib.Nifti1Image(
-        rectified_data,
-        unthresh_img.affine,
-        unthresh_img.header
+        rectified_data, unthresh_img.affine, unthresh_img.header
     )
     rectified_img.to_filename(str(output_path))
 
     results[str(unthresh_img_path)] = result
 
-with open(logdir / "rectification_log.json", "w") as f:
+with open(logdir / 'rectification_log.json', 'w') as f:
     json.dump(qc_results, f, indent=4)
 
 
@@ -273,24 +293,25 @@
 #     - output: resampled image in MNI space
 
 ## first get MNI152NLin2009cAsym template from templateflow
-mni_template = tflow.get("MNI152NLin2009cAsym", resolution=2, suffix="T1w", desc=None)
+mni_template = tflow.get(
+    'MNI152NLin2009cAsym', resolution=2, suffix='T1w', desc=None
+)
 
-print("Resampling images to MNI space...")
+print('Resampling images to MNI space...')
 results = {}
 overwrite = False
 all_images_to_resample = find_bids_files(
-    datadir, type='thresh', space='native', desc='binarized') + find_bids_files(
-    datadir, type='unthresh', space='native', desc='rectified') 
+    datadir, type='thresh', space='native', desc='binarized'
+) + find_bids_files(datadir, type='unthresh', space='native', desc='rectified')
 
-print (f"Found {len(all_images_to_resample)} images to resample.")
+print(f'Found {len(all_images_to_resample)} images to resample.')
 
 for img_path in all_images_to_resample:
     components = parse_bids_filename(img_path)
-    output_path = Path(modify_bids_filename(
-        img_path,
-        space='MNI152NLin2009cAsym'
-    ))
-    results [str(output_path)] = {
+    output_path = Path(
+        modify_bids_filename(img_path, space='MNI152NLin2009cAsym')
+    )
+    results[str(output_path)] = {
         'infile': str(img_path),
     }
     if output_path.exists() and not overwrite:
@@ -304,10 +325,14 @@
         interpolation = 'linear'
     else:
         interpolation = 'continuous'
-    
-    resampled_img = resample_to_img(img, mni_template, 
+
+    resampled_img = resample_to_img(
+        img,
+        mni_template,
         interpolation=interpolation,
-        force_resample=True, copy_header=True)
+        force_resample=True,
+        copy_header=True,
+    )
 
     if components['desc'] == 'binarized':
         interpolation = 'linear'
@@ -315,48 +340,50 @@
         resampled_data = resampled_img.get_fdata()
         binarized_data = (resampled_data > 0.5).astype(np.float32)
         resampled_img = nib.Nifti1Image(
-            binarized_data,
-            resampled_img.affine,
-            resampled_img.header
+            binarized_data, resampled_img.affine, resampled_img.header
         )
 
-
     resampled_img.to_filename(str(output_path))
 
-with open(logdir / "resampling_log.json", "w") as f:
+with open(logdir / 'resampling_log.json', 'w') as f:
     json.dump(results, f, indent=4)
 
 
-
-
 # - Create concatenated versions of all images - narps.create_concat_imag
 #     - input: individual 3d images
 #     - output: combined 4d images for each image type
 
-concat_dir = basedir / "data-concat"
+concat_dir = basedir / 'data-concat'
 if not concat_dir.exists():
     concat_dir.mkdir(parents=True, exist_ok=True)
 
 results = {}
-for hyp in range(1,10):
-    print(f"Creating concatenated images for hypothesis {hyp}...")
-    
-    resampled_images = {'unthresh': find_bids_files(
-        datadir, type='unthresh', space='MNI152NLin2009cAsym', hyp=str(hyp)), 
-        'thresh': []}
+for hyp in range(1, 10):
+    print(f'Creating concatenated images for hypothesis {hyp}...')
+
+    resampled_images = {
+        'unthresh': find_bids_files(
+            datadir, type='unthresh', space='MNI152NLin2009cAsym', hyp=str(hyp)
+        ),
+        'thresh': [],
+    }
     team_ids = []
     for img_path in resampled_images['unthresh']:
         components = parse_bids_filename(img_path)
         team_ids.append(components['team'])
         thresh_img_path = modify_bids_filename(
-            img_path,
-            type='thresh', desc='binarized', suffix='mask'
+            img_path, type='thresh', desc='binarized', suffix='mask'
         )
-        assert Path(thresh_img_path).exists(), f"Binarized thresholded image not found for {img_path}"
+        assert Path(
+            thresh_img_path
+        ).exists(), f'Binarized thresholded image not found for {img_path}'
         resampled_images['thresh'].append(thresh_img_path)
-    assert len(resampled_images['thresh']) == len(resampled_images['unthresh']), "Mismatch in number of unthresh and thresh images"
-    print (f"Found {len(team_ids)} unthresh resampled images to concatenate for hypothesis {hyp}.")
-
+    assert len(resampled_images['thresh']) == len(
+        resampled_images['unthresh']
+    ), 'Mismatch in number of unthresh and thresh images'
+    print(
+        f'Found {len(team_ids)} unthresh resampled images to concatenate for hypothesis {hyp}.'
+    )
 
     suffix_dict = {'unthresh': 'stat', 'thresh': 'mask'}
     for imgtype in ['unthresh', 'thresh']:
@@ -367,12 +394,15 @@
         # concatenate along 4th dimension
         concat_img = nilearn.image.concat_imgs(img_list)
 
-        output_path = concat_dir / f"hyp-{hyp}_type-{imgtype}_space-MNI152NLin2009cAsym_desc-concat_{suffix_dict[imgtype]}.nii.gz"
+        output_path = (
+            concat_dir
+            / f'hyp-{hyp}_type-{imgtype}_space-MNI152NLin2009cAsym_desc-concat_{suffix_dict[imgtype]}.nii.gz'
+        )
         concat_img.to_filename(str(output_path))
-        print(f"Saved concatenated {imgtype} image for hypothesis {hyp} to {output_path}")
-        results[str(output_path)] = {
-            'team_ids': team_ids
-        }
+        print(
+            f'Saved concatenated {imgtype} image for hypothesis {hyp} to {output_path}'
+        )
+        results[str(output_path)] = {'team_ids': team_ids}
 
-with open(logdir / "concatenation_log.json", "w") as f:
-    json.dump(results, f, indent=4)
\ No newline at end of file
+with open(logdir / 'concatenation_log.json', 'w') as f:
+    json.dump(results, f, indent=4)

From 561c3b0ac91c9c8cc1be2628dcb608d5c21aefb7 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 30 Nov 2025 09:56:11 -0800
Subject: [PATCH 11/87] fix suffix handling

---
 src/BetterCodeBetterScience/narps/bids_utils.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/BetterCodeBetterScience/narps/bids_utils.py b/src/BetterCodeBetterScience/narps/bids_utils.py
index 1a41efe..66c1d8c 100644
--- a/src/BetterCodeBetterScience/narps/bids_utils.py
+++ b/src/BetterCodeBetterScience/narps/bids_utils.py
@@ -130,9 +130,14 @@ def modify_bids_filename(filename: Union[str, Path], **bids_tags) -> Union[str,
             ordered_pairs.append((key, value))
             existing_keys.add(key)
     
-    # Add any new keys from bids_tags that weren't in original
+    # Check if suffix should be modified
+    if 'suffix' in bids_tags:
+        suffix = bids_tags['suffix']
+        existing_keys.add('suffix')
+    
+    # Add any new keys from bids_tags that weren't in original (except suffix)
     for key, value in bids_tags.items():
-        if key not in existing_keys:
+        if key not in existing_keys and key != 'suffix':
             ordered_pairs.append((key, value))
     
     # Reconstruct filename maintaining order

From 7973dd209928e1b846cac80b1d59dbecae26f0c1 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 30 Nov 2025 09:56:23 -0800
Subject: [PATCH 12/87] fix suffix handling

---
 tests/narps/test_bids.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/narps/test_bids.py b/tests/narps/test_bids.py
index 6961659..1f10019 100644
--- a/tests/narps/test_bids.py
+++ b/tests/narps/test_bids.py
@@ -367,6 +367,25 @@ def test_modify_bids_filename_preserve_suffix():
     assert result.endswith("_bold.nii.gz")
 
 
+def test_modify_bids_filename_change_suffix():
+    """Test changing the suffix."""
+    original = "sub-01_task-rest_bold.nii.gz"
+    result = modify_bids_filename(original, suffix="T1w")
+    
+    # Suffix should be at the end, not as suffix-value
+    assert result == "sub-01_task-rest_T1w.nii.gz"
+    assert "suffix-" not in result
+
+
+def test_modify_bids_filename_change_suffix_and_tags():
+    """Test changing both suffix and other tags."""
+    original = "sub-01_task-rest_bold.nii.gz"
+    result = modify_bids_filename(original, task="memory", suffix="T1w")
+    
+    assert result == "sub-01_task-memory_T1w.nii.gz"
+    assert "suffix-" not in result
+
+
 def test_modify_bids_filename_complex_modification():
     """Test complex modification with many changes."""
     original = "sub-01_ses-01_task-rest_acq-mb_bold.nii.gz"

From 5cf3f15af48ef959d5b5509b4b35a84464bba169 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 30 Nov 2025 09:56:41 -0800
Subject: [PATCH 13/87] working version

---
 .../narps/narps_megascript.py                 | 174 ++++++++++++++----
 1 file changed, 143 insertions(+), 31 deletions(-)

diff --git a/src/BetterCodeBetterScience/narps/narps_megascript.py b/src/BetterCodeBetterScience/narps/narps_megascript.py
index b4d3024..d7c6843 100644
--- a/src/BetterCodeBetterScience/narps/narps_megascript.py
+++ b/src/BetterCodeBetterScience/narps/narps_megascript.py
@@ -19,10 +19,12 @@
 import json
 import templateflow.api as tflow
 from nilearn.image import resample_to_img
+import pandas as pd
+from scipy.stats import norm, t
 
 dotenv.load_dotenv()
 
-## Download data
+## 1. Download data
 # - the organized data are available from https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz
 
 assert (
@@ -56,16 +58,8 @@
 if not logdir.exists():
     logdir.mkdir(parents=True, exist_ok=True)
 
-## Get info about teams and hypotheses
-## team dirs are in orig, starting with numeric team IDs
 
-teamdirs = sorted(
-    [d for d in origdir.iterdir() if d.is_dir() and d.name[0].isdigit()]
-)
-print(f'Found {len(teamdirs)} team directories.')
-team_dict = {d.name: {'orig': d} for d in teamdirs}
-
-# convert orig data to a BIDS-like organization
+## 2. convert orig data to a BIDS-like organization
 
 overwrite = False
 datadir = basedir / 'data-teams'
@@ -75,9 +69,24 @@
 if not datadir.exists():
     datadir.mkdir(parents=True, exist_ok=True)
 
+# Get info about teams - we will only process data for hypothesis 1 here
+# team dirs are in orig, starting with numeric team IDs
+
+teamdirs = sorted(
+    [d for d in origdir.iterdir() if d.is_dir() and d.name[0].isdigit()]
+)
+print(f'Found {len(teamdirs)} team directories.')
+team_dict = {d.name: {'orig': d} for d in teamdirs}
+
+# we will only process hypothesis 1 for this analysis for the sake of speed
+target_hypothesis = 1
+
+team_id_to_number = {}
+
 for team_id, paths in team_dict.items():
     # only use the team number
     team_id_short = team_id.split('_')[0]
+    team_id_to_number[team_id.split('_')[1]] = team_id_short
     team_orig_dir = paths['orig']
     # include "thresh" to prevent some additional files from being detected
     for type in ['thresh', 'unthresh']:
@@ -92,6 +101,8 @@
                     f'Unexpected hypothesis number format in file {img_file}, skipping.'
                 )
                 continue
+            if int(hyp) != target_hypothesis:
+                continue
             dest_file = (
                 datadir
                 / f'team-{team_id_short}_hyp-{hyp}_type-{imgtype}_space-native_desc-orig_stat.nii.gz'
@@ -103,7 +114,7 @@
             assert parse_bids_filename(dest_file)['hyp'] == hyp
             assert parse_bids_filename(dest_file)['type'] == imgtype
 
-# QC to identify bad data and move them to excluded data dir
+## 3. QC to identify bad data and move them to excluded data dir
 # look for:
 #  - different image dimensions or affine between thresh and unthresh images for a given team/hyp
 # - missing thresholded images
@@ -169,6 +180,9 @@
     # check for min_p_direction > error_thresh
     result['n_thresh_vox'] = int(n_thresh_vox)
 
+    # decide whether to rectify based on in-mask values
+    # and info from researcher survey
+
     if n_thresh_vox > 0:
         masker = NiftiMasker(mask_img=thresh_img)
         masker.fit()
@@ -203,11 +217,9 @@
     json.dump(qc_results, f, indent=4)
 
 
-# - Get binarized thresholded maps (narps.get_binarized_thresh_masks())
-#     - input: thresholded original image
-#     - output: binarized version
-
-# Create binarized versions of thresholded images
+## 4 - Get binarized thresholded maps 
+# some thresholded masks have continuous values, so we will binarize 
+# them at a small threshold (1e-4)
 
 print('Creating binarized images...')
 thresh_images_to_binarize = find_bids_files(
@@ -244,10 +256,10 @@
     json.dump(results, f, indent=4)
 
 
-# - Create rectified images - narps.create_rectified_images()
-#     - input: original image (thresh and unthresh versions)
-#     - output: rectified images for reverse contrasts
-#     - NOTE: see logic within get_binarized_thresh_masks
+# 5 - Create rectified images 
+# some unthresh images need to be rectified (i.e. multiplied by -1)
+# so that they match the hypothesis
+# we infer this based on the match between thresh and unthresh images
 
 print('Creating rectified images...')
 results = {}
@@ -282,15 +294,13 @@
     )
     rectified_img.to_filename(str(output_path))
 
-    results[str(unthresh_img_path)] = result
+    results[str(output_path)] = result
 
 with open(logdir / 'rectification_log.json', 'w') as f:
     json.dump(qc_results, f, indent=4)
 
 
-# - Get resampled images (narps.get_resampled_images())
-#     - input: all image types (thresh, bin, unthresh)
-#     - output: resampled image in MNI space
+## 6:  Get resampled images
 
 ## first get MNI152NLin2009cAsym template from templateflow
 mni_template = tflow.get(
@@ -348,22 +358,122 @@
 with open(logdir / 'resampling_log.json', 'w') as f:
     json.dump(results, f, indent=4)
 
+## 7: convert concatenated unthresh image to z scores
+# some teams provided t instead of z scores
+
+
+def TtoZ(data, df=54):
+    """
+    takes a nibabel file object and converts from z to t
+    using Hughett's transform
+    adapted from:
+    https://github.com/vsoch/TtoZ/blob/master/TtoZ/scripts.py
+    - default to 54 which is full sample per condition for narps
+    """
+
+    # Select just the nonzero voxels
+    nonzero_vox = data != 0
+    nonzero = data[nonzero_vox]
+
+    # We will store our results here
+    Z = np.zeros(len(nonzero))
+
+    # Select values less than or == 0, and greater than zero
+    c = np.zeros(len(nonzero))
+    k1 = nonzero <= c
+    k2 = nonzero > c
+
+    # Subset the data into two sets
+    t1 = nonzero[k1]
+    t2 = nonzero[k2]
+
+    # Calculate p values for <=0
+    p_values_t1 = t.cdf(t1, df=df)
+    z_values_t1 = norm.ppf(p_values_t1)
+
+    # Calculate p values for > 0
+    p_values_t2 = t.cdf(-t2, df=df)
+    z_values_t2 = -norm.ppf(p_values_t2)
+    Z[k1] = z_values_t1
+    Z[k2] = z_values_t2
+
+    # Write new image to file
+    new_nii = np.zeros(data.shape)
+    new_nii[nonzero_vox] = Z
+
+    return new_nii
+
+
+print('Converting unthresh images to z-scores...')
+
+# first load the spreadsheet to get the stats types
+stats_types_df = pd.read_csv(
+    origdir / 'narps_neurovault_images_details_responses_corrected.csv'
+        ) #.set_index('team_id')
+stats_types_df.columns = [
+    'Timestamp', 'team_id', 'software',
+    'unthresh_type', 'thresh_type',
+    'template', 'h5', 'h6', 'h9', 'comments']
+stats_types_df['team_number'] = [
+    team_id_to_number.get(tid, None) for tid in stats_types_df['team_id']]
+
+stat_type_by_team = {}
+for _, row in stats_types_df.iterrows():
+    team_number = row['team_number']
+    if 't value' in row['unthresh_type'].strip().lower():
+        stat_type_by_team[team_number] = 't'
+    else:
+        # default to z if unsure - i.e. no conversion
+        stat_type_by_team[team_number] = 'z'
+
+for team, stattype in stat_type_by_team.items():
+    team_unthresh_images = find_bids_files(
+        datadir, team=team,type='unthresh', space='MNI152NLin2009cAsym', desc='rectified'
+    )
+    if len(team_unthresh_images) == 0:
+        continue
+    if len(team_unthresh_images) > 1:
+        print(f'Warning: multiple unthresh images found for team {team}, using first one.')
+    unthresh_img_path = team_unthresh_images[0]
+    output_path = Path(
+        modify_bids_filename(
+            unthresh_img_path, suffix='zstat'
+        )
+    )
+    if output_path.exists() and not overwrite:
+        continue
+    unthresh_img = nib.load(str(unthresh_img_path))
+    unthresh_data = unthresh_img.get_fdata()
+    converted = False
+    if stattype == 't':
+        unthresh_data = TtoZ(unthresh_data, df=54)
+        converted = True
+    zstat_img = nib.Nifti1Image(
+        unthresh_data, unthresh_img.affine, unthresh_img.header
+    )
+    zstat_img.to_filename(str(output_path))
+    results[str(output_path)] = {
+        'infile': str(unthresh_img_path),
+        'original_stat_type': stattype,
+    }
+
+with open(logdir / 't_to_z_log.json', 'w') as f:
+    json.dump(results, f, indent=4)
 
-# - Create concatenated versions of all images - narps.create_concat_imag
-#     - input: individual 3d images
-#     - output: combined 4d images for each image type
+## 8: Create concatenated versions of all images 
 
 concat_dir = basedir / 'data-concat'
 if not concat_dir.exists():
     concat_dir.mkdir(parents=True, exist_ok=True)
 
 results = {}
-for hyp in range(1, 10):
+for hyp in [target_hypothesis]:
     print(f'Creating concatenated images for hypothesis {hyp}...')
 
     resampled_images = {
         'unthresh': find_bids_files(
-            datadir, type='unthresh', space='MNI152NLin2009cAsym', hyp=str(hyp)
+            datadir, type='unthresh', space='MNI152NLin2009cAsym', hyp=str(hyp),
+            suffix='zstat'
         ),
         'thresh': [],
     }
@@ -385,12 +495,13 @@
         f'Found {len(team_ids)} unthresh resampled images to concatenate for hypothesis {hyp}.'
     )
 
-    suffix_dict = {'unthresh': 'stat', 'thresh': 'mask'}
+    suffix_dict = {'unthresh': 'zstat', 'thresh': 'mask'}
     for imgtype in ['unthresh', 'thresh']:
         img_list = []
         for img_path in resampled_images[imgtype]:
             img = nib.load(str(img_path))
             img_list.append(img)
+            img_paths = [p.as_posix() for p in resampled_images[imgtype]]
         # concatenate along 4th dimension
         concat_img = nilearn.image.concat_imgs(img_list)
 
@@ -402,7 +513,8 @@
         print(
             f'Saved concatenated {imgtype} image for hypothesis {hyp} to {output_path}'
         )
-        results[str(output_path)] = {'team_ids': team_ids}
+        results[str(output_path)] = {'infiles': img_paths}
 
 with open(logdir / 'concatenation_log.json', 'w') as f:
     json.dump(results, f, indent=4)
+

From 9024ea1a360c29a3b0ecd2f97294b5e5234edee2 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 30 Nov 2025 10:50:21 -0800
Subject: [PATCH 14/87] minor cleanup, format with blue ?

---
 .../narps/narps_megascript.py                 | 51 ++++++++++++-------
 1 file changed, 32 insertions(+), 19 deletions(-)

diff --git a/src/BetterCodeBetterScience/narps/narps_megascript.py b/src/BetterCodeBetterScience/narps/narps_megascript.py
index d7c6843..b7e6ddf 100644
--- a/src/BetterCodeBetterScience/narps/narps_megascript.py
+++ b/src/BetterCodeBetterScience/narps/narps_megascript.py
@@ -217,8 +217,8 @@
     json.dump(qc_results, f, indent=4)
 
 
-## 4 - Get binarized thresholded maps 
-# some thresholded masks have continuous values, so we will binarize 
+## 4 - Get binarized thresholded maps
+# some thresholded masks have continuous values, so we will binarize
 # them at a small threshold (1e-4)
 
 print('Creating binarized images...')
@@ -256,7 +256,7 @@
     json.dump(results, f, indent=4)
 
 
-# 5 - Create rectified images 
+# 5 - Create rectified images
 # some unthresh images need to be rectified (i.e. multiplied by -1)
 # so that they match the hypothesis
 # we infer this based on the match between thresh and unthresh images
@@ -409,13 +409,22 @@ def TtoZ(data, df=54):
 # first load the spreadsheet to get the stats types
 stats_types_df = pd.read_csv(
     origdir / 'narps_neurovault_images_details_responses_corrected.csv'
-        ) #.set_index('team_id')
+)   # .set_index('team_id')
 stats_types_df.columns = [
-    'Timestamp', 'team_id', 'software',
-    'unthresh_type', 'thresh_type',
-    'template', 'h5', 'h6', 'h9', 'comments']
+    'Timestamp',
+    'team_id',
+    'software',
+    'unthresh_type',
+    'thresh_type',
+    'template',
+    'h5',
+    'h6',
+    'h9',
+    'comments',
+]
 stats_types_df['team_number'] = [
-    team_id_to_number.get(tid, None) for tid in stats_types_df['team_id']]
+    team_id_to_number.get(tid, None) for tid in stats_types_df['team_id']
+]
 
 stat_type_by_team = {}
 for _, row in stats_types_df.iterrows():
@@ -428,18 +437,20 @@ def TtoZ(data, df=54):
 
 for team, stattype in stat_type_by_team.items():
     team_unthresh_images = find_bids_files(
-        datadir, team=team,type='unthresh', space='MNI152NLin2009cAsym', desc='rectified'
+        datadir,
+        team=team,
+        type='unthresh',
+        space='MNI152NLin2009cAsym',
+        desc='rectified',
     )
     if len(team_unthresh_images) == 0:
         continue
     if len(team_unthresh_images) > 1:
-        print(f'Warning: multiple unthresh images found for team {team}, using first one.')
-    unthresh_img_path = team_unthresh_images[0]
-    output_path = Path(
-        modify_bids_filename(
-            unthresh_img_path, suffix='zstat'
+        print(
+            f'Warning: multiple unthresh images found for team {team}, using first one.'
         )
-    )
+    unthresh_img_path = team_unthresh_images[0]
+    output_path = Path(modify_bids_filename(unthresh_img_path, suffix='zstat'))
     if output_path.exists() and not overwrite:
         continue
     unthresh_img = nib.load(str(unthresh_img_path))
@@ -460,7 +471,7 @@ def TtoZ(data, df=54):
 with open(logdir / 't_to_z_log.json', 'w') as f:
     json.dump(results, f, indent=4)
 
-## 8: Create concatenated versions of all images 
+## 8: Create concatenated versions of all images
 
 concat_dir = basedir / 'data-concat'
 if not concat_dir.exists():
@@ -472,8 +483,11 @@ def TtoZ(data, df=54):
 
     resampled_images = {
         'unthresh': find_bids_files(
-            datadir, type='unthresh', space='MNI152NLin2009cAsym', hyp=str(hyp),
-            suffix='zstat'
+            datadir,
+            type='unthresh',
+            space='MNI152NLin2009cAsym',
+            hyp=str(hyp),
+            suffix='zstat',
         ),
         'thresh': [],
     }
@@ -517,4 +531,3 @@ def TtoZ(data, df=54):
 
 with open(logdir / 'concatenation_log.json', 'w') as f:
     json.dump(results, f, indent=4)
-

From 936ea6c6e842656bb17db42a2a4d802c4200f108 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Thu, 4 Dec 2025 07:27:14 -0800
Subject: [PATCH 15/87] initial workflow development

---
 book/extras.md    |  9 +++++++++
 book/workflows.md |  7 +++++--
 pyproject.toml    |  1 +
 uv.lock           | 11 +++++++++++
 4 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/book/extras.md b/book/extras.md
index 6d9b932..14a4269 100644
--- a/book/extras.md
+++ b/book/extras.md
@@ -329,3 +329,12 @@ Found 422 publications containing Memory in the title
 One very nice feature of the document store is that not all records have to have the same keys; this provides a great deal of flexibility at data ingestion.  However, too much heterogeneity between documents can make the database hard to work with.  One benefit of homogeneity in the document structure is that it allows indexing, which can greatly increase the speed of queries in large document stores.  For example, if we know that we will often want to search by the `year` field, then we can add an index for this field:
 
 *MORE HERE*
+
+
+### NARPS
+
+The example comes from a paper that we published in 2020 {cite:p}`Botvinik-Nezer:2020aa`, which involved analysis of data from a large study called the Neuroimaging Analysis Replication and Prediction Study (hereafter *NARPS* for short).  The goal of this study was to identify how the results of data analysis varied between different research groups when given the same data.  A relatively large neuroimaging dataset was collected and distributed to groups of researchers, who were asked to test a set of nine hypotheses about brain activity in relation to a monetary gambling task that the participants performed during MRI scanning.  Seventy teams submitted results, which included their answers to the 9 yes/no hypotheses along with a detailed description of their analysis workflow and a number of outputs from intermediate stages of the analysis. The main finding was that there was a striking amount of variability in the results between teams, even though the raw data were identical.
+
+The workflow that I will use here starts with the results that the teams submitted, and ends with preprocessed data that are ready for further statistical analysis.  I wrote much of the original analysis code for the project, which can be found [here](https://github.com/poldrack/narps).  This code was written at the point when I was just becoming interested in software engineering practices for science, and while it represents a first step in that direction, it has *a lot* of problems. In particular, it uses the problematic *God object* anti-pattern that I mentioned in an earlier chapter.  For the purposes of this chapter I have first rewritten the analysis into a monolithic mega-script, which I will then incrementally refactor into a well-structured workflow.  I chose this example because it is relatively complex yet runs quickly on any modern laptop.  
+
+
diff --git a/book/workflows.md b/book/workflows.md
index 1b56b8e..4d10fdb 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -30,15 +30,18 @@ Finally, we care about the *efficiency* of the workflow implementation. This inc
 
 It's worth noting that these different desiderata will sometimes conflict with one another (such as configurability versus maintainability), and that no workflow will be perfect.  
 
+## An example workflow
 
+In this chapter I will use a running example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features outlined above.  
 
-### Breaking a workflow into stages
+
+## Breaking a workflow into stages
 
 good breakpoints between workflow modules include:
 
 - conceptual logic - different stages do different things 
 - points where one might need to restart the computation (e.g. due to computational cost)
-- sections where one might wish to swap in a new method
+- sections where one might wish to swap in a new method or different parameterization
 - points where the output could be reusable elsewhere
 
 the workflow should be stateless when possible
diff --git a/pyproject.toml b/pyproject.toml
index 8f8d3ec..da969f7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -60,6 +60,7 @@ dependencies = [
     "statsmodels>=0.14.5",
     "blue>=0.9.1",
     "nilearn>=0.12.1",
+    "fmriprep-docker>=25.2.3",
 ]
 
 [build-system]
diff --git a/uv.lock b/uv.lock
index dde3a40..c5951fe 100644
--- a/uv.lock
+++ b/uv.lock
@@ -312,6 +312,7 @@ dependencies = [
     { name = "docutils" },
     { name = "fastembed" },
     { name = "fastparquet" },
+    { name = "fmriprep-docker" },
     { name = "gprofiler-official" },
     { name = "h5py" },
     { name = "hypothesis" },
@@ -371,6 +372,7 @@ requires-dist = [
     { name = "docutils", specifier = "==0.17.1" },
     { name = "fastembed", specifier = ">=0.7.3" },
     { name = "fastparquet", specifier = ">=2024.11.0" },
+    { name = "fmriprep-docker", specifier = ">=25.2.3" },
     { name = "gprofiler-official", specifier = ">=1.0.0" },
     { name = "h5py", specifier = ">=3.15.1" },
     { name = "hypothesis", specifier = ">=6.115.3" },
@@ -1326,6 +1328,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ee/1b/00a78aa2e8fbd63f9af08c9c19e6deb3d5d66b4dda677a0f61654680ee89/flatbuffers-25.9.23-py2.py3-none-any.whl", hash = "sha256:255538574d6cb6d0a79a17ec8bc0d30985913b87513a01cce8bcdb6b4c44d0e2", size = 30869, upload-time = "2025-09-24T05:25:28.912Z" },
 ]
 
+[[package]]
+name = "fmriprep-docker"
+version = "25.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/1a/df92c6e30179895add181faf3a7ce0ee9c7888052177cb0ca29a35e99db6/fmriprep_docker-25.2.3.tar.gz", hash = "sha256:19c9fe7ac860a49142aa51e5351c44af2a68737a3a0c78603e2ef138f718ae93", size = 9278, upload-time = "2025-10-17T18:07:32.242Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/b3/b442ad416fd14bbc33ef7c595f5cbe119c2b612f2f1b77928be5e5d583dd/fmriprep_docker-25.2.3-py2.py3-none-any.whl", hash = "sha256:16b31baf18fa9bf761e022ec931bde3464a0673d5778c9ed5121ebb4208ae241", size = 10449, upload-time = "2025-10-17T18:07:28.637Z" },
+]
+
 [[package]]
 name = "fonttools"
 version = "4.54.1"

From eb12af0fe3e3b888ac93dd32edc2cf687b32f3bd Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 15 Dec 2025 15:11:22 -0800
Subject: [PATCH 16/87] cleanup

---
 .gitmodules     | 4 ----
 my_datalad_repo | 1 -
 2 files changed, 5 deletions(-)
 delete mode 160000 my_datalad_repo

diff --git a/.gitmodules b/.gitmodules
index 5bca6a6..e69de29 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +0,0 @@
-[submodule "my_datalad_repo"]
-	path = my_datalad_repo
-	url = ./my_datalad_repo
-	datalad-id = 74807713-a6cf-4418-9dfc-e490a881645b
diff --git a/my_datalad_repo b/my_datalad_repo
deleted file mode 160000
index e8ce63a..0000000
--- a/my_datalad_repo
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e8ce63a3121002619888b8a6c87a693d177d78ea

From 1147e5f48e17668b8f97547eeda9bf012221d5a0 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 15 Dec 2025 15:26:47 -0800
Subject: [PATCH 17/87] update build cmds

---
 Makefile | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile
index 7cd3860..35add9a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,10 +1,11 @@
 clean:
 	- rm -rf book/_build
 
-build: clean
-	uv run jupyter-book build book/
+build-html: clean
+	myst build --html
+	npx serve _build/html
 
-pdf:
+build-pdf:
 	jupyter-book build book/ --builder pdflatex
 
 pipinstall:

From b9f4b22aeb53f0f7147dec9becc2409d29862e90 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 16 Dec 2025 07:30:47 -0800
Subject: [PATCH 18/87] add deps

---
 myst.yml       |  4 +--
 pyproject.toml |  2 ++
 uv.lock        | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 77 insertions(+), 2 deletions(-)

diff --git a/myst.yml b/myst.yml
index b4c5624..e179bf8 100644
--- a/myst.yml
+++ b/myst.yml
@@ -8,7 +8,7 @@ project:
     - book/references.bib
   exports:
     - format: pdf
-      template: https://github.com/myst-templates/plain_typst_book.git 
+      template: plain_latex_book
       output: exports/book.pdf
     - format: md
     - format: docx
@@ -30,5 +30,5 @@ project:
 site:
   options:
     logo: logo.png
-    folders: true
+#    folders: true
   template: book-theme
diff --git a/pyproject.toml b/pyproject.toml
index 795338a..4e1d5b6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -62,6 +62,8 @@ dependencies = [
     "nilearn>=0.12.1",
     "fmriprep-docker>=25.2.3",
     "mystmd>=1.7.0",
+    "mne>=1.11.0",
+    "mongomock>=4.3.0",
 ]
 
 [build-system]
diff --git a/uv.lock b/uv.lock
index 5afa41f..a31483c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -309,7 +309,9 @@ dependencies = [
     { name = "mariadb" },
     { name = "matplotlib" },
     { name = "mdnewline" },
+    { name = "mne" },
     { name = "monarch-py" },
+    { name = "mongomock" },
     { name = "mysql-connector-python" },
     { name = "mystmd" },
     { name = "neo4j" },
@@ -370,7 +372,9 @@ requires-dist = [
     { name = "mariadb", specifier = ">=1.1.14" },
     { name = "matplotlib", specifier = ">=3.9.2" },
     { name = "mdnewline", specifier = ">=0.1.3" },
+    { name = "mne", specifier = ">=1.11.0" },
     { name = "monarch-py", specifier = ">=1.22.0" },
+    { name = "mongomock", specifier = ">=4.3.0" },
     { name = "mysql-connector-python", specifier = ">=9.5.0" },
     { name = "mystmd", specifier = ">=1.7.0" },
     { name = "neo4j", specifier = ">=6.0.3" },
@@ -2437,6 +2441,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },
 ]
 
+[[package]]
+name = "lazy-loader"
+version = "0.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6b/c875b30a1ba490860c93da4cabf479e03f584eba06fe5963f6f6644653d8/lazy_loader-0.4.tar.gz", hash = "sha256:47c75182589b91a4e1a85a136c074285a5ad4d9f39c63e0d7fb76391c4574cd1", size = 15431, upload-time = "2024-04-05T13:03:12.261Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097, upload-time = "2024-04-05T13:03:10.514Z" },
+]
+
 [[package]]
 name = "linkml"
 version = "1.9.3"
@@ -2728,6 +2744,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/fd/f7420e8cbce45c259c770cac5718badf907b302d3a99ec587ba5ce030237/mmh3-5.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:3d6bfd9662a20c054bc216f861fa330c2dac7c81e7fb8307b5e32ab5b9b4d2e0", size = 39350, upload-time = "2025-07-29T07:42:29.794Z" },
 ]
 
+[[package]]
+name = "mne"
+version = "1.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "decorator" },
+    { name = "jinja2" },
+    { name = "lazy-loader" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pooch" },
+    { name = "scipy" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/4f/ed4c27b6179665235a7ce3a738b24a05cafe9fa67f728994361598b27c2f/mne-1.11.0.tar.gz", hash = "sha256:0a89b8fc44133b81218a35cdcba74ad0f8ae2e265136249b365b9ce04864c688", size = 7152794, upload-time = "2025-11-21T19:34:45.907Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/60/a9b51009f6df38b491a874b3ca5db1ce37395c6327faca1008e71e9814e6/mne-1.11.0-py3-none-any.whl", hash = "sha256:993f25b0c92e563c23cb272c42c6c0298be10f40ed50abe4dd2deeba8d184ac2", size = 7451119, upload-time = "2025-11-21T19:34:43.463Z" },
+]
+
 [[package]]
 name = "monarch-py"
 version = "1.23.1"
@@ -2755,6 +2791,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/be/3b/6b13ac39ed9e714c75214ae9d6bb70f272ea65c36e37b8a396ebff20e2da/monarch_py-1.23.1-py3-none-any.whl", hash = "sha256:9cba9cad1c88745fba19b699a5e81aee653802568997c700e7d1707b863aecd1", size = 71086, upload-time = "2025-12-10T04:04:01.81Z" },
 ]
 
+[[package]]
+name = "mongomock"
+version = "4.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "pytz" },
+    { name = "sentinels" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/a4/4a560a9f2a0bec43d5f63104f55bc48666d619ca74825c8ae156b08547cf/mongomock-4.3.0.tar.gz", hash = "sha256:32667b79066fabc12d4f17f16a8fd7361b5f4435208b3ba32c226e52212a8c30", size = 135862, upload-time = "2024-11-16T11:23:25.957Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/4d/8bea712978e3aff017a2ab50f262c620e9239cc36f348aae45e48d6a4786/mongomock-4.3.0-py2.py3-none-any.whl", hash = "sha256:5ef86bd12fc8806c6e7af32f21266c61b6c4ba96096f85129852d1c4fec1327e", size = 64891, upload-time = "2024-11-16T11:23:24.748Z" },
+]
+
 [[package]]
 name = "more-click"
 version = "0.1.3"
@@ -3650,6 +3700,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
+[[package]]
+name = "pooch"
+version = "1.8.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "platformdirs" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/77/b3d3e00c696c16cf99af81ef7b1f5fe73bd2a307abca41bd7605429fe6e5/pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10", size = 59353, upload-time = "2024-06-06T16:53:46.224Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/87/77cc11c7a9ea9fd05503def69e3d18605852cd0d4b0d3b8f15bbeb3ef1d1/pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47", size = 64574, upload-time = "2024-06-06T16:53:44.343Z" },
+]
+
 [[package]]
 name = "posthog"
 version = "5.4.0"
@@ -4790,6 +4854,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072, upload-time = "2024-04-07T00:01:07.438Z" },
 ]
 
+[[package]]
+name = "sentinels"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/9b/07195878aa25fe6ed209ec74bc55ae3e3d263b60a489c6e73fdca3c8fe05/sentinels-1.1.1.tar.gz", hash = "sha256:3c2f64f754187c19e0a1a029b148b74cf58dd12ec27b4e19c0e5d6e22b5a9a86", size = 4393, upload-time = "2025-08-12T07:57:50.26Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/65/dea992c6a97074f6d8ff9eab34741298cac2ce23e2b6c74fb7d08afdf85c/sentinels-1.1.1-py3-none-any.whl", hash = "sha256:835d3b28f3b47f5284afa4bf2db6e00f2dc5f80f9923d4b7e7aeeeccf6146a11", size = 3744, upload-time = "2025-08-12T07:57:48.858Z" },
+]
+
 [[package]]
 name = "setuptools"
 version = "80.9.0"

From 389465310ff0c0091a45f177023b1f4d16391a8a Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 16 Dec 2025 08:01:40 -0800
Subject: [PATCH 19/87] initial add

---
 .../LifeSnaps_example.ipynb                   | 219 ++++++++++++++++++
 1 file changed, 219 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/LifeSnaps_example.ipynb

diff --git a/src/BetterCodeBetterScience/LifeSnaps_example.ipynb b/src/BetterCodeBetterScience/LifeSnaps_example.ipynb
new file mode 100644
index 0000000..bdab0ca
--- /dev/null
+++ b/src/BetterCodeBetterScience/LifeSnaps_example.ipynb
@@ -0,0 +1,219 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "5397a69c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pymongo\n",
+    "from pathlib import Path\n",
+    "import os\n",
+    "\n",
+    "\n",
+    "db_import_dir = Path('/Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9318b6f9",
+   "metadata": {},
+   "source": [
+    "## Step 1: load mongobd data from bson\n",
+    "\n",
+    "There are three data files:\n",
+    "\n",
+    "- fitbit.bson\n",
+    "- sema.bson\n",
+    "- surveys.bson\n",
+    "\n",
+    "we load these into the local mongodb using mongorestore.\n",
+    "\n",
+    "the id/user_id entry in the mongo records refers to the subject id\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c55e4bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collection 'fitbit' already loaded with 71284346 documents.\n",
+      "Collection 'sema' already loaded with 15380 documents.\n",
+      "Collection 'surveys' already loaded with 935 documents.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Connect to MongoDB\n",
+    "def get_mongo_client(host='localhost', port=27017):\n",
+    "    try:\n",
+    "        client = pymongo.MongoClient(f\"mongodb://{host}:{port}/\")\n",
+    "    except pymongo.errors.ConnectionError as e:\n",
+    "        raise Exception(f\"Error connecting to MongoDB - have you set it up yet?: {e}\")\n",
+    "    return client\n",
+    "\n",
+    "client = get_mongo_client()\n",
+    "\n",
+    "# load the database and import data if necessary\n",
+    "db = client['lifesnaps']\n",
+    "collection_lengths = {\n",
+    "    'fitbit': 71284346,\n",
+    "    'sema': 15380,\n",
+    "    'surveys': 935\n",
+    "}\n",
+    "\n",
+    "overwrite = False\n",
+    "\n",
+    "for collection_name, expected_length in collection_lengths.items():\n",
+    "    collection = db[collection_name]\n",
+    "    actual_length = collection.count_documents({})\n",
+    "    # use ge since we will removing some objects below\n",
+    "    if actual_length >= expected_length and not overwrite:\n",
+    "        print(f\"Collection '{collection_name}' already loaded with {actual_length} documents.\")\n",
+    "    else:\n",
+    "        # import the data from the BSON file\n",
+    "        print(f\"Collection '{collection_name}' has {actual_length} documents, expected {expected_length}. Importing data...\")\n",
+    "        import_file = db_import_dir / f\"{collection_name}.bson\"\n",
+    "        if not import_file.exists():\n",
+    "            raise FileNotFoundError(f\"Import file {import_file} does not exist.\")\n",
+    "        print(f\"Importing data into collection '{collection_name}' from {import_file}...\")\n",
+    "        command = f\"mongorestore --host {client.address[0]} --port {client.address[1]} --db lifesnaps --collection {collection_name} --drop {import_file}\"\n",
+    "        print(f\"Running command: {command}\")\n",
+    "        os.system(command)\n",
+    "        \n",
+    "        collection = db[collection_name]\n",
+    "        actual_length = collection.count_documents({})\n",
+    "        assert actual_length >= expected_length, f\"After import, collection '{collection_name}' has {actual_length} documents, expected {expected_length}.\"\n",
+    "        print(f\"Successfully imported collection '{collection_name}' with {actual_length} documents.\")\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0729c2ec",
+   "metadata": {},
+   "source": [
+    "### Step 2: remove unnecessary entries from fitbit database\n",
+    "\n",
+    "The fitbit store is huge and we don't need many of the entries, so let's remove them.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56ad6fcb",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a2dd2b2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Removed 9844973 unwanted documents from 'fitbit' collection.\n"
+     ]
+    }
+   ],
+   "source": [
+    "fitbit_types_to_keep = [\n",
+    "    \"Profile\",\n",
+    "    \"heart_rate\",\n",
+    "    \"sleep\",\n",
+    "    \"steps\",\n",
+    "    \"lightly_active_minutes\",\n",
+    "    \"moderately_active_minutes\",\n",
+    "    \"very_active_minutes\",\n",
+    "    \"sedentary_minutes\",\n",
+    "    \"calories\",\n",
+    "]\n",
+    "\n",
+    "# remove unwanted fitbit data\n",
+    "fitbit_collection = db['fitbit']\n",
+    "deletion_result = fitbit_collection.delete_many({\"type\": {\"$nin\": fitbit_types_to_keep}})\n",
+    "print(f\"Removed {deletion_result.deleted_count} unwanted documents from 'fitbit' collection.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "3752b2db",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'Profile': 69,\n",
+       " 'calories': 9675782,\n",
+       " 'heart_rate': 48720040,\n",
+       " 'lightly_active_minutes': 7203,\n",
+       " 'moderately_active_minutes': 7203,\n",
+       " 'sedentary_minutes': 7203,\n",
+       " 'sleep': 4141,\n",
+       " 'steps': 3010529,\n",
+       " 'very_active_minutes': 7203}"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def get_collection_type_counts(db, collection_name, sample_size=3):\n",
+    "    # Get distinct types in a collection and sample documents for each type\n",
+    "    collection = db[collection_name]\n",
+    "    distinct_types = collection.distinct(\"type\")\n",
+    "    type_counts = {}\n",
+    "    for dtype in distinct_types:\n",
+    "        count = collection.count_documents({\"type\": dtype})\n",
+    "        sample_docs = list(collection.find({\"type\": dtype}).limit(sample_size))\n",
+    "        type_counts[dtype] = count\n",
+    "        \n",
+    "    return type_counts\n",
+    "\n",
+    "get_collection_type_counts(db, 'fitbit')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11b8f064",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "BetterCodeBetterScience",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 98e22acdf92aac1443bd1367c8a542e65a69d7af Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 16 Dec 2025 15:36:27 -0800
Subject: [PATCH 20/87] remove 'one of us'

---
 book/software_engineering.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/book/software_engineering.md b/book/software_engineering.md
index 90a9bd8..b6b1575 100644
--- a/book/software_engineering.md
+++ b/book/software_engineering.md
@@ -69,7 +69,7 @@ User stories are also useful for thinking through the potential impact of new fe
 Perhaps the most common example of violations of YAGNI comes about in the development of visualization tools.
 In this example, the developer might decide to create an visualizer to show how the original dataset is being converted into the new format, with interactive features that would allow the user to view features of individual files.
 The question that you should always ask yourself is: What user stories would this feature address? If it's difficult to come up with stories that make clear how the feature would help solve particular problems for users, then the feature is probably not needed. "If you build it, they will come" might work in baseball, but it rarely works in scientific software.
-This is the reason that one of us (RP) regularly tells his trainees to post a note in their workspace with one simple mantra: "MVP".
+This is the reason that I regularly tells my trainees to post a note in their workspace with one simple mantra: "MVP".
 
 
 ## Refactoring code
@@ -954,7 +954,7 @@ def get_subject_label(file):
         return None
 ```
 
-When one of us asked the question "Should there ever be a file path that doesn't include a subject label?", the answer was "No", meaning that this code allows what amounts to an error to occur without announcing its presence.
+When I asked the question "Should there ever be a file path that doesn't include a subject label?", the answer was "No", meaning that this code allows what amounts to an error to occur without announcing its presence.
 When we looked at the place where this function was used in the code, there was no check for whether the output was `None`, meaning that such an error would go unnoticed until it caused an error later when `subject_label` was assumed to be a string.
 Also note that the docstring for this function is misleading, as it states that a message will be printed if the return value is `None`, but no message is actually printed.
 In general, printing a message is a poor way to signal the potential presence of a problem, particularly if the code has a large amount of text output in which the message might be lost.

From 0abbf6d02b23e57368a1e0f4a795f5b90f39f418 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 17 Dec 2025 08:39:11 -0800
Subject: [PATCH 21/87] add link check

---
 Makefile       |   3 +
 pyproject.toml |   5 ++
 uv.lock        | 173 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 181 insertions(+)

diff --git a/Makefile b/Makefile
index 35add9a..cadd7fe 100644
--- a/Makefile
+++ b/Makefile
@@ -8,6 +8,9 @@ build-html: clean
 build-pdf:
 	jupyter-book build book/ --builder pdflatex
 
+check-links:
+	check-links	
+
 pipinstall:
 	uv pip install -r pyproject.toml
 	uv pip install -e .
diff --git a/pyproject.toml b/pyproject.toml
index 4e1d5b6..62b01fc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -64,12 +64,17 @@ dependencies = [
     "mystmd>=1.7.0",
     "mne>=1.11.0",
     "mongomock>=4.3.0",
+    "linkcheckmd>=1.4.0",
 ]
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+# add script entry points here
+[project.scripts]
+check-links = "BetterCodeBetterScience.check_links:main"
+
 [tool.codespell]
 # Ref: https://github.com/codespell-project/codespell#using-a-config-file
 skip = './book/transcripts,./book/_build/html,.js*,.git*,*.lock,*.bib,.venv*,*.ipynb,*.json'
diff --git a/uv.lock b/uv.lock
index a31483c..0c89da9 100644
--- a/uv.lock
+++ b/uv.lock
@@ -29,6 +29,62 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/39/e8/806475fe4cdfd8635535d3fa11bd61d19b7cc94b61b9147ebdd2ab4cbbee/acres-0.5.0-py3-none-any.whl", hash = "sha256:fcc32b974b510897de0f041609b4234f9ff03e2e960aea088f63973fb106c772", size = 12703, upload-time = "2025-06-04T12:40:28.745Z" },
 ]
 
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload-time = "2025-10-28T20:59:39.937Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/9b/01f00e9856d0a73260e86dd8ed0c2234a466c5c1712ce1c281548df39777/aiohttp-3.13.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b1e56bab2e12b2b9ed300218c351ee2a3d8c8fdab5b1ec6193e11a817767e47b", size = 737623, upload-time = "2025-10-28T20:56:30.797Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/1b/4be39c445e2b2bd0aab4ba736deb649fabf14f6757f405f0c9685019b9e9/aiohttp-3.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:364e25edaabd3d37b1db1f0cbcee8c73c9a3727bfa262b83e5e4cf3489a2a9dc", size = 492664, upload-time = "2025-10-28T20:56:32.708Z" },
+    { url = "https://files.pythonhosted.org/packages/28/66/d35dcfea8050e131cdd731dff36434390479b4045a8d0b9d7111b0a968f1/aiohttp-3.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c5c94825f744694c4b8db20b71dba9a257cd2ba8e010a803042123f3a25d50d7", size = 491808, upload-time = "2025-10-28T20:56:34.57Z" },
+    { url = "https://files.pythonhosted.org/packages/00/29/8e4609b93e10a853b65f8291e64985de66d4f5848c5637cddc70e98f01f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba2715d842ffa787be87cbfce150d5e88c87a98e0b62e0f5aa489169a393dbbb", size = 1738863, upload-time = "2025-10-28T20:56:36.377Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/fa/4ebdf4adcc0def75ced1a0d2d227577cd7b1b85beb7edad85fcc87693c75/aiohttp-3.13.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:585542825c4bc662221fb257889e011a5aa00f1ae4d75d1d246a5225289183e3", size = 1700586, upload-time = "2025-10-28T20:56:38.034Z" },
+    { url = "https://files.pythonhosted.org/packages/da/04/73f5f02ff348a3558763ff6abe99c223381b0bace05cd4530a0258e52597/aiohttp-3.13.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39d02cb6025fe1aabca329c5632f48c9532a3dabccd859e7e2f110668972331f", size = 1768625, upload-time = "2025-10-28T20:56:39.75Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/49/a825b79ffec124317265ca7d2344a86bcffeb960743487cb11988ffb3494/aiohttp-3.13.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e67446b19e014d37342f7195f592a2a948141d15a312fe0e700c2fd2f03124f6", size = 1867281, upload-time = "2025-10-28T20:56:41.471Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/48/adf56e05f81eac31edcfae45c90928f4ad50ef2e3ea72cb8376162a368f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4356474ad6333e41ccefd39eae869ba15a6c5299c9c01dfdcfdd5c107be4363e", size = 1752431, upload-time = "2025-10-28T20:56:43.162Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ab/593855356eead019a74e862f21523db09c27f12fd24af72dbc3555b9bfd9/aiohttp-3.13.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeacf451c99b4525f700f078becff32c32ec327b10dcf31306a8a52d78166de7", size = 1562846, upload-time = "2025-10-28T20:56:44.85Z" },
+    { url = "https://files.pythonhosted.org/packages/39/0f/9f3d32271aa8dc35036e9668e31870a9d3b9542dd6b3e2c8a30931cb27ae/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8a9b889aeabd7a4e9af0b7f4ab5ad94d42e7ff679aaec6d0db21e3b639ad58d", size = 1699606, upload-time = "2025-10-28T20:56:46.519Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/3c/52d2658c5699b6ef7692a3f7128b2d2d4d9775f2a68093f74bca06cf01e1/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fa89cb11bc71a63b69568d5b8a25c3ca25b6d54c15f907ca1c130d72f320b76b", size = 1720663, upload-time = "2025-10-28T20:56:48.528Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/d4/8f8f3ff1fb7fb9e3f04fcad4e89d8a1cd8fc7d05de67e3de5b15b33008ff/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8aa7c807df234f693fed0ecd507192fc97692e61fee5702cdc11155d2e5cadc8", size = 1737939, upload-time = "2025-10-28T20:56:50.77Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d3/ddd348f8a27a634daae39a1b8e291ff19c77867af438af844bf8b7e3231b/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9eb3e33fdbe43f88c3c75fa608c25e7c47bbd80f48d012763cb67c47f39a7e16", size = 1555132, upload-time = "2025-10-28T20:56:52.568Z" },
+    { url = "https://files.pythonhosted.org/packages/39/b8/46790692dc46218406f94374903ba47552f2f9f90dad554eed61bfb7b64c/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9434bc0d80076138ea986833156c5a48c9c7a8abb0c96039ddbb4afc93184169", size = 1764802, upload-time = "2025-10-28T20:56:54.292Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/e4/19ce547b58ab2a385e5f0b8aa3db38674785085abcf79b6e0edd1632b12f/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff15c147b2ad66da1f2cbb0622313f2242d8e6e8f9b79b5206c84523a4473248", size = 1719512, upload-time = "2025-10-28T20:56:56.428Z" },
+    { url = "https://files.pythonhosted.org/packages/70/30/6355a737fed29dcb6dfdd48682d5790cb5eab050f7b4e01f49b121d3acad/aiohttp-3.13.2-cp312-cp312-win32.whl", hash = "sha256:27e569eb9d9e95dbd55c0fc3ec3a9335defbf1d8bc1d20171a49f3c4c607b93e", size = 426690, upload-time = "2025-10-28T20:56:58.736Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/0d/b10ac09069973d112de6ef980c1f6bb31cb7dcd0bc363acbdad58f927873/aiohttp-3.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:8709a0f05d59a71f33fd05c17fc11fcb8c30140506e13c2f5e8ee1b8964e1b45", size = 453465, upload-time = "2025-10-28T20:57:00.795Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
 [[package]]
 name = "airium"
 version = "0.2.7"
@@ -306,6 +362,7 @@ dependencies = [
     { name = "jupyter" },
     { name = "jupyter-book" },
     { name = "jupytext" },
+    { name = "linkcheckmd" },
     { name = "mariadb" },
     { name = "matplotlib" },
     { name = "mdnewline" },
@@ -369,6 +426,7 @@ requires-dist = [
     { name = "jupyter", specifier = ">=1.1.1" },
     { name = "jupyter-book", specifier = ">=1.0.2" },
     { name = "jupytext", specifier = ">=1.16.4" },
+    { name = "linkcheckmd", specifier = ">=1.4.0" },
     { name = "mariadb", specifier = ">=1.1.14" },
     { name = "matplotlib", specifier = ">=3.9.2" },
     { name = "mdnewline", specifier = ">=0.1.3" },
@@ -1394,6 +1452,31 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/38/74/f94141b38a51a553efef7f510fc213894161ae49b88bffd037f8d2a7cb2f/frozendict-2.4.7-py3-none-any.whl", hash = "sha256:972af65924ea25cf5b4d9326d549e69a9a4918d8a76a9d3a7cd174d98b237550", size = 16264, upload-time = "2025-11-11T22:40:12.836Z" },
 ]
 
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
 [[package]]
 name = "fsspec"
 version = "2025.12.0"
@@ -2453,6 +2536,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097, upload-time = "2024-04-05T13:03:10.514Z" },
 ]
 
+[[package]]
+name = "linkcheckmd"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/59/ea/34da82a2c946699e18275b19a97464046f1193299c42401ae7b088108eed/linkcheckmd-1.4.0.tar.gz", hash = "sha256:3a539c9a4e11697fc7fcc269d379accf93c8cccbf971f3cea0bae40912d9f609", size = 10760, upload-time = "2021-02-28T02:50:22.504Z" }
+
 [[package]]
 name = "linkml"
 version = "1.9.3"
@@ -2852,6 +2944,33 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" },
 ]
 
+[[package]]
+name = "multidict"
+version = "6.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/80/1e/5492c365f222f907de1039b91f922b93fa4f764c713ee858d235495d8f50/multidict-6.7.0.tar.gz", hash = "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5", size = 101834, upload-time = "2025-10-06T14:52:30.657Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/9e/9f61ac18d9c8b475889f32ccfa91c9f59363480613fc807b6e3023d6f60b/multidict-6.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8a3862568a36d26e650a19bb5cbbba14b71789032aebc0423f8cc5f150730184", size = 76877, upload-time = "2025-10-06T14:49:20.884Z" },
+    { url = "https://files.pythonhosted.org/packages/38/6f/614f09a04e6184f8824268fce4bc925e9849edfa654ddd59f0b64508c595/multidict-6.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:960c60b5849b9b4f9dcc9bea6e3626143c252c74113df2c1540aebce70209b45", size = 45467, upload-time = "2025-10-06T14:49:22.054Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/93/c4f67a436dd026f2e780c433277fff72be79152894d9fc36f44569cab1a6/multidict-6.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2049be98fb57a31b4ccf870bf377af2504d4ae35646a19037ec271e4c07998aa", size = 43834, upload-time = "2025-10-06T14:49:23.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/f5/013798161ca665e4a422afbc5e2d9e4070142a9ff8905e482139cd09e4d0/multidict-6.7.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0934f3843a1860dd465d38895c17fce1f1cb37295149ab05cd1b9a03afacb2a7", size = 250545, upload-time = "2025-10-06T14:49:24.882Z" },
+    { url = "https://files.pythonhosted.org/packages/71/2f/91dbac13e0ba94669ea5119ba267c9a832f0cb65419aca75549fcf09a3dc/multidict-6.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3e34f3a1b8131ba06f1a73adab24f30934d148afcd5f5de9a73565a4404384e", size = 258305, upload-time = "2025-10-06T14:49:26.778Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/b0/754038b26f6e04488b48ac621f779c341338d78503fb45403755af2df477/multidict-6.7.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:efbb54e98446892590dc2458c19c10344ee9a883a79b5cec4bc34d6656e8d546", size = 242363, upload-time = "2025-10-06T14:49:28.562Z" },
+    { url = "https://files.pythonhosted.org/packages/87/15/9da40b9336a7c9fa606c4cf2ed80a649dffeb42b905d4f63a1d7eb17d746/multidict-6.7.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a35c5fc61d4f51eb045061e7967cfe3123d622cd500e8868e7c0c592a09fedc4", size = 268375, upload-time = "2025-10-06T14:49:29.96Z" },
+    { url = "https://files.pythonhosted.org/packages/82/72/c53fcade0cc94dfaad583105fd92b3a783af2091eddcb41a6d5a52474000/multidict-6.7.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29fe6740ebccba4175af1b9b87bf553e9c15cd5868ee967e010efcf94e4fd0f1", size = 269346, upload-time = "2025-10-06T14:49:31.404Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/e2/9baffdae21a76f77ef8447f1a05a96ec4bc0a24dae08767abc0a2fe680b8/multidict-6.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:123e2a72e20537add2f33a79e605f6191fba2afda4cbb876e35c1a7074298a7d", size = 256107, upload-time = "2025-10-06T14:49:32.974Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/06/3f06f611087dc60d65ef775f1fb5aca7c6d61c6db4990e7cda0cef9b1651/multidict-6.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b284e319754366c1aee2267a2036248b24eeb17ecd5dc16022095e747f2f4304", size = 253592, upload-time = "2025-10-06T14:49:34.52Z" },
+    { url = "https://files.pythonhosted.org/packages/20/24/54e804ec7945b6023b340c412ce9c3f81e91b3bf5fa5ce65558740141bee/multidict-6.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:803d685de7be4303b5a657b76e2f6d1240e7e0a8aa2968ad5811fa2285553a12", size = 251024, upload-time = "2025-10-06T14:49:35.956Z" },
+    { url = "https://files.pythonhosted.org/packages/14/48/011cba467ea0b17ceb938315d219391d3e421dfd35928e5dbdc3f4ae76ef/multidict-6.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c04a328260dfd5db8c39538f999f02779012268f54614902d0afc775d44e0a62", size = 251484, upload-time = "2025-10-06T14:49:37.631Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/2f/919258b43bb35b99fa127435cfb2d91798eb3a943396631ef43e3720dcf4/multidict-6.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8a19cdb57cd3df4cd865849d93ee14920fb97224300c88501f16ecfa2604b4e0", size = 263579, upload-time = "2025-10-06T14:49:39.502Z" },
+    { url = "https://files.pythonhosted.org/packages/31/22/a0e884d86b5242b5a74cf08e876bdf299e413016b66e55511f7a804a366e/multidict-6.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b2fd74c52accced7e75de26023b7dccee62511a600e62311b918ec5c168fc2a", size = 259654, upload-time = "2025-10-06T14:49:41.32Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e5/17e10e1b5c5f5a40f2fcbb45953c9b215f8a4098003915e46a93f5fcaa8f/multidict-6.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3e8bfdd0e487acf992407a140d2589fe598238eaeffa3da8448d63a63cd363f8", size = 251511, upload-time = "2025-10-06T14:49:46.021Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/9a/201bb1e17e7af53139597069c375e7b0dcbd47594604f65c2d5359508566/multidict-6.7.0-cp312-cp312-win32.whl", hash = "sha256:dd32a49400a2c3d52088e120ee00c1e3576cbff7e10b98467962c74fdb762ed4", size = 41895, upload-time = "2025-10-06T14:49:48.718Z" },
+    { url = "https://files.pythonhosted.org/packages/46/e2/348cd32faad84eaf1d20cce80e2bb0ef8d312c55bca1f7fa9865e7770aaf/multidict-6.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:92abb658ef2d7ef22ac9f8bb88e8b6c3e571671534e029359b6d9e845923eb1b", size = 46073, upload-time = "2025-10-06T14:49:50.28Z" },
+    { url = "https://files.pythonhosted.org/packages/25/ec/aad2613c1910dce907480e0c3aa306905830f25df2e54ccc9dea450cb5aa/multidict-6.7.0-cp312-cp312-win_arm64.whl", hash = "sha256:490dab541a6a642ce1a9d61a4781656b346a55c13038f0b1244653828e3a83ec", size = 43226, upload-time = "2025-10-06T14:49:52.304Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" },
+]
+
 [[package]]
 name = "murmurhash"
 version = "1.0.15"
@@ -3830,6 +3949,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/79/217ae7eb2462ef254aab95b3610d85105a86f4ec8b43863788e32c0d5369/pronto-2.7.2-py3-none-any.whl", hash = "sha256:9c4b037ae1f9598398f38a55306eb1af7c3cdf8be7d535925500b978b32d1450", size = 62212, upload-time = "2025-11-10T12:45:42.969Z" },
 ]
 
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
 [[package]]
 name = "protobuf"
 version = "6.33.2"
@@ -5837,6 +5980,36 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/d1/b51471c11592ff9c012bd3e2f7334a6ff2f42a7aed2caffcf0bdddc9cb89/wrapt-2.0.1-py3-none-any.whl", hash = "sha256:4d2ce1bf1a48c5277d7969259232b57645aae5686dba1eaeade39442277afbca", size = 44046, upload-time = "2025-11-07T00:45:32.116Z" },
 ]
 
+[[package]]
+name = "yarl"
+version = "1.22.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload-time = "2025-10-06T14:09:44.631Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload-time = "2025-10-06T14:09:46.372Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload-time = "2025-10-06T14:09:48.648Z" },
+    { url = "https://files.pythonhosted.org/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload-time = "2025-10-06T14:09:50.089Z" },
+    { url = "https://files.pythonhosted.org/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload-time = "2025-10-06T14:09:52.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload-time = "2025-10-06T14:09:54.128Z" },
+    { url = "https://files.pythonhosted.org/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload-time = "2025-10-06T14:09:55.762Z" },
+    { url = "https://files.pythonhosted.org/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload-time = "2025-10-06T14:09:57.958Z" },
+    { url = "https://files.pythonhosted.org/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload-time = "2025-10-06T14:09:59.527Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload-time = "2025-10-06T14:10:01.139Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload-time = "2025-10-06T14:10:02.756Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload-time = "2025-10-06T14:10:04.552Z" },
+    { url = "https://files.pythonhosted.org/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload-time = "2025-10-06T14:10:06.489Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload-time = "2025-10-06T14:10:09.254Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload-time = "2025-10-06T14:10:11.369Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload-time = "2025-10-06T14:10:13.112Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" },
+]
+
 [[package]]
 name = "zarr"
 version = "3.1.5"

From 693bd6643cefda4bb7f365e14e44aebbb18d5222 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 17 Dec 2025 08:39:30 -0800
Subject: [PATCH 22/87] full data prep:

---
 .../LifeSnaps_example.ipynb                   | 514 ++++++++++++++++--
 1 file changed, 467 insertions(+), 47 deletions(-)

diff --git a/src/BetterCodeBetterScience/LifeSnaps_example.ipynb b/src/BetterCodeBetterScience/LifeSnaps_example.ipynb
index bdab0ca..9d75202 100644
--- a/src/BetterCodeBetterScience/LifeSnaps_example.ipynb
+++ b/src/BetterCodeBetterScience/LifeSnaps_example.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 1,
    "id": "5397a69c",
    "metadata": {},
    "outputs": [],
@@ -36,7 +36,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
+   "id": "342e7980",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_collection_type_counts(db, collection_name, sample_size=3):\n",
+    "    # Get distinct types in a collection and sample documents for each type\n",
+    "    collection = db[collection_name]\n",
+    "    distinct_types = collection.distinct(\"type\")\n",
+    "    type_counts = {}\n",
+    "    for dtype in distinct_types:\n",
+    "        count = collection.count_documents({\"type\": dtype})\n",
+    "        sample_docs = list(collection.find({\"type\": dtype}).limit(sample_size))\n",
+    "        type_counts[dtype] = count\n",
+    "        \n",
+    "    return type_counts\n",
+    "\n",
+    "def get_collection_size(db, collection_name):\n",
+    "    # Get the numner of documents in a collection\n",
+    "\n",
+    "    return db[collection_name].count_documents({})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
    "id": "1c55e4bf",
    "metadata": {},
    "outputs": [
@@ -44,9 +69,100 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Collection 'fitbit' already loaded with 71284346 documents.\n",
-      "Collection 'sema' already loaded with 15380 documents.\n",
-      "Collection 'surveys' already loaded with 935 documents.\n"
+      "Collection 'fitbit' has 0 documents, expected 71284346. Importing data...\n",
+      "Importing data into collection 'fitbit' from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson...\n",
+      "Running command: mongorestore --host localhost --port 27017 --db lifesnaps --collection fitbit --drop /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-12-16T20:53:00.855-0800\tchecking for collection data in /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson\n",
+      "2025-12-16T20:53:00.856-0800\treading metadata for lifesnaps.fitbit from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.metadata.json\n",
+      "2025-12-16T20:53:00.889-0800\trestoring lifesnaps.fitbit from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson\n",
+      "2025-12-16T20:53:03.854-0800\t[........................]  lifesnaps.fitbit  246MB/9.02GB  (2.7%)\n",
+      "2025-12-16T20:53:06.854-0800\t[#.......................]  lifesnaps.fitbit  511MB/9.02GB  (5.5%)\n",
+      "2025-12-16T20:53:09.854-0800\t[#.......................]  lifesnaps.fitbit  758MB/9.02GB  (8.2%)\n",
+      "2025-12-16T20:53:12.854-0800\t[##......................]  lifesnaps.fitbit  968MB/9.02GB  (10.5%)\n",
+      "2025-12-16T20:53:15.854-0800\t[###.....................]  lifesnaps.fitbit  1.19GB/9.02GB  (13.2%)\n",
+      "2025-12-16T20:53:18.854-0800\t[###.....................]  lifesnaps.fitbit  1.45GB/9.02GB  (16.0%)\n",
+      "2025-12-16T20:53:21.854-0800\t[####....................]  lifesnaps.fitbit  1.66GB/9.02GB  (18.4%)\n",
+      "2025-12-16T20:53:24.854-0800\t[#####...................]  lifesnaps.fitbit  1.90GB/9.02GB  (21.0%)\n",
+      "2025-12-16T20:53:27.854-0800\t[#####...................]  lifesnaps.fitbit  2.15GB/9.02GB  (23.8%)\n",
+      "2025-12-16T20:53:30.854-0800\t[######..................]  lifesnaps.fitbit  2.40GB/9.02GB  (26.7%)\n",
+      "2025-12-16T20:53:33.854-0800\t[#######.................]  lifesnaps.fitbit  2.66GB/9.02GB  (29.5%)\n",
+      "2025-12-16T20:53:36.854-0800\t[#######.................]  lifesnaps.fitbit  2.91GB/9.02GB  (32.3%)\n",
+      "2025-12-16T20:53:39.854-0800\t[########................]  lifesnaps.fitbit  3.13GB/9.02GB  (34.7%)\n",
+      "2025-12-16T20:53:42.854-0800\t[#########...............]  lifesnaps.fitbit  3.39GB/9.02GB  (37.6%)\n",
+      "2025-12-16T20:53:45.854-0800\t[#########...............]  lifesnaps.fitbit  3.64GB/9.02GB  (40.4%)\n",
+      "2025-12-16T20:53:48.854-0800\t[##########..............]  lifesnaps.fitbit  3.89GB/9.02GB  (43.1%)\n",
+      "2025-12-16T20:53:51.854-0800\t[##########..............]  lifesnaps.fitbit  4.13GB/9.02GB  (45.8%)\n",
+      "2025-12-16T20:53:54.854-0800\t[###########.............]  lifesnaps.fitbit  4.34GB/9.02GB  (48.1%)\n",
+      "2025-12-16T20:53:57.854-0800\t[############............]  lifesnaps.fitbit  4.59GB/9.02GB  (50.9%)\n",
+      "2025-12-16T20:54:00.854-0800\t[############............]  lifesnaps.fitbit  4.84GB/9.02GB  (53.7%)\n",
+      "2025-12-16T20:54:03.854-0800\t[#############...........]  lifesnaps.fitbit  5.10GB/9.02GB  (56.6%)\n",
+      "2025-12-16T20:54:06.854-0800\t[##############..........]  lifesnaps.fitbit  5.36GB/9.02GB  (59.4%)\n",
+      "2025-12-16T20:54:09.854-0800\t[##############..........]  lifesnaps.fitbit  5.62GB/9.02GB  (62.3%)\n",
+      "2025-12-16T20:54:12.854-0800\t[###############.........]  lifesnaps.fitbit  5.83GB/9.02GB  (64.6%)\n",
+      "2025-12-16T20:54:15.854-0800\t[################........]  lifesnaps.fitbit  6.06GB/9.02GB  (67.2%)\n",
+      "2025-12-16T20:54:18.854-0800\t[################........]  lifesnaps.fitbit  6.31GB/9.02GB  (69.9%)\n",
+      "2025-12-16T20:54:21.854-0800\t[#################.......]  lifesnaps.fitbit  6.57GB/9.02GB  (72.8%)\n",
+      "2025-12-16T20:54:24.854-0800\t[##################......]  lifesnaps.fitbit  6.81GB/9.02GB  (75.5%)\n",
+      "2025-12-16T20:54:27.854-0800\t[##################......]  lifesnaps.fitbit  7.05GB/9.02GB  (78.2%)\n",
+      "2025-12-16T20:54:30.854-0800\t[###################.....]  lifesnaps.fitbit  7.29GB/9.02GB  (80.8%)\n",
+      "2025-12-16T20:54:33.854-0800\t[####################....]  lifesnaps.fitbit  7.55GB/9.02GB  (83.7%)\n",
+      "2025-12-16T20:54:36.854-0800\t[####################....]  lifesnaps.fitbit  7.81GB/9.02GB  (86.6%)\n",
+      "2025-12-16T20:54:39.854-0800\t[#####################...]  lifesnaps.fitbit  8.06GB/9.02GB  (89.4%)\n",
+      "2025-12-16T20:54:42.854-0800\t[######################..]  lifesnaps.fitbit  8.31GB/9.02GB  (92.2%)\n",
+      "2025-12-16T20:54:45.855-0800\t[######################..]  lifesnaps.fitbit  8.54GB/9.02GB  (94.7%)\n",
+      "2025-12-16T20:54:48.855-0800\t[#######################.]  lifesnaps.fitbit  8.78GB/9.02GB  (97.4%)\n",
+      "2025-12-16T20:54:51.722-0800\t[########################]  lifesnaps.fitbit  9.02GB/9.02GB  (100.0%)\n",
+      "2025-12-16T20:54:51.722-0800\tfinished restoring lifesnaps.fitbit (71284346 documents, 0 failures)\n",
+      "2025-12-16T20:54:51.722-0800\trestoring indexes for collection lifesnaps.fitbit from metadata\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"type_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"type\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"id_1_type_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"id\", Value:1}, primitive.E{Key:\"type\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"id_1_type_1_data.dateTime_1_data.value.bpm_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"id\", Value:1}, primitive.E{Key:\"type\", Value:1}, primitive.E{Key:\"data.dateTime\", Value:1}, primitive.E{Key:\"data.value.bpm\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.dateTime_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.dateTime\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.reading_time_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.reading_time\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.sleep_start_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.sleep_start\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.startTime_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.startTime\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"id_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"id\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.timestamp_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.timestamp\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n",
+      "2025-12-16T20:59:25.881-0800\t71284346 document(s) restored successfully. 0 document(s) failed to restore.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Successfully imported collection 'fitbit' with 71284346 documents.\n",
+      "Collection 'sema' has 0 documents, expected 15380. Importing data...\n",
+      "Importing data into collection 'sema' from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson...\n",
+      "Running command: mongorestore --host localhost --port 27017 --db lifesnaps --collection sema --drop /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson\n",
+      "Successfully imported collection 'sema' with 15380 documents.\n",
+      "Collection 'surveys' has 0 documents, expected 935. Importing data...\n",
+      "Importing data into collection 'surveys' from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson...\n",
+      "Running command: mongorestore --host localhost --port 27017 --db lifesnaps --collection surveys --drop /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson\n",
+      "Successfully imported collection 'surveys' with 935 documents.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-12-16T20:59:31.410-0800\tchecking for collection data in /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson\n",
+      "2025-12-16T20:59:31.411-0800\treading metadata for lifesnaps.sema from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.metadata.json\n",
+      "2025-12-16T20:59:31.442-0800\trestoring lifesnaps.sema from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson\n",
+      "2025-12-16T20:59:31.492-0800\tfinished restoring lifesnaps.sema (15380 documents, 0 failures)\n",
+      "2025-12-16T20:59:31.492-0800\tno indexes to restore for collection lifesnaps.sema\n",
+      "2025-12-16T20:59:31.492-0800\t15380 document(s) restored successfully. 0 document(s) failed to restore.\n",
+      "2025-12-16T20:59:31.538-0800\tchecking for collection data in /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson\n",
+      "2025-12-16T20:59:31.538-0800\treading metadata for lifesnaps.surveys from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.metadata.json\n",
+      "2025-12-16T20:59:31.560-0800\trestoring lifesnaps.surveys from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson\n",
+      "2025-12-16T20:59:31.604-0800\tfinished restoring lifesnaps.surveys (935 documents, 0 failures)\n",
+      "2025-12-16T20:59:31.604-0800\tno indexes to restore for collection lifesnaps.surveys\n",
+      "2025-12-16T20:59:31.604-0800\t935 document(s) restored successfully. 0 document(s) failed to restore.\n"
      ]
     }
    ],
@@ -69,11 +185,11 @@
     "    'surveys': 935\n",
     "}\n",
     "\n",
-    "overwrite = False\n",
+    "# in general we will need to overwrite to get the full dataset to begin with\n",
+    "overwrite = True\n",
     "\n",
     "for collection_name, expected_length in collection_lengths.items():\n",
-    "    collection = db[collection_name]\n",
-    "    actual_length = collection.count_documents({})\n",
+    "    actual_length = get_collection_size(db, collection_name)\n",
     "    # use ge since we will removing some objects below\n",
     "    if actual_length >= expected_length and not overwrite:\n",
     "        print(f\"Collection '{collection_name}' already loaded with {actual_length} documents.\")\n",
@@ -88,8 +204,7 @@
     "        print(f\"Running command: {command}\")\n",
     "        os.system(command)\n",
     "        \n",
-    "        collection = db[collection_name]\n",
-    "        actual_length = collection.count_documents({})\n",
+    "        actual_length = get_collection_size(db, collection_name)\n",
     "        assert actual_length >= expected_length, f\"After import, collection '{collection_name}' has {actual_length} documents, expected {expected_length}.\"\n",
     "        print(f\"Successfully imported collection '{collection_name}' with {actual_length} documents.\")\n",
     " "
@@ -110,11 +225,47 @@
    "cell_type": "markdown",
    "id": "56ad6fcb",
    "metadata": {},
-   "source": []
+   "source": [
+    "First pull Profile records into a separate object store since they are a different kind of data"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 4,
+   "id": "e6bfae7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Created 'fitbit_profile' collection with 69 documents.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# create a new table containing all documents from fitbit with type 'Profile'\n",
+    "profile_collection = db['fitbit_profile']\n",
+    "profile_collection.drop()  # drop existing collection if it exists\n",
+    "fitbit_collection = db['fitbit']\n",
+    "profiles = list(fitbit_collection.find({\"type\": \"Profile\"}))\n",
+    "if len(profiles) > 0:\n",
+    "    profile_collection.insert_many(profiles)\n",
+    "    print(f\"Created 'fitbit_profile' collection with {get_collection_size(db, 'fitbit_profile')} documents.\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a653da8c",
+   "metadata": {},
+   "source": [
+    "Remove unwanted fitbit data types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
    "id": "a2dd2b2e",
    "metadata": {},
    "outputs": [
@@ -122,13 +273,22 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Removed 9844973 unwanted documents from 'fitbit' collection.\n"
+      "Removed 9845042 unwanted documents from 'fitbit' collection.\n",
+      "Remaining documents in 'fitbit' collection: 61439304\n",
+      "Final document counts in 'fitbit' collection after cleanup:\n",
+      "Type: calories, Count: 9675782\n",
+      "Type: heart_rate, Count: 48720040\n",
+      "Type: lightly_active_minutes, Count: 7203\n",
+      "Type: moderately_active_minutes, Count: 7203\n",
+      "Type: sedentary_minutes, Count: 7203\n",
+      "Type: sleep, Count: 4141\n",
+      "Type: steps, Count: 3010529\n",
+      "Type: very_active_minutes, Count: 7203\n"
      ]
     }
    ],
    "source": [
     "fitbit_types_to_keep = [\n",
-    "    \"Profile\",\n",
     "    \"heart_rate\",\n",
     "    \"sleep\",\n",
     "    \"steps\",\n",
@@ -142,57 +302,317 @@
     "# remove unwanted fitbit data\n",
     "fitbit_collection = db['fitbit']\n",
     "deletion_result = fitbit_collection.delete_many({\"type\": {\"$nin\": fitbit_types_to_keep}})\n",
-    "print(f\"Removed {deletion_result.deleted_count} unwanted documents from 'fitbit' collection.\")"
+    "print(f\"Removed {deletion_result.deleted_count} unwanted documents from 'fitbit' collection.\")\n",
+    "print(f\"Remaining documents in 'fitbit' collection: {get_collection_size(db, 'fitbit')}\")\n",
+    "print(\"Final document counts in 'fitbit' collection after cleanup:\")\n",
+    "final_type_counts = get_collection_type_counts(db, 'fitbit')\n",
+    "for dtype, count in final_type_counts.items():\n",
+    "    print(f\"Type: {dtype}, Count: {count}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f6d90f7",
+   "metadata": {},
+   "source": [
+    "## Harmonize the documents and combine into a single database\n",
+    "\n",
+    "We want to be able to treat each of the different data types similarly, but currently some of them have their value in a different location than the `value` field."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 6,
    "id": "3752b2db",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "{'Profile': 69,\n",
-       " 'calories': 9675782,\n",
-       " 'heart_rate': 48720040,\n",
-       " 'lightly_active_minutes': 7203,\n",
-       " 'moderately_active_minutes': 7203,\n",
-       " 'sedentary_minutes': 7203,\n",
-       " 'sleep': 4141,\n",
-       " 'steps': 3010529,\n",
-       " 'very_active_minutes': 7203}"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Removed 2 documents with null 'data.SURVEY_NAME' from 'sema' collection.\n",
+      "Remaining documents in 'sema' collection: 15378\n",
+      "Updated 15378 documents in 'sema' collection to add 'type' field.\n",
+      "Document counts in 'sema' collection after adding 'type' field:\n",
+      "Type: Context and Mood Survey, Count: 11526\n",
+      "Type: Step Goal Survey, Count: 3852\n"
+     ]
     }
    ],
    "source": [
-    "def get_collection_type_counts(db, collection_name, sample_size=3):\n",
-    "    # Get distinct types in a collection and sample documents for each type\n",
-    "    collection = db[collection_name]\n",
-    "    distinct_types = collection.distinct(\"type\")\n",
-    "    type_counts = {}\n",
-    "    for dtype in distinct_types:\n",
-    "        count = collection.count_documents({\"type\": dtype})\n",
-    "        sample_docs = list(collection.find({\"type\": dtype}).limit(sample_size))\n",
-    "        type_counts[dtype] = count\n",
-    "        \n",
-    "    return type_counts\n",
+    "# for sema collection, create a 'type' field based on data['SURVEY_NAME']\n",
     "\n",
-    "get_collection_type_counts(db, 'fitbit')\n"
+    "sema_collection = db['sema']\n",
+    "# first remove documents that None for data.SURVEY_NAME\n",
+    "deletion_result = sema_collection.delete_many({\"data.SURVEY_NAME\": None})\n",
+    "print(f\"Removed {deletion_result.deleted_count} documents with null 'data.SURVEY_NAME' from 'sema' collection.\")\n",
+    "print(f\"Remaining documents in 'sema' collection: {get_collection_size(db,'sema')}\")\n",
+    "# now update documents to add 'type'\n",
+    "update_result = sema_collection.update_many(\n",
+    "    {\"type\": {\"$exists\": False}},\n",
+    "    [{\"$set\": {\"type\": \"$data.SURVEY_NAME\"}}]\n",
+    ")\n",
+    "print(f\"Updated {update_result.modified_count} documents in 'sema' collection to add 'type' field.\")\n",
+    "print(f\"Document counts in 'sema' collection after adding 'type' field:\")\n",
+    "sema_type_counts = get_collection_type_counts(db, 'sema')\n",
+    "for dtype, count in sema_type_counts.items():\n",
+    "    print(f\"Type: {dtype}, Count: {count}\") "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "11b8f064",
+   "execution_count": 7,
+   "id": "eb0057c2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Combined 'sema' collection into 'fitbit'. New 'fitbit' collection size: 61450830 documents.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# combine the sema collection into fitbit\n",
+    "\n",
+    "sema_collection = db['sema']\n",
+    "# drop the \"Step Goal Survey\" from sema\n",
+    "sema_collection.delete_many({\"type\": \"Step Goal Survey\"})\n",
+    "\n",
+    "fitbit_collection = db['fitbit']\n",
+    "fitbit_collection.insert_many(sema_collection.find())\n",
+    "print(f\"Combined 'sema' collection into 'fitbit'. New 'fitbit' collection size: {get_collection_size(db, 'fitbit')} documents.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "853eb7e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Updated 48720040 documents of type 'heart_rate' to add 'value' field from 'data.value.bpm'.\n",
+      "Updated 4141 documents of type 'sleep' to add 'date' field from 'data.endTime'.\n",
+      "Updated 4141 documents of type 'sleep' to add 'value' field from 'data.minutesAsleep'.\n",
+      "Updated 7203 documents of type 'lightly_active_minutes' to add 'value' field from 'data.value'.\n",
+      "Updated 7203 documents of type 'moderately_active_minutes' to add 'value' field from 'data.value'.\n",
+      "Updated 7203 documents of type 'very_active_minutes' to add 'value' field from 'data.value'.\n",
+      "Updated 7203 documents of type 'sedentary_minutes' to add 'value' field from 'data.value'.\n",
+      "Updated 9675782 documents of type 'calories' to add 'date' field from 'data.dateTime'.\n",
+      "Updated 9675782 documents of type 'calories' to add 'value' field from 'data.value'.\n",
+      "Updated 3010529 documents of type 'steps' to add 'date' field from 'data.dateTime'.\n",
+      "Updated 3010529 documents of type 'steps' to add 'value' field from 'data.value'.\n",
+      "Updated 11526 documents of type 'Context and Mood Survey' to add 'date' field from 'data.COMPLETED_TS'.\n",
+      "Updated 11526 documents of type 'Context and Mood Survey' to add 'value' field from 'data.MOOD'.\n",
+      "\n",
+      "Verifying updates:\n",
+      "Type 'heart_rate': 48720040/48720040 documents now have 'value' field.\n",
+      "Type 'sleep': 4141/4141 documents now have 'value' field.\n",
+      "Type 'lightly_active_minutes': 7203/7203 documents now have 'value' field.\n",
+      "Type 'moderately_active_minutes': 7203/7203 documents now have 'value' field.\n",
+      "Type 'very_active_minutes': 7203/7203 documents now have 'value' field.\n",
+      "Type 'sedentary_minutes': 7203/7203 documents now have 'value' field.\n",
+      "Type 'calories': 9675782/9675782 documents now have 'value' field.\n",
+      "Type 'steps': 3010529/3010529 documents now have 'value' field.\n",
+      "Type 'Context and Mood Survey': 11526/11526 documents now have 'value' field.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# some already are called \"value\": calories, active/sedentary minutes\n",
+    "value_variable = {\n",
+    "    'heart_rate': 'value.bpm',\n",
+    "    'sleep': 'minutesAsleep',\n",
+    "    'lightly_active_minutes': 'value',\n",
+    "    'moderately_active_minutes': 'value',\n",
+    "    'very_active_minutes': 'value',\n",
+    "    'sedentary_minutes': 'value',\n",
+    "    'calories': 'value',\n",
+    "    'steps': 'value',\n",
+    "    \"Context and Mood Survey\": 'MOOD'\n",
+    "}\n",
+    "date_variable = {\n",
+    "    'sleep': 'endTime',\n",
+    "    'calories': 'dateTime',\n",
+    "    'steps': 'dateTime',\n",
+    "    \"Context and Mood Survey\": 'COMPLETED_TS'\n",
+    "}\n",
+    "# for each object that has type matching one of the keys in value_variable,\n",
+    "# move data[value_variable] into 'value' field at root level of object\n",
+    "\n",
+    "fitbit_collection = db['fitbit']\n",
+    "\n",
+    "for doc_type, value_field in value_variable.items():\n",
+    "    # Update documents of this type to move the value from data[value_field] to root level 'value'\n",
+    "    update_result = fitbit_collection.update_many(\n",
+    "        {\n",
+    "            \"type\": doc_type,\n",
+    "            f\"data.{value_field}\": {\"$exists\": True}\n",
+    "        },\n",
+    "        [\n",
+    "            {\"$set\": {\n",
+    "                \"value\": f\"$data.{value_field}\",\n",
+    "                \"value_origin\": value_field\n",
+    "            }}\n",
+    "        ]\n",
+    "    )\n",
+    "    # fix date field if applicable\n",
+    "    if doc_type in date_variable:\n",
+    "        date_field = date_variable[doc_type]\n",
+    "        date_update_result = fitbit_collection.update_many(\n",
+    "            {\n",
+    "                \"type\": doc_type,\n",
+    "                f\"data.{date_field}\": {\"$exists\": True}\n",
+    "            },\n",
+    "            [\n",
+    "                {\"$set\": {\n",
+    "                    \"date\": f\"$data.{date_field}\",\n",
+    "                    \"date_origin\": date_field\n",
+    "                }}\n",
+    "            ]\n",
+    "        )\n",
+    "        print(f\"Updated {date_update_result.modified_count} documents of type '{doc_type}' to add 'date' field from 'data.{date_field}'.\")\n",
+    "    print(f\"Updated {update_result.modified_count} documents of type '{doc_type}' to add 'value' field from 'data.{value_field}'.\")\n",
+    "\n",
+    "print(\"\\nVerifying updates:\")\n",
+    "for doc_type in value_variable.keys():\n",
+    "    count_with_value = fitbit_collection.count_documents({\n",
+    "        \"type\": doc_type,\n",
+    "        \"value\": {\"$exists\": True}\n",
+    "    })\n",
+    "    total_count = fitbit_collection.count_documents({\"type\": doc_type})\n",
+    "    print(f\"Type '{doc_type}': {count_with_value}/{total_count} documents now have 'value' field.\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b137d0f7",
+   "metadata": {},
+   "source": [
+    "Harmonize by adding type field to sema database"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "335a1d89",
+   "metadata": {},
+   "source": [
+    "rename id to user_id for fitbit collection to harmonize with others"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "89b2a549",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Renamed 'id' field to 'user_id' in 61439304 documents in 'fitbit' collection.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# rename \"id\" field to \"user_id\" in fitbit collection\n",
+    "\n",
+    "# skip if all entities already have \"user_id\"\n",
+    "if fitbit_collection.count_documents({\"user_id\": {\"$exists\": False}}) > 0:\n",
+    "\n",
+    "    rename_result = fitbit_collection.update_many(\n",
+    "        {},\n",
+    "        {\"$rename\": {\"id\": \"user_id\"}}\n",
+    "    )\n",
+    "    print(f\"Renamed 'id' field to 'user_id' in {rename_result.modified_count} documents in 'fitbit' collection.\")\n",
+    "else:\n",
+    "    print(\"Field 'id' already renamed to 'user_id' in 'fitbit' collection; skipping rename.\")   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df746117",
+   "metadata": {},
+   "source": [
+    "Doublecheck that every document has a fields for type, value, user_id, and date."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "523fa955",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Missing field counts in 'fitbit' collection:\n",
+      "Field 'user_id': 0 documents missing this field.\n",
+      "Field 'type': 0 documents missing this field.\n",
+      "Field 'value': 0 documents missing this field.\n",
+      "Field 'date': 48748852 documents missing this field.\n"
+     ]
+    }
+   ],
+   "source": [
+    "field_to_check_for = ['user_id', 'type', 'value', 'date']\n",
+    "# check that all documents in fitbit collection have these fields\n",
+    "missing_field_counts = {}\n",
+    "for field in field_to_check_for:\n",
+    "    count_missing = fitbit_collection.count_documents({field: {\"$exists\": False}})\n",
+    "    missing_field_counts[field] = count_missing\n",
+    "print(\"Missing field counts in 'fitbit' collection:\")\n",
+    "for field, count in missing_field_counts.items():\n",
+    "    print(f\"Field '{field}': {count} documents missing this field.\") "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ce192d95",
+   "metadata": {},
+   "source": [
+    "### Combine all three stores into a single store\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "ce02ac7b",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "# delete intermediate collections if desired\n",
+    "#fitbit_collection.drop()\n",
+    "#sema_collection.drop()\n",
+    "#print(\"Deleted intermediate collections 'fitbit' and 'sema'.\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "5e7e8199",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total size of 'lifesnaps_data' collection: 0.00 GB\n"
+     ]
+    }
+   ],
+   "source": [
+    "# get total size of lifesnaps_data collection in gigabytes\n",
+    "\n",
+    "total_size_gb = get_collection_size(db, 'lifesnaps_data') / 1e7\n",
+    "print(f\"Total size of 'lifesnaps_data' collection: {total_size_gb:.02f} GB\")"
+   ]
   }
  ],
  "metadata": {

From 3beb12d3fdfeb58aaa7b722b9875d63b28ccd6bb Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Fri, 19 Dec 2025 12:52:28 -0800
Subject: [PATCH 23/87] add a few topics

---
 book/workflows.md | 53 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/book/workflows.md b/book/workflows.md
index 4d10fdb..79c77ef 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -66,6 +66,56 @@ but sometimes state is required
 - running it multiple time should give same answer as running it once
 - 
 
+- somewhere talk about in-place operations and their challenges
+
+- local mutation - never change an object that is passed in as an argument
+    - always copy
+    - if the package uses copy-on-write then this is cheap (only copied metadata)
+    - this is not default in pandas 1.x but coming in 2.x
+        - google says it's possible using pd.options.mode.copy_on_write = True - need to confirm
+    - need to check for other frameworks
+
+- lazy frames (polars)
+
+- any function that must mutate in place should do so clearly
+    - e.g. normalize_(x) (apparently pytorch style for mutating functions?)
+    - or using "inplace" in the function name
+
+
+- can encode state in type (e.g. a lightweight class that tracks state ,e.g. "NormalizedArray")
+- or track stage explicitly (e.g. Dataset(stage='normalized', data=array))
+
+- use zarr to save each pipeline step as a new group:
+
+dataset.zarr/
+├── raw/
+│   └── signal
+├── zscored/
+│   └── signal
+├── filtered/
+│   └── signal
+
+- can also store parameters as attrs in zarr
+- e.g. z.attrs.update({
+    "stage": "zscore",
+    "mean_method": "time",
+    "std_ddof": 1,
+})
+
+
+also look at arrow for columnar data - look into arrow immutability
+
+
+## Deferred execution
+
+- dask, xarray
+
+## Checkpointing
+
+- pipeline state should be files on disk, not in memory
+- functions don't pass large objects in memory, they simply pass file names
+- for modern formats like parquet (others?) reading is very fast so the penalty is minimal
+
 ## Precomputing expensive/common operations
 
 
@@ -104,6 +154,9 @@ https://workflowhub.eu/
 ## Logging
 
 
+## Report generation
+
+
  
 ## Simple workflow management with Makefiles
 

From bc8554900e97783b6c7d2c31390b9279d5509a36 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Fri, 19 Dec 2025 12:52:51 -0800
Subject: [PATCH 24/87] add deps for scrna-seq example:

---
 pyproject.toml | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index 62b01fc..49d70ca 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -65,6 +65,17 @@ dependencies = [
     "mne>=1.11.0",
     "mongomock>=4.3.0",
     "linkcheckmd>=1.4.0",
+    "anndata>=0.12.7",
+    "xarray>=2025.12.0",
+    "dask>=2025.12.0",
+    "pyarrow>=22.0.0",
+    "scanpy>=1.11.5",
+    "scrublet>=0.2.3",
+    "igraph>=1.0.0",
+    "leidenalg>=0.11.0",
+    "fastcluster>=1.3.0",
+    "scikit-misc>=0.5.2",
+    "harmony-pytorch>=0.1.8",
 ]
 
 [build-system]

From c0434ca6b41ce51fa624bc2da1ad5ea25af3fe74 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Fri, 19 Dec 2025 12:53:07 -0800
Subject: [PATCH 25/87] add deps for scrna-seq example:

---
 uv.lock | 599 ++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 512 insertions(+), 87 deletions(-)

diff --git a/uv.lock b/uv.lock
index 0c89da9..51b298c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -103,6 +103,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/34/d4e1c02d3bee589efb5dfa17f88ea08bdb3e3eac12bc475462aec52ed223/alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92", size = 13511, upload-time = "2024-01-10T00:56:08.388Z" },
 ]
 
+[[package]]
+name = "anndata"
+version = "0.12.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "array-api-compat" },
+    { name = "h5py" },
+    { name = "legacy-api-wrap" },
+    { name = "natsort" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "scipy" },
+    { name = "zarr" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d8/64/ea6da6d88c0b5ad3231828a8ab895cec871ff965e626e4986bc4dfae053d/anndata-0.12.7.tar.gz", hash = "sha256:10612d476e78570be2fdd391b09cb64d3b33cda32b1b46a0a4b999ba98d64d47", size = 2248853, upload-time = "2025-12-16T13:47:14.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/bc/dee9a01c1b9cd16d7e257644a2fc8ee6df6c685faaf68d289bdc4c91adec/anndata-0.12.7-py3-none-any.whl", hash = "sha256:bd7c18bdc2ed24b9089fd1494b52b787566dea175dde4689d4144693d0949581", size = 174195, upload-time = "2025-12-16T13:47:12.637Z" },
+]
+
 [[package]]
 name = "annexremote"
 version = "1.6.6"
@@ -130,6 +150,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
 ]
 
+[[package]]
+name = "annoy"
+version = "1.17.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/07/38/e321b0e05d8cc068a594279fb7c097efb1df66231c295d482d7ad51b6473/annoy-1.17.3.tar.gz", hash = "sha256:9cbfebefe0a5f843eba29c6be4c84d601f4f41ad4ded0486f1b88c3b07739c15", size = 647460, upload-time = "2023-06-14T16:37:34.152Z" }
+
 [[package]]
 name = "anthropic"
 version = "0.75.0"
@@ -219,6 +245,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" },
 ]
 
+[[package]]
+name = "array-api-compat"
+version = "1.12.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8d/bd/9fa5c7c5621698d5632cc852a79fbbdc28024462c9396698e5fdcb395f37/array_api_compat-1.12.0.tar.gz", hash = "sha256:585bc615f650de53ac24b7c012baecfcdd810f50df3573be47e6dd9fa20df974", size = 99883, upload-time = "2025-05-16T08:49:59.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/b1/0542e0cab6f49f151a2d7a42400f84f706fc0b64e85dc1f56708b2e9fd37/array_api_compat-1.12.0-py3-none-any.whl", hash = "sha256:a0b4795b6944a9507fde54679f9350e2ad2b1e2acf4a2408a098cdc27f890a8b", size = 58156, upload-time = "2025-05-16T08:49:58.129Z" },
+]
+
 [[package]]
 name = "arrow"
 version = "1.4.0"
@@ -343,25 +378,31 @@ version = "0.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "accelerate" },
+    { name = "anndata" },
     { name = "anthropic" },
     { name = "biopython" },
     { name = "biothings-client" },
     { name = "blue" },
     { name = "chromadb" },
     { name = "codespell" },
+    { name = "dask" },
     { name = "datalad" },
     { name = "datalad-osf" },
     { name = "docutils" },
+    { name = "fastcluster" },
     { name = "fastembed" },
     { name = "fastparquet" },
     { name = "fmriprep-docker" },
     { name = "gprofiler-official" },
     { name = "h5py" },
+    { name = "harmony-pytorch" },
     { name = "hypothesis" },
     { name = "icecream" },
+    { name = "igraph" },
     { name = "jupyter" },
     { name = "jupyter-book" },
     { name = "jupytext" },
+    { name = "leidenalg" },
     { name = "linkcheckmd" },
     { name = "mariadb" },
     { name = "matplotlib" },
@@ -382,6 +423,7 @@ dependencies = [
     { name = "pandas" },
     { name = "pickleshare" },
     { name = "pre-commit" },
+    { name = "pyarrow" },
     { name = "pygithub" },
     { name = "pymongo" },
     { name = "pyppeteer" },
@@ -392,8 +434,11 @@ dependencies = [
     { name = "pyyaml" },
     { name = "rpy2" },
     { name = "ruff" },
+    { name = "scanpy" },
     { name = "scikit-learn" },
+    { name = "scikit-misc" },
     { name = "scipy" },
+    { name = "scrublet" },
     { name = "seaborn" },
     { name = "statsmodels" },
     { name = "templateflow" },
@@ -401,31 +446,38 @@ dependencies = [
     { name = "torch" },
     { name = "tqdm" },
     { name = "transformers" },
+    { name = "xarray" },
     { name = "zarr" },
 ]
 
 [package.metadata]
 requires-dist = [
     { name = "accelerate", specifier = ">=1.4.0" },
+    { name = "anndata", specifier = ">=0.12.7" },
     { name = "anthropic", specifier = ">=0.61.0" },
     { name = "biopython", specifier = ">=1.86" },
     { name = "biothings-client", specifier = ">=0.4.1" },
     { name = "blue", specifier = ">=0.9.1" },
     { name = "chromadb", specifier = ">=1.3.5" },
     { name = "codespell", specifier = ">=2.4.1" },
+    { name = "dask", specifier = ">=2025.12.0" },
     { name = "datalad", specifier = ">=1.2.3" },
     { name = "datalad-osf", specifier = ">=0.3.0" },
     { name = "docutils", specifier = "==0.17.1" },
+    { name = "fastcluster", specifier = ">=1.3.0" },
     { name = "fastembed", specifier = ">=0.7.3" },
     { name = "fastparquet", specifier = ">=2024.11.0" },
     { name = "fmriprep-docker", specifier = ">=25.2.3" },
     { name = "gprofiler-official", specifier = ">=1.0.0" },
     { name = "h5py", specifier = ">=3.15.1" },
+    { name = "harmony-pytorch", specifier = ">=0.1.8" },
     { name = "hypothesis", specifier = ">=6.115.3" },
     { name = "icecream", specifier = ">=2.1.4" },
+    { name = "igraph", specifier = ">=1.0.0" },
     { name = "jupyter", specifier = ">=1.1.1" },
     { name = "jupyter-book", specifier = ">=1.0.2" },
     { name = "jupytext", specifier = ">=1.16.4" },
+    { name = "leidenalg", specifier = ">=0.11.0" },
     { name = "linkcheckmd", specifier = ">=1.4.0" },
     { name = "mariadb", specifier = ">=1.1.14" },
     { name = "matplotlib", specifier = ">=3.9.2" },
@@ -446,6 +498,7 @@ requires-dist = [
     { name = "pandas", specifier = ">=2.2.3" },
     { name = "pickleshare", specifier = ">=0.7.5" },
     { name = "pre-commit", specifier = ">=4.2.0" },
+    { name = "pyarrow", specifier = ">=22.0.0" },
     { name = "pygithub", specifier = ">=2.4.0" },
     { name = "pymongo", extras = ["srv"], specifier = ">=4.15.4" },
     { name = "pyppeteer", specifier = ">=2.0.0" },
@@ -456,8 +509,11 @@ requires-dist = [
     { name = "pyyaml", specifier = ">=6.0.2" },
     { name = "rpy2", specifier = ">=3.6.4" },
     { name = "ruff", specifier = ">=0.6.9" },
+    { name = "scanpy", specifier = ">=1.11.5" },
     { name = "scikit-learn", specifier = ">=1.5.2" },
+    { name = "scikit-misc", specifier = ">=0.5.2" },
     { name = "scipy", specifier = ">=1.14.1" },
+    { name = "scrublet", specifier = ">=0.2.3" },
     { name = "seaborn", specifier = ">=0.13.2" },
     { name = "statsmodels", specifier = ">=0.14.5" },
     { name = "templateflow", specifier = ">=25.1.1" },
@@ -465,6 +521,7 @@ requires-dist = [
     { name = "torch", specifier = ">=2.6.0" },
     { name = "tqdm", specifier = ">=4.66.5" },
     { name = "transformers", specifier = ">=4.49.0" },
+    { name = "xarray", specifier = ">=2025.12.0" },
     { name = "zarr", specifier = ">=3.1.3" },
 ]
 
@@ -609,30 +666,30 @@ wheels = [
 
 [[package]]
 name = "boto3"
-version = "1.42.8"
+version = "1.42.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore" },
     { name = "jmespath" },
     { name = "s3transfer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9d/34/64e34fb40903d358a4a3d697e2ee4784a7b52c11e7effbad01967b2d3fc3/boto3-1.42.8.tar.gz", hash = "sha256:e967706af5887339407481562c389c612d5eae641eb854ddd59026d049df740e", size = 112886, upload-time = "2025-12-11T21:54:15.614Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/66/ffe9623d64e97800ff6bac26953cd9ef99410fb864a0b26a0ea2e09b97f0/boto3-1.42.12.tar.gz", hash = "sha256:649b134d25b278c24fcc8b3f94519de3884283b7848dc32f42b0ffdd9d19ce99", size = 112868, upload-time = "2025-12-17T20:30:42.394Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/96/37/9702c0b8e63aaeb1ad430ece22567b03e58ea41e446d68b92e2cb00e7817/boto3-1.42.8-py3-none-any.whl", hash = "sha256:747acc83488fc80b0e7d1c4ff0c533039ff3ede21bdbd4e89544e25b010b070c", size = 140559, upload-time = "2025-12-11T21:54:14.513Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/8b/20a90c75499e3c3a8e3eb5607d930c723577ef8c64968b9be6b743f18158/boto3-1.42.12-py3-none-any.whl", hash = "sha256:8112e1beb5978bb455ea4b41a9ef26fc408f6340d8ff69ef93dded4f80fd53e9", size = 140573, upload-time = "2025-12-17T20:30:40.063Z" },
 ]
 
 [[package]]
 name = "botocore"
-version = "1.42.8"
+version = "1.42.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jmespath" },
     { name = "python-dateutil" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3a/ea/4be7a4a640d599b5691c7cf27e125155d7d3643ecbe37e32941f412e3de5/botocore-1.42.8.tar.gz", hash = "sha256:4921aa454f82fed0880214eab21126c98a35fe31ede952693356f9c85ce3574b", size = 14861038, upload-time = "2025-12-11T21:54:04.031Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a0/b6/9b7988a8476712cdbfeeb68c733933005465c85ebf0ee469a6ea5ca3415c/botocore-1.42.12.tar.gz", hash = "sha256:1f9f63c3d6bb1f768519da30d6018706443c5d8af5472274d183a4945f3d81f8", size = 14879004, upload-time = "2025-12-17T20:30:29.542Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1c/24/a4301564a979368d6f3644f47acc921450b5524b8846e827237d98b04746/botocore-1.42.8-py3-none-any.whl", hash = "sha256:4cb89c74dd9083d16e45868749b999265a91309b2499907c84adeffa0a8df89b", size = 14534173, upload-time = "2025-12-11T21:54:01.143Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/73/22764d0a17130b7d95b2a4104607e6db5487a0e5afb68f5691260ae9c3dc/botocore-1.42.12-py3-none-any.whl", hash = "sha256:4f163880350f6d831857ce5d023875b7c6534be862e5affd9fcf82b8d1ab3537", size = 14552878, upload-time = "2025-12-17T20:30:24.671Z" },
 ]
 
 [[package]]
@@ -651,11 +708,11 @@ wheels = [
 
 [[package]]
 name = "cachetools"
-version = "6.2.2"
+version = "6.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fb/44/ca1675be2a83aeee1886ab745b28cda92093066590233cc501890eb8417a/cachetools-6.2.2.tar.gz", hash = "sha256:8e6d266b25e539df852251cfd6f990b4bc3a141db73b939058d809ebd2590fc6", size = 31571, upload-time = "2025-11-13T17:42:51.465Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bc/1d/ede8680603f6016887c062a2cf4fc8fdba905866a3ab8831aa8aa651320c/cachetools-6.2.4.tar.gz", hash = "sha256:82c5c05585e70b6ba2d3ae09ea60b79548872185d2f24ae1f2709d37299fd607", size = 31731, upload-time = "2025-12-15T18:24:53.744Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/46/eb6eca305c77a4489affe1c5d8f4cae82f285d9addd8de4ec084a7184221/cachetools-6.2.2-py3-none-any.whl", hash = "sha256:6c09c98183bf58560c97b2abfcedcbaf6a896a490f534b031b661d3723b45ace", size = 11503, upload-time = "2025-11-13T17:42:50.232Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/fc/1d7b80d0eb7b714984ce40efc78859c022cd930e402f599d8ca9e39c78a4/cachetools-6.2.4-py3-none-any.whl", hash = "sha256:69a7a52634fed8b8bf6e24a050fb60bff1c9bd8f6d24572b99c32d4e71e62a51", size = 11551, upload-time = "2025-12-15T18:24:52.332Z" },
 ]
 
 [[package]]
@@ -766,7 +823,7 @@ wheels = [
 
 [[package]]
 name = "chromadb"
-version = "1.3.6"
+version = "1.3.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "bcrypt" },
@@ -797,13 +854,13 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uvicorn", extra = ["standard"] },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c0/5c/c8d751b327f863c11cc51e4cd01750696bacdc65b291beda8b008917910e/chromadb-1.3.6.tar.gz", hash = "sha256:834d7d154471b36bed10ddb53fcc96dfa912d18f0d57418490d829f7aad59895", size = 1959127, upload-time = "2025-12-10T05:25:22.644Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/b9/23eb242c0bad56bcac57d9f45a6cc85e016a44ae9baf763c0d040e45e2d7/chromadb-1.3.7.tar.gz", hash = "sha256:393b866b6ac60c12fc0f2a43d07b2884f2d02a68a1b2cb43c5ef87d141543571", size = 1960950, upload-time = "2025-12-12T21:03:13.941Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/6d/2a09221575a4fd7b6356c1416160d491fccd38ab6b24eee7df030552a7ac/chromadb-1.3.6-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d80b9621af6dfdd23a4aced8e33f667ab41e8252c2a1c4f46eb27acbbb67fe48", size = 20782782, upload-time = "2025-12-10T05:25:20.205Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/8e/528f64a8ec1e32b9d079c77572e0e8301e1fb461474fefca6bce7ce90f8e/chromadb-1.3.6-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1dee1987755d1dc920d9608f76eedb0f70ae06ade020d462f3265b290ca05b65", size = 20078289, upload-time = "2025-12-10T05:25:17.621Z" },
-    { url = "https://files.pythonhosted.org/packages/33/1c/07bb66f9d8f243ae232fa9f73bcb63ae1386dc327cfa085feca7365c34ad/chromadb-1.3.6-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1a59a2ef5121b0321ce1ffcdf84dfa1f11fba7c6734fe6b3b22a22c9c531314", size = 20703285, upload-time = "2025-12-10T05:25:11.594Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/5d/210639c32d3f6f49b265c84990be5da1bb6e1b2fd31f9845abec4580e3ba/chromadb-1.3.6-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2f98ee1e180c11aaf33f0aed11a54f385def8361931fcab8c876e56e94f02699", size = 21633675, upload-time = "2025-12-10T05:25:14.759Z" },
-    { url = "https://files.pythonhosted.org/packages/59/91/bf5dfa3bd5b457a9195439e077128c274202b1a231bd3a9d4d7f3c2259a3/chromadb-1.3.6-cp39-abi3-win_amd64.whl", hash = "sha256:cde42db6c3b31b7edf75bbf60447cd83e9693fe08d2005496ae418c05cae9b3f", size = 21870402, upload-time = "2025-12-10T05:25:24.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/9d/306e220cfb4382e9f29e645339826d1deec64c34cf905c344d0d7345dbdb/chromadb-1.3.7-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:74839c349a740b8e349fabc569f8f4becae9806fa8ff9ca186797bef1f54ee4c", size = 20816599, upload-time = "2025-12-12T21:03:11.173Z" },
+    { url = "https://files.pythonhosted.org/packages/51/3e/0fbb4c6e7971019c976cf3dbef1c22c1a3089f74ef86c88e2e066edc47e4/chromadb-1.3.7-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:fe9c96f73450274d9f722572afc9d455b4f6f4cd960fa49e4bf489075ef30e6f", size = 20113076, upload-time = "2025-12-12T21:03:07.873Z" },
+    { url = "https://files.pythonhosted.org/packages/69/78/2ae4064c9b194271b9c2bc66a26a7e11363d13ed2bd691a563fac1a7c5f2/chromadb-1.3.7-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:972cb168033db76a4bb1031bc38b6cc4e6d05ef716c1ffce8ae95a1a3b515dd2", size = 20738619, upload-time = "2025-12-12T21:03:01.409Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/3aa34cb02c3c0e4920a47da5d9092cab690fcbf6df13ec744eacf96891d6/chromadb-1.3.7-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e05190236e309b54165866dd11676c2702a35b73beaa29502741f22f333c51a", size = 21654395, upload-time = "2025-12-12T21:03:04.909Z" },
+    { url = "https://files.pythonhosted.org/packages/00/36/7d2d7b6bb26e53214492d71ccb4e128fa2de4d98a215befb7787deaf2701/chromadb-1.3.7-cp39-abi3-win_amd64.whl", hash = "sha256:4618ba7bb5ef5dbf0d4fd9ce708b912d8cd1ab24d3c81e0e092841f325b2c94d", size = 21874973, upload-time = "2025-12-12T21:03:16.918Z" },
 ]
 
 [[package]]
@@ -839,6 +896,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ae/8a/c4bb04426d608be4a3171efa2e233d2c59a5c8937850c10d098e126df18e/cloudpathlib-0.23.0-py3-none-any.whl", hash = "sha256:8520b3b01468fee77de37ab5d50b1b524ea6b4a8731c35d1b7407ac0cd716002", size = 62755, upload-time = "2025-10-07T22:47:54.905Z" },
 ]
 
+[[package]]
+name = "cloudpickle"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" },
+]
+
 [[package]]
 name = "codespell"
 version = "2.4.1"
@@ -1001,15 +1067,15 @@ wheels = [
 
 [[package]]
 name = "curies"
-version = "0.12.5"
+version = "0.12.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a9/4c/fc5d51c21b99f802948a8b3079565806239c76e7b2f1f6702a603fe282f7/curies-0.12.5.tar.gz", hash = "sha256:57e4853045f8029c2564fbf2290221ff7a529034405076d1e82b7a8727b33dfc", size = 282912, upload-time = "2025-11-25T12:47:24.825Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/48/f2d73a4b266c7407af39a8f6d397bce7260627802d1bdf88ab3745a89408/curies-0.12.6.tar.gz", hash = "sha256:fe16fd217dadc7f85e80137ae303ba6afc35abaeeadb2730b45de01433843248", size = 283201, upload-time = "2025-12-17T11:42:18.316Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8c/dd/29000adb47118edbf865a6e366fba294dcdacdf34322cedb23b8e7d30ae0/curies-0.12.5-py3-none-any.whl", hash = "sha256:e7fbb63cb49aeb389d46db64dae02f1563741084e033c2075cd1e163fdb1ead8", size = 69711, upload-time = "2025-11-25T12:47:23.058Z" },
+    { url = "https://files.pythonhosted.org/packages/de/b5/2a7682e76e011ea56547f7adf0bddd4cc151caab2183355773d069368e55/curies-0.12.6-py3-none-any.whl", hash = "sha256:64568d18d547daeca82f96e24acf7b829ae62c7a7ee875f9d178f7f59871f321", size = 69950, upload-time = "2025-12-17T11:42:16.427Z" },
 ]
 
 [[package]]
@@ -1037,6 +1103,46 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/94/fb/1b681635bfd5f2274d0caa8f934b58435db6c091b97f5593738065ddb786/cymem-2.0.13-cp312-cp312-win_arm64.whl", hash = "sha256:6bbd701338df7bf408648191dff52472a9b334f71bcd31a21a41d83821050f67", size = 35959, upload-time = "2025-11-14T14:57:41.682Z" },
 ]
 
+[[package]]
+name = "cython"
+version = "3.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/39/e1/c0d92b1258722e1bc62a12e630c33f1f842fdab53fd8cd5de2f75c6449a9/cython-3.2.3.tar.gz", hash = "sha256:f13832412d633376ffc08d751cc18ed0d7d00a398a4065e2871db505258748a6", size = 3276650, upload-time = "2025-12-14T07:50:34.691Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b4/14/d16282d17c9eb2f78ca9ccd5801fed22f6c3360f5a55dbcce3c93cc70352/cython-3.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cf210228c15b5c625824d8e31d43b6fea25f9e13c81dac632f2f7d838e0229a5", size = 2968471, upload-time = "2025-12-14T07:51:01.207Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/3c/46304a942dac5a636701c55f5b05ec00ad151e6722cd068fe3d0993349bb/cython-3.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5bf0cebeb4147e172a114437d3fce5a507595d8fdd821be792b1bb25c691514", size = 3223581, upload-time = "2025-12-14T07:51:04.336Z" },
+    { url = "https://files.pythonhosted.org/packages/29/ad/15da606d71f40bcf2c405f84ca3d4195cb252f4eaa2f551fe6b2e630ee7c/cython-3.2.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1f8700ba89c977438744f083890d87187f15709507a5489e0f6d682053b7fa0", size = 3391391, upload-time = "2025-12-14T07:51:05.998Z" },
+    { url = "https://files.pythonhosted.org/packages/51/9e/045b35eb678682edc3e2d57112cf5ac3581a9ef274eb220b638279195678/cython-3.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:25732f3981a93407826297f4423206e5e22c3cfccfc74e37bf444453bbdc076f", size = 2756814, upload-time = "2025-12-14T07:51:07.759Z" },
+    { url = "https://files.pythonhosted.org/packages/43/49/afe1e3df87a770861cf17ba39f4a91f6d22a2571010fc1890b3708360630/cython-3.2.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:74f482da8b605c61b4df6ff716d013f20131949cb2fa59b03e63abd36ef5bac0", size = 2874467, upload-time = "2025-12-14T07:51:31.568Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/da/044f725a083e28fb4de5bd33d13ec13f0753734b6ae52d4bc07434610cc8/cython-3.2.3-cp39-abi3-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0a75a04688875b275a6c875565e672325bae04327dd6ec2fc25aeb5c6cf82fce", size = 3211272, upload-time = "2025-12-14T07:51:33.673Z" },
+    { url = "https://files.pythonhosted.org/packages/95/14/af02ba6e2e03279f2ca2956e3024a44faed4c8496bda8170b663dc3ba6e8/cython-3.2.3-cp39-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b01b36c9eb1b68c25bddbeef7379f7bfc37f7c9afc044e71840ffab761a2dd0", size = 2856058, upload-time = "2025-12-14T07:51:36.015Z" },
+    { url = "https://files.pythonhosted.org/packages/69/16/d254359396c2f099ab154f89b2b35f5b8b0dd21a8102c2c96a7e00291434/cython-3.2.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3829f99d611412288f44ff543e9d2b5c0c83274998b2a6680bbe5cca3539c1fd", size = 2993276, upload-time = "2025-12-14T07:51:37.863Z" },
+    { url = "https://files.pythonhosted.org/packages/51/0e/1a071381923e896f751f8fbff2a01c5dc8860a8b9a90066f6ec8df561dc4/cython-3.2.3-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c2365a0c79ab9c0fa86d30a4a6ba7e37fc1be9537c48b79b9d63ee7e08bf2fef", size = 2890843, upload-time = "2025-12-14T07:51:40.409Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/46/1e93e10766db988e6bb8e5c6f7e2e90b9e62f1ac8dee4c1a6cf1fc170773/cython-3.2.3-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3141734fb15f8b5e9402b9240f8da8336edecae91742b41c85678c31ab68f66d", size = 3225339, upload-time = "2025-12-14T07:51:42.09Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/ae/c284b06ae6a9c95d5883bf8744d10466cf0df64cef041a4c80ccf9fd07bd/cython-3.2.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9a24cc653fad3adbd9cbaa638d80df3aa08a1fe27f62eb35850971c70be680df", size = 3114751, upload-time = "2025-12-14T07:51:44.088Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d6/7795a4775c70256217134195f06b07233cf17b00f8905d5b3d782208af64/cython-3.2.3-cp39-abi3-win32.whl", hash = "sha256:b39dff92db70cbd95528f3b81d70e06bd6d3fc9c1dd91321e4d3b999ece3bceb", size = 2435616, upload-time = "2025-12-14T07:51:46.063Z" },
+    { url = "https://files.pythonhosted.org/packages/18/9e/2a3edcb858ad74e6274448dccf32150c532bc6e423f112a71f65ff3b5680/cython-3.2.3-cp39-abi3-win_arm64.whl", hash = "sha256:18edc858e6a52de47fe03ffa97ea14dadf450e20069de0a8aef531006c4bbd93", size = 2440952, upload-time = "2025-12-14T07:51:47.943Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/41/54fd429ff8147475fc24ca43246f85d78fb4e747c27f227e68f1594648f1/cython-3.2.3-py3-none-any.whl", hash = "sha256:06a1317097f540d3bb6c7b81ed58a0d8b9dbfa97abf39dfd4c22ee87a6c7241e", size = 1255561, upload-time = "2025-12-14T07:50:31.217Z" },
+]
+
+[[package]]
+name = "dask"
+version = "2025.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "cloudpickle" },
+    { name = "fsspec" },
+    { name = "packaging" },
+    { name = "partd" },
+    { name = "pyyaml" },
+    { name = "toolz" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/ae/92fca08ff8fe3e8413842564dd55ee30c9cd9e07629e1bf4d347b005a5bf/dask-2025.12.0.tar.gz", hash = "sha256:8d478f2aabd025e2453cf733ad64559de90cf328c20209e4574e9543707c3e1b", size = 10995316, upload-time = "2025-12-12T14:59:10.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6f/3a/2121294941227c548d4b5f897a8a1b5f4c44a58f5437f239e6b86511d78e/dask-2025.12.0-py3-none-any.whl", hash = "sha256:4213ce9c5d51d6d89337cff69de35d902aa0bf6abdb8a25c942a4d0281f3a598", size = 1481293, upload-time = "2025-12-12T14:58:59.32Z" },
+]
+
 [[package]]
 name = "datalad"
 version = "1.2.3"
@@ -1098,15 +1204,15 @@ wheels = [
 
 [[package]]
 name = "debugpy"
-version = "1.8.18"
+version = "1.8.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/62/1a/7cb5531840d7ba5d9329644109e62adee41f2f0083d9f8a4039f01de58cf/debugpy-1.8.18.tar.gz", hash = "sha256:02551b1b84a91faadd2db9bc4948873f2398190c95b3cc6f97dc706f43e8c433", size = 1644467, upload-time = "2025-12-10T19:48:07.236Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/75/9e12d4d42349b817cd545b89247696c67917aab907012ae5b64bbfea3199/debugpy-1.8.19.tar.gz", hash = "sha256:eea7e5987445ab0b5ed258093722d5ecb8bb72217c5c9b1e21f64efe23ddebdb", size = 1644590, upload-time = "2025-12-15T21:53:28.044Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/83/01/439626e3572a33ac543f25bc1dac1e80bc01c7ce83f3c24dc4441302ca13/debugpy-1.8.18-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:530c38114725505a7e4ea95328dbc24aabb9be708c6570623c8163412e6d1d6b", size = 2549961, upload-time = "2025-12-10T19:48:21.73Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/73/1eeaa15c20a2b627be57a65bc1ebf2edd8d896950eac323588b127d776f2/debugpy-1.8.18-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:a114865099283cbed4c9330cb0c9cb7a04cfa92e803577843657302d526141ec", size = 4309855, upload-time = "2025-12-10T19:48:23.41Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/6f/2da8ded21ae55df7067e57bd7f67ffed7e08b634f29bdba30c03d3f19918/debugpy-1.8.18-cp312-cp312-win32.whl", hash = "sha256:4d26736dfabf404e9f3032015ec7b0189e7396d0664e29e5bdbe7ac453043c95", size = 5280577, upload-time = "2025-12-10T19:48:25.386Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/8e/ebe887218c5b84f9421de7eb7bb7cdf196e84535c3f504a562219297d755/debugpy-1.8.18-cp312-cp312-win_amd64.whl", hash = "sha256:7e68ba950acbcf95ee862210133681f408cbb78d1c9badbb515230ec55ed6487", size = 5322458, upload-time = "2025-12-10T19:48:28.049Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/0d/bf7ac329c132436c57124202b5b5ccd6366e5d8e75eeb184cf078c826e8d/debugpy-1.8.18-py2.py3-none-any.whl", hash = "sha256:ab8cf0abe0fe2dfe1f7e65abc04b1db8740f9be80c1274acb625855c5c3ece6e", size = 5286576, upload-time = "2025-12-10T19:48:56.071Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/15/d762e5263d9e25b763b78be72dc084c7a32113a0bac119e2f7acae7700ed/debugpy-1.8.19-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:bccb1540a49cde77edc7ce7d9d075c1dbeb2414751bc0048c7a11e1b597a4c2e", size = 2549995, upload-time = "2025-12-15T21:53:43.773Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/88/f7d25c68b18873b7c53d7c156ca7a7ffd8e77073aa0eac170a9b679cf786/debugpy-1.8.19-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:e9c68d9a382ec754dc05ed1d1b4ed5bd824b9f7c1a8cd1083adb84b3c93501de", size = 4309891, upload-time = "2025-12-15T21:53:45.26Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/4f/a65e973aba3865794da65f71971dca01ae66666132c7b2647182d5be0c5f/debugpy-1.8.19-cp312-cp312-win32.whl", hash = "sha256:6599cab8a783d1496ae9984c52cb13b7c4a3bd06a8e6c33446832a5d97ce0bee", size = 5286355, upload-time = "2025-12-15T21:53:46.763Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/3a/d3d8b48fec96e3d824e404bf428276fb8419dfa766f78f10b08da1cb2986/debugpy-1.8.19-cp312-cp312-win_amd64.whl", hash = "sha256:66e3d2fd8f2035a8f111eb127fa508469dfa40928a89b460b41fd988684dc83d", size = 5328239, upload-time = "2025-12-15T21:53:48.868Z" },
+    { url = "https://files.pythonhosted.org/packages/25/3e/e27078370414ef35fafad2c06d182110073daaeb5d3bf734b0b1eeefe452/debugpy-1.8.19-py2.py3-none-any.whl", hash = "sha256:360ffd231a780abbc414ba0f005dad409e71c78637efe8f2bd75837132a41d38", size = 5292321, upload-time = "2025-12-15T21:54:16.024Z" },
 ]
 
 [[package]]
@@ -1270,7 +1376,7 @@ wheels = [
 
 [[package]]
 name = "fastapi"
-version = "0.124.4"
+version = "0.125.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-doc" },
@@ -1278,9 +1384,26 @@ dependencies = [
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cd/21/ade3ff6745a82ea8ad88552b4139d27941549e4f19125879f848ac8f3c3d/fastapi-0.124.4.tar.gz", hash = "sha256:0e9422e8d6b797515f33f500309f6e1c98ee4e85563ba0f2debb282df6343763", size = 378460, upload-time = "2025-12-12T15:00:43.891Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/17/71/2df15009fb4bdd522a069d2fbca6007c6c5487fce5cb965be00fc335f1d1/fastapi-0.125.0.tar.gz", hash = "sha256:16b532691a33e2c5dee1dac32feb31dc6eb41a3dd4ff29a95f9487cb21c054c0", size = 370550, upload-time = "2025-12-17T21:41:44.15Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/2f/ff2fcc98f500713368d8b650e1bbc4a0b3ebcdd3e050dcdaad5f5a13fd7e/fastapi-0.125.0-py3-none-any.whl", hash = "sha256:2570ec4f3aecf5cca8f0428aed2398b774fcdfee6c2116f86e80513f2f86a7a1", size = 112888, upload-time = "2025-12-17T21:41:41.286Z" },
+]
+
+[[package]]
+name = "fastcluster"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/41/1e/417892546cb92e71f5bcaeffc8d89b47716fd811805a8ae559b91f754015/fastcluster-1.3.0.tar.gz", hash = "sha256:d5233aeba5c3faa949c7fa6a39345a09f716ccebbd748541e5735c866696df02", size = 173065, upload-time = "2025-05-06T17:45:30.101Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3e/57/aa70121b5008f44031be645a61a7c4abc24e0e888ad3fc8fda916f4d188e/fastapi-0.124.4-py3-none-any.whl", hash = "sha256:6d1e703698443ccb89e50abe4893f3c84d9d6689c0cf1ca4fad6d3c15cf69f15", size = 113281, upload-time = "2025-12-12T15:00:42.44Z" },
+    { url = "https://files.pythonhosted.org/packages/41/dc/b43081c5f4c1441b46e847adee464cea22dbb106891437b4a2d41a81f59a/fastcluster-1.3.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b20785852abb0ba5af62316327b654cea0fd736f819cd48792de0875ffb485f0", size = 62799, upload-time = "2025-05-06T17:45:15.084Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/77/d1cf1f6e6c83c11ebcf4d378a5ea566d30b50e240477f695e33a9b88698b/fastcluster-1.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6be2e33529917df1398f5d85ea55856ebddd81041b0fbe2dfc6badcb0c3b2054", size = 38879, upload-time = "2025-05-06T17:45:16.649Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/69/0bf77416d2fba60d773039eb236c6fcf64384236c58e63b5a2120e803af3/fastcluster-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1ddd6df989ee9ced20c4ecd7cef8df421a10b5410913385bb29d9183d21cc5ee", size = 34778, upload-time = "2025-05-06T17:45:17.646Z" },
+    { url = "https://files.pythonhosted.org/packages/db/36/bc720b34d27bcb40024d63692e1f30a4e9402670881121755c5a1fb5e5c8/fastcluster-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0d22a99d2fef1d7a314650e0f5fc78d4f91d4b233e5aa81b31da45506d25f21", size = 184385, upload-time = "2025-05-06T17:45:18.697Z" },
+    { url = "https://files.pythonhosted.org/packages/27/eb/df607b9e505fc105539977c7da68af06a448d6dfb86355ff2b839c775fbe/fastcluster-1.3.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:428126288895fcb6316a239635bafaa19e4677240afee2723a952e488929091d", size = 194095, upload-time = "2025-05-06T17:45:20.378Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/63/e6ffa0b2cc9d708f9ab6eb4dd22fc843d64002e7cf9b2bc1ca6ec6df0dd7/fastcluster-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:317db2531895cdf178a3009d3a8b13dfa83a5ed4ab14943b33377174cf9420cf", size = 37350, upload-time = "2025-05-06T17:45:22.018Z" },
 ]
 
 [[package]]
@@ -1360,11 +1483,11 @@ wheels = [
 
 [[package]]
 name = "filelock"
-version = "3.20.0"
+version = "3.20.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/58/46/0028a82567109b5ef6e4d2a1f04a583fb513e6cf9527fcdd09afd817deeb/filelock-3.20.0.tar.gz", hash = "sha256:711e943b4ec6be42e1d4e6690b48dc175c822967466bb31c0c293f34334c13f4", size = 18922, upload-time = "2025-10-08T18:03:50.056Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/23/ce7a1126827cedeb958fc043d61745754464eb56c5937c35bbf2b8e26f34/filelock-3.20.1.tar.gz", hash = "sha256:b8360948b351b80f420878d8516519a2204b07aefcdcfd24912a5d33127f188c", size = 19476, upload-time = "2025-12-15T23:54:28.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7f/a1a97644e39e7316d850784c642093c99df1290a460df4ede27659056834/filelock-3.20.1-py3-none-any.whl", hash = "sha256:15d9e9a67306188a44baa72f569d2bfd803076269365fdea0934385da4dc361a", size = 16666, upload-time = "2025-12-15T23:54:26.874Z" },
 ]
 
 [[package]]
@@ -1401,19 +1524,19 @@ wheels = [
 
 [[package]]
 name = "fonttools"
-version = "4.61.0"
+version = "4.61.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/33/f9/0e84d593c0e12244150280a630999835a64f2852276161b62a0f98318de0/fonttools-4.61.0.tar.gz", hash = "sha256:ec520a1f0c7758d7a858a00f090c1745f6cde6a7c5e76fb70ea4044a15f712e7", size = 3561884, upload-time = "2025-11-28T17:05:49.491Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/ca/cf17b88a8df95691275a3d77dc0a5ad9907f328ae53acbe6795da1b2f5ed/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69", size = 3565756, upload-time = "2025-12-12T17:31:24.246Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/5d/19e5939f773c7cb05480fe2e881d63870b63ee2b4bdb9a77d55b1d36c7b9/fonttools-4.61.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e24a1565c4e57111ec7f4915f8981ecbb61adf66a55f378fdc00e206059fcfef", size = 2846930, upload-time = "2025-11-28T17:04:46.639Z" },
-    { url = "https://files.pythonhosted.org/packages/25/b2/0658faf66f705293bd7e739a4f038302d188d424926be9c59bdad945664b/fonttools-4.61.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2bfacb5351303cae9f072ccf3fc6ecb437a6f359c0606bae4b1ab6715201d87", size = 2383016, upload-time = "2025-11-28T17:04:48.525Z" },
-    { url = "https://files.pythonhosted.org/packages/29/a3/1fa90b95b690f0d7541f48850adc40e9019374d896c1b8148d15012b2458/fonttools-4.61.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0bdcf2e29d65c26299cc3d502f4612365e8b90a939f46cd92d037b6cb7bb544a", size = 4949425, upload-time = "2025-11-28T17:04:50.482Z" },
-    { url = "https://files.pythonhosted.org/packages/af/00/acf18c00f6c501bd6e05ee930f926186f8a8e268265407065688820f1c94/fonttools-4.61.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6cd0d9051b8ddaf7385f99dd82ec2a058e2b46cf1f1961e68e1ff20fcbb61af", size = 4999632, upload-time = "2025-11-28T17:04:52.508Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/e0/19a2b86e54109b1d2ee8743c96a1d297238ae03243897bc5345c0365f34d/fonttools-4.61.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e074bc07c31406f45c418e17c1722e83560f181d122c412fa9e815df0ff74810", size = 4939438, upload-time = "2025-11-28T17:04:54.437Z" },
-    { url = "https://files.pythonhosted.org/packages/04/35/7b57a5f57d46286360355eff8d6b88c64ab6331107f37a273a71c803798d/fonttools-4.61.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5a9b78da5d5faa17e63b2404b77feeae105c1b7e75f26020ab7a27b76e02039f", size = 5088960, upload-time = "2025-11-28T17:04:56.348Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/0e/6c5023eb2e0fe5d1ababc7e221e44acd3ff668781489cc1937a6f83d620a/fonttools-4.61.0-cp312-cp312-win32.whl", hash = "sha256:9821ed77bb676736b88fa87a737c97b6af06e8109667e625a4f00158540ce044", size = 2264404, upload-time = "2025-11-28T17:04:58.149Z" },
-    { url = "https://files.pythonhosted.org/packages/36/0b/63273128c7c5df19b1e4cd92e0a1e6ea5bb74a400c4905054c96ad60a675/fonttools-4.61.0-cp312-cp312-win_amd64.whl", hash = "sha256:0011d640afa61053bc6590f9a3394bd222de7cfde19346588beabac374e9d8ac", size = 2314427, upload-time = "2025-11-28T17:04:59.812Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/14/634f7daea5ffe6a5f7a0322ba8e1a0e23c9257b80aa91458107896d1dfc7/fonttools-4.61.0-py3-none-any.whl", hash = "sha256:276f14c560e6f98d24ef7f5f44438e55ff5a67f78fa85236b218462c9f5d0635", size = 1144485, upload-time = "2025-11-28T17:05:47.573Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/16/7decaa24a1bd3a70c607b2e29f0adc6159f36a7e40eaba59846414765fd4/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e", size = 2851593, upload-time = "2025-12-12T17:30:04.225Z" },
+    { url = "https://files.pythonhosted.org/packages/94/98/3c4cb97c64713a8cf499b3245c3bf9a2b8fd16a3e375feff2aed78f96259/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2", size = 2400231, upload-time = "2025-12-12T17:30:06.47Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/37/82dbef0f6342eb01f54bca073ac1498433d6ce71e50c3c3282b655733b31/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796", size = 4954103, upload-time = "2025-12-12T17:30:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/44/f3aeac0fa98e7ad527f479e161aca6c3a1e47bb6996b053d45226fe37bf2/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d", size = 5004295, upload-time = "2025-12-12T17:30:10.56Z" },
+    { url = "https://files.pythonhosted.org/packages/14/e8/7424ced75473983b964d09f6747fa09f054a6d656f60e9ac9324cf40c743/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8", size = 4944109, upload-time = "2025-12-12T17:30:12.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/8b/6391b257fa3d0b553d73e778f953a2f0154292a7a7a085e2374b111e5410/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0", size = 5093598, upload-time = "2025-12-12T17:30:15.79Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/71/fd2ea96cdc512d92da5678a1c98c267ddd4d8c5130b76d0f7a80f9a9fde8/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261", size = 2269060, upload-time = "2025-12-12T17:30:18.058Z" },
+    { url = "https://files.pythonhosted.org/packages/80/3b/a3e81b71aed5a688e89dfe0e2694b26b78c7d7f39a5ffd8a7d75f54a12a8/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9", size = 2319078, upload-time = "2025-12-12T17:30:22.862Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/4e/ce75a57ff3aebf6fc1f4e9d508b8e5810618a33d900ad6c19eb30b290b97/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371", size = 1148996, upload-time = "2025-12-12T17:31:21.03Z" },
 ]
 
 [[package]]
@@ -1505,29 +1628,29 @@ wheels = [
 
 [[package]]
 name = "google-auth"
-version = "2.43.0"
+version = "2.45.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cachetools" },
     { name = "pyasn1-modules" },
     { name = "rsa" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ff/ef/66d14cf0e01b08d2d51ffc3c20410c4e134a1548fc246a6081eae585a4fe/google_auth-2.43.0.tar.gz", hash = "sha256:88228eee5fc21b62a1b5fe773ca15e67778cb07dc8363adcb4a8827b52d81483", size = 296359, upload-time = "2025-11-06T00:13:36.587Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/00/3c794502a8b892c404b2dea5b3650eb21bfc7069612fbfd15c7f17c1cb0d/google_auth-2.45.0.tar.gz", hash = "sha256:90d3f41b6b72ea72dd9811e765699ee491ab24139f34ebf1ca2b9cc0c38708f3", size = 320708, upload-time = "2025-12-15T22:58:42.889Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6f/d1/385110a9ae86d91cc14c5282c61fe9f4dc41c0b9f7d423c6ad77038c4448/google_auth-2.43.0-py2.py3-none-any.whl", hash = "sha256:af628ba6fa493f75c7e9dbe9373d148ca9f4399b5ea29976519e0a3848eddd16", size = 223114, upload-time = "2025-11-06T00:13:35.209Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/97/451d55e05487a5cd6279a01a7e34921858b16f7dc8aa38a2c684743cd2b3/google_auth-2.45.0-py2.py3-none-any.whl", hash = "sha256:82344e86dc00410ef5382d99be677c6043d72e502b625aa4f4afa0bdacca0f36", size = 233312, upload-time = "2025-12-15T22:58:40.777Z" },
 ]
 
 [[package]]
 name = "google-crc32c"
-version = "1.7.1"
+version = "1.8.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/ae/87802e6d9f9d69adfaedfcfd599266bf386a54d0be058b532d04c794f76d/google_crc32c-1.7.1.tar.gz", hash = "sha256:2bff2305f98846f3e825dbeec9ee406f89da7962accdb29356e4eadc251bd472", size = 14495, upload-time = "2025-03-26T14:29:13.32Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/03/41/4b9c02f99e4c5fb477122cd5437403b552873f014616ac1d19ac8221a58d/google_crc32c-1.8.0.tar.gz", hash = "sha256:a428e25fb7691024de47fecfbff7ff957214da51eddded0da0ae0e0f03a2cf79", size = 14192, upload-time = "2025-12-16T00:35:25.142Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dd/b7/787e2453cf8639c94b3d06c9d61f512234a82e1d12d13d18584bd3049904/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:2d73a68a653c57281401871dd4aeebbb6af3191dcac751a76ce430df4d403194", size = 30470, upload-time = "2025-03-26T14:34:31.655Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/b4/6042c2b0cbac3ec3a69bb4c49b28d2f517b7a0f4a0232603c42c58e22b44/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:22beacf83baaf59f9d3ab2bbb4db0fb018da8e5aebdce07ef9f09fce8220285e", size = 30315, upload-time = "2025-03-26T15:01:54.634Z" },
-    { url = "https://files.pythonhosted.org/packages/29/ad/01e7a61a5d059bc57b702d9ff6a18b2585ad97f720bd0a0dbe215df1ab0e/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19eafa0e4af11b0a4eb3974483d55d2d77ad1911e6cf6f832e1574f6781fd337", size = 33180, upload-time = "2025-03-26T14:41:32.168Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/a5/7279055cf004561894ed3a7bfdf5bf90a53f28fadd01af7cd166e88ddf16/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6d86616faaea68101195c6bdc40c494e4d76f41e07a37ffdef270879c15fb65", size = 32794, upload-time = "2025-03-26T14:41:33.264Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/d6/77060dbd140c624e42ae3ece3df53b9d811000729a5c821b9fd671ceaac6/google_crc32c-1.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:b7491bdc0c7564fcf48c0179d2048ab2f7c7ba36b84ccd3a3e1c3f7a72d3bba6", size = 33477, upload-time = "2025-03-26T14:29:10.94Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5f/7307325b1198b59324c0fa9807cafb551afb65e831699f2ce211ad5c8240/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:4b8286b659c1335172e39563ab0a768b8015e88e08329fa5321f774275fc3113", size = 31300, upload-time = "2025-12-16T00:21:56.723Z" },
+    { url = "https://files.pythonhosted.org/packages/21/8e/58c0d5d86e2220e6a37befe7e6a94dd2f6006044b1a33edf1ff6d9f7e319/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:2a3dc3318507de089c5384cc74d54318401410f82aa65b2d9cdde9d297aca7cb", size = 30867, upload-time = "2025-12-16T00:38:31.302Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/a9/a780cc66f86335a6019f557a8aaca8fbb970728f0efd2430d15ff1beae0e/google_crc32c-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14f87e04d613dfa218d6135e81b78272c3b904e2a7053b841481b38a7d901411", size = 33364, upload-time = "2025-12-16T00:40:22.96Z" },
+    { url = "https://files.pythonhosted.org/packages/21/3f/3457ea803db0198c9aaca2dd373750972ce28a26f00544b6b85088811939/google_crc32c-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb5c869c2923d56cb0c8e6bcdd73c009c36ae39b652dbe46a05eb4ef0ad01454", size = 33740, upload-time = "2025-12-16T00:40:23.96Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c0/87c2073e0c72515bb8733d4eef7b21548e8d189f094b5dad20b0ecaf64f6/google_crc32c-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:3cc0c8912038065eafa603b238abf252e204accab2a704c63b9e14837a854962", size = 34437, upload-time = "2025-12-16T00:35:21.395Z" },
 ]
 
 [[package]]
@@ -1640,6 +1763,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/09/a8/2d02b10a66747c54446e932171dd89b8b4126c0111b440e6bc05a7c852ec/h5py-3.15.1-cp312-cp312-win_arm64.whl", hash = "sha256:61d5a58a9851e01ee61c932bbbb1c98fe20aba0a5674776600fb9a361c0aa652", size = 2458214, upload-time = "2025-10-16T10:34:35.733Z" },
 ]
 
+[[package]]
+name = "harmony-pytorch"
+version = "0.1.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "psutil" },
+    { name = "scikit-learn" },
+    { name = "threadpoolctl" },
+    { name = "torch" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8d/df/71fe694d70ff148db2364c4118a6bbd37e598be269be471ed3d2f6bfee1a/harmony-pytorch-0.1.8.tar.gz", hash = "sha256:1b097906d49c6ed9dde6cf234f7d987fb49a3b649b8a1323d99e6ea71b5b7df2", size = 8373, upload-time = "2024-01-07T21:36:56.059Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/da/42486f1c79b6f2db9140ee23161791e5b25d9369f30c1d9f67b67f3eb4bf/harmony_pytorch-0.1.8-py3-none-any.whl", hash = "sha256:1f92f6145ea93225b0226fda9da5bdd442e411d14ff402052afae0fde7fd1452", size = 8474, upload-time = "2024-01-07T21:36:54.488Z" },
+]
+
 [[package]]
 name = "hbreader"
 version = "0.9.1"
@@ -1792,6 +1932,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
 ]
 
+[[package]]
+name = "igraph"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "texttable" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/be/56bef1919005b4caf1f71522b300d359f7faeb7ae93a3b0baa9b4f146a87/igraph-1.0.0.tar.gz", hash = "sha256:2414d0be2e4d77ee5357807d100974b40f6082bb1bb71988ec46cfb6728651ee", size = 5077105, upload-time = "2025-10-23T12:22:50.127Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a5/03/3278ad0ceb3ea0e84d8ae3a85bdded4d0e57853aeb802a200feb43847b93/igraph-1.0.0-cp39-abi3-macosx_10_15_x86_64.whl", hash = "sha256:c2cbc415e02523e5a241eecee82319080bf928a70b1ba299f3b3e25bf029b6d4", size = 2257415, upload-time = "2025-10-23T12:22:27.246Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/bc/6281ec7f9baaf71ee57c3b1748da2d3148d15d253e1a03006f204aa68ca5/igraph-1.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a27753cd80680a8f676c2d5a467aaa4a95e510b30748398ec4e4aeb982130e8", size = 2048555, upload-time = "2025-10-23T12:22:29.49Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/38/3cd6428a4ed4c09a56df05998438e7774fd1d799ee4fb8fc481674f5f7fc/igraph-1.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a55dc3a2a4e3fc3eba42479910c1511bfc3ecb33cdf5f0406891fd85f14b5aee", size = 5314141, upload-time = "2025-10-23T12:22:31.023Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/da/dd2867c25adbb41563720f14b5fc895c98bf88be682a3faff4f7b3118d2a/igraph-1.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2d04c2c76f686fb1f554ee35dfd3085f5e73b7965ba6b4cf06d53e66b1955522", size = 5683134, upload-time = "2025-10-23T12:22:32.423Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/40/243c118d34ab80382d7009c4dcb99b887384c3d2ce84d29eeac19e2a007a/igraph-1.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f2b52dc1757fff0fed29a9f7a276d971a11db4211569ed78b9eab36288dfcc9d", size = 6211583, upload-time = "2025-10-23T12:22:34.238Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/b7/88f433819c54b496cb0315fce28e658970cb20ff5dbd52a5a605ce2888de/igraph-1.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:05c79a2a8fca695b2f217a6fa7f2549f896f757d4db41be32a055400cb19cc30", size = 6594509, upload-time = "2025-10-23T12:22:35.831Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5d/8f7f6f619d374e959aa3664ebc4b24c10abc90c2e8efbed97f2623fadaf5/igraph-1.0.0-cp39-abi3-win32.whl", hash = "sha256:c2bce3cd472fec3dd9c4d8a3ea5b6b9be65fb30edf760beb4850760dd4f2d479", size = 2725406, upload-time = "2025-10-23T12:22:37.588Z" },
+    { url = "https://files.pythonhosted.org/packages/af/77/a85b3745cf40a0572bae2de8cd9c2a2a8af78e5cf3e880fc0a249114e609/igraph-1.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:faeff8ede0cf15eb4ded44b0fcea6e1886740146e60504c24ad2da14e0939563", size = 3221663, upload-time = "2025-10-23T12:22:39.404Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/7e/5df541c37bdf6493035e89c22bd53f30d99b291bcda6c78e9a8afeecec2b/igraph-1.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:b607cafc24b10a615e713ee96e58208ef27e0764af80140c7cc45d4724a3f2df", size = 2785701, upload-time = "2025-10-23T12:22:41.03Z" },
+]
+
 [[package]]
 name = "ijson"
 version = "3.4.0.post0"
@@ -1811,6 +1971,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a1/2b/6f7ade27a8ff5758fc41006dadd2de01730def84fe3e60553b329c59e0d4/ijson-3.4.0.post0-cp312-cp312-win_amd64.whl", hash = "sha256:e15833dcf6f6d188fdc624a31cd0520c3ba21b6855dc304bc7c1a8aeca02d4ac", size = 54789, upload-time = "2025-10-10T05:28:19.552Z" },
 ]
 
+[[package]]
+name = "imageio"
+version = "2.37.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "pillow" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/6f/606be632e37bf8d05b253e8626c2291d74c691ddc7bcdf7d6aaf33b32f6a/imageio-2.37.2.tar.gz", hash = "sha256:0212ef2727ac9caa5ca4b2c75ae89454312f440a756fcfc8ef1993e718f50f8a", size = 389600, upload-time = "2025-11-04T14:29:39.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/fe/301e0936b79bcab4cacc7548bf2853fc28dced0a578bab1f7ef53c9aa75b/imageio-2.37.2-py3-none-any.whl", hash = "sha256:ad9adfb20335d718c03de457358ed69f141021a333c40a53e57273d8a5bd0b9b", size = 317646, upload-time = "2025-11-04T14:29:37.948Z" },
+]
+
 [[package]]
 name = "imagesize"
 version = "1.4.1"
@@ -2064,11 +2237,11 @@ wheels = [
 
 [[package]]
 name = "joblib"
-version = "1.5.2"
+version = "1.5.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/5d/447af5ea094b9e4c4054f82e223ada074c552335b9b4b2d14bd9b35a67c4/joblib-1.5.2.tar.gz", hash = "sha256:3faa5c39054b2f03ca547da9b2f52fde67c06240c31853f306aea97f13647b55", size = 331077, upload-time = "2025-08-27T12:15:46.575Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/e8/685f47e0d754320684db4425a0967f7d3fa70126bffd76110b7009a0090f/joblib-1.5.2-py3-none-any.whl", hash = "sha256:4e1f0bdbb987e6d843c70cf43714cb276623def372df3c22fe5266b2670bc241", size = 308396, upload-time = "2025-08-27T12:15:45.188Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
 ]
 
 [[package]]
@@ -2341,7 +2514,7 @@ wheels = [
 
 [[package]]
 name = "jupyterlab"
-version = "4.5.0"
+version = "4.5.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "async-lru" },
@@ -2358,9 +2531,9 @@ dependencies = [
     { name = "tornado" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/df/e5/4fa382a796a6d8e2cd867816b64f1ff27f906e43a7a83ad9eb389e448cd8/jupyterlab-4.5.0.tar.gz", hash = "sha256:aec33d6d8f1225b495ee2cf20f0514f45e6df8e360bdd7ac9bace0b7ac5177ea", size = 23989880, upload-time = "2025-11-18T13:19:00.365Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/21/413d142686a4e8f4268d985becbdb4daf060524726248e73be4773786987/jupyterlab-4.5.1.tar.gz", hash = "sha256:09da1ddfbd9eec18b5101dbb8515612aa1e47443321fb99503725a88e93d20d9", size = 23992251, upload-time = "2025-12-15T16:58:59.361Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/1e/5a4d5498eba382fee667ed797cf64ae5d1b13b04356df62f067f48bb0f61/jupyterlab-4.5.0-py3-none-any.whl", hash = "sha256:88e157c75c1afff64c7dc4b801ec471450b922a4eae4305211ddd40da8201c8a", size = 12380641, upload-time = "2025-11-18T13:18:56.252Z" },
+    { url = "https://files.pythonhosted.org/packages/af/c3/acced767eecc11a70c65c45295db5396c4f0c1937874937d5a76d7b177b6/jupyterlab-4.5.1-py3-none-any.whl", hash = "sha256:31b059de96de0754ff1f2ce6279774b6aab8c34d7082e9752db58207c99bd514", size = 12384821, upload-time = "2025-12-15T16:58:55.563Z" },
 ]
 
 [[package]]
@@ -2536,6 +2709,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097, upload-time = "2024-04-05T13:03:10.514Z" },
 ]
 
+[[package]]
+name = "legacy-api-wrap"
+version = "1.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/49/f06f94048c8974205730d40beca879e43b6eee08efb0101cfb8623e60f41/legacy_api_wrap-1.5.tar.gz", hash = "sha256:b41ba6532f3ebfe3a897a35a7f97dec3be04b92a450f6c2bcf89f1b91c9cadf2", size = 11610, upload-time = "2025-11-03T13:21:12.437Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/5b/058db09c45ba58a7321bdf2294cae651b37d6fec68117265af90cde043b0/legacy_api_wrap-1.5-py3-none-any.whl", hash = "sha256:5a8ea50e3e3bcbcdec3447b77034fd0d32cb2cf4089db799238708e4d7e0098d", size = 10182, upload-time = "2025-11-03T13:21:11.102Z" },
+]
+
+[[package]]
+name = "leidenalg"
+version = "0.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "igraph" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5d/a5/853e93441aed7f82b0389f86f37e19413e817ba0c54cc790895935256968/leidenalg-0.11.0.tar.gz", hash = "sha256:f454be96bbc8089ea2a90ca853d8d389ab646de964a03bd58417f8b29ff8ef5d", size = 452850, upload-time = "2025-10-31T17:14:48.684Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/a9/4ab4e244215db0c8b626e4bed0d3e0fbd191c52d2d5f5cb9d160139ecc7e/leidenalg-0.11.0-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:5607589050bfc1926e657b4d8a3b5341fe1eb81018c22cf4a3d3a39e368d1fcb", size = 2256514, upload-time = "2025-10-31T17:14:27.574Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f4/98db342d603671ae0a233f0a624939a47161044a2716cbd62a50440a1132/leidenalg-0.11.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:9b5781876b1f1faed72a4f9926ff52de286843556b9d6791fe25a2acb33b7a5c", size = 1926003, upload-time = "2025-10-31T17:14:29.521Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/38/fd6ac21af10b12828b472eada4fce0edf2a212581238ad0c8d1afebc6f98/leidenalg-0.11.0-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a80f49477f8e793f27d8e08949177f19e3834cd878af50a662b4f87335d06549", size = 2545535, upload-time = "2025-10-31T17:14:31.102Z" },
+    { url = "https://files.pythonhosted.org/packages/77/87/b087584750a788535b4a8d56ddeb82a175d32b472aa5338a4e2cc593a42c/leidenalg-0.11.0-cp38-abi3-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:2143be3e80485584ccbdf927323fce65345da17facd0f8b438f11015f5dc6c27", size = 2845029, upload-time = "2025-10-31T17:14:32.815Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/a4/a89e2ce16a580f7bea066ed49364f0b3e04a6412f0c3692975bee8515141/leidenalg-0.11.0-cp38-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:571a0934f831a69442d82889d319bdba93de924bd9e09b720cd8cbe6fdc08c17", size = 2738084, upload-time = "2025-10-31T17:14:35.246Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/fe/8923cac6cd7c9e0ac5f38aaa69a4744c93d025575763d05f7a3baae8020d/leidenalg-0.11.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:aec03e7178b19102dd271b453a39b9865cf283b4113151ba60514e5681046294", size = 4070307, upload-time = "2025-10-31T17:14:36.796Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/94/beaab5ee9968f9389f705532c31ffb868bad8a5ce68fb699ddde5ddc5409/leidenalg-0.11.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:310b9269a11fd1e960590c1a2b6ff685a2cc42aa3234ce67bc2a623ab61f26a9", size = 3797863, upload-time = "2025-10-31T17:14:38.124Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/8e/8caf4ba38fd7d8e6197348b348a4ab666b1b3117225ea2f0934a98a93176/leidenalg-0.11.0-cp38-abi3-win32.whl", hash = "sha256:5ea4cd7ee054540112b28f7e2d64658dcccd59f61a5d6a08a41df808645f96e9", size = 1643351, upload-time = "2025-10-31T17:14:39.385Z" },
+    { url = "https://files.pythonhosted.org/packages/47/15/7d459a8e2a43f17c1db129b997b7bb7aa7f000a0967bab87c28b8c5cf448/leidenalg-0.11.0-cp38-abi3-win_amd64.whl", hash = "sha256:5e789c0960008d185413344a402d0587580c441644d4d20bf57c96f25d4d1710", size = 1990321, upload-time = "2025-10-31T17:14:40.892Z" },
+]
+
 [[package]]
 name = "linkcheckmd"
 version = "1.4.0"
@@ -2631,6 +2833,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/6b/d139535d7590a1bba1ceb68751bef22fadaa5b815bbdf0e858e3875726b2/llvmlite-0.46.0-cp312-cp312-win_amd64.whl", hash = "sha256:398b39db462c39563a97b912d4f2866cd37cba60537975a09679b28fbbc0fb38", size = 38138940, upload-time = "2025-12-08T18:15:10.162Z" },
 ]
 
+[[package]]
+name = "locket"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/83/97b29fe05cb6ae28d2dbd30b81e2e402a3eed5f460c26e9eaa5895ceacf5/locket-1.0.0.tar.gz", hash = "sha256:5c0d4c052a8bbbf750e056a8e65ccd309086f4f0f18a2eac306a8dfa4112a632", size = 4350, upload-time = "2022-04-20T22:04:44.312Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl", hash = "sha256:b6c819a722f7b6bd955b80781788e4a66a55628b858d347536b7e81325a3a5e3", size = 4398, upload-time = "2022-04-20T22:04:42.23Z" },
+]
+
 [[package]]
 name = "loguru"
 version = "0.7.3"
@@ -3025,11 +3236,20 @@ wheels = [
 
 [[package]]
 name = "narwhals"
-version = "2.13.0"
+version = "2.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4a/84/897fe7b6406d436ef312e57e5a1a13b4a5e7e36d1844e8d934ce8880e3d3/narwhals-2.14.0.tar.gz", hash = "sha256:98be155c3599db4d5c211e565c3190c398c87e7bf5b3cdb157dece67641946e0", size = 600648, upload-time = "2025-12-16T11:29:13.458Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/3e/b8ecc67e178919671695f64374a7ba916cf0adbf86efedc6054f38b5b8ae/narwhals-2.14.0-py3-none-any.whl", hash = "sha256:b56796c9a00179bd757d15282c540024e1d5c910b19b8c9944d836566c030acf", size = 430788, upload-time = "2025-12-16T11:29:11.699Z" },
+]
+
+[[package]]
+name = "natsort"
+version = "8.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/89/ea/f82ef99ced4d03c33bb314c9b84a08a0a86c448aaa11ffd6256b99538aa5/narwhals-2.13.0.tar.gz", hash = "sha256:ee94c97f4cf7cfeebbeca8d274784df8b3d7fd3f955ce418af998d405576fdd9", size = 594555, upload-time = "2025-12-01T13:54:05.329Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e2/a9/a0c57aee75f77794adaf35322f8b6404cbd0f89ad45c87197a937764b7d0/natsort-8.4.0.tar.gz", hash = "sha256:45312c4a0e5507593da193dedd04abb1469253b601ecaf63445ad80f0a1ea581", size = 76575, upload-time = "2023-06-20T04:17:19.925Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/0d/1861d1599571974b15b025e12b142d8e6b42ad66c8a07a89cb0fc21f1e03/narwhals-2.13.0-py3-none-any.whl", hash = "sha256:9b795523c179ca78204e3be53726da374168f906e38de2ff174c2363baaaf481", size = 426407, upload-time = "2025-12-01T13:54:03.861Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/82/7a9d0550484a62c6da82858ee9419f3dd1ccc9aa1c26a1e43da3ecd20b0d/natsort-8.4.0-py3-none-any.whl", hash = "sha256:4732914fb471f56b5cce04d7bae6f164a592c7712e1c85f9ef585e197299521c", size = 38268, upload-time = "2023-06-20T04:17:17.522Z" },
 ]
 
 [[package]]
@@ -3181,7 +3401,7 @@ wheels = [
 
 [[package]]
 name = "notebook"
-version = "7.5.0"
+version = "7.5.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jupyter-server" },
@@ -3190,9 +3410,9 @@ dependencies = [
     { name = "notebook-shim" },
     { name = "tornado" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/89/ac/a97041621250a4fc5af379fb377942841eea2ca146aab166b8fcdfba96c2/notebook-7.5.0.tar.gz", hash = "sha256:3b27eaf9913033c28dde92d02139414c608992e1df4b969c843219acf2ff95e4", size = 14052074, upload-time = "2025-11-19T08:36:20.093Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/a9/882707b0aa639e6d7d3e7df4bfbe07479d832e9a8f02d8471002a4ea6d65/notebook-7.5.1.tar.gz", hash = "sha256:b2fb4cef4d47d08c33aecce1c6c6e84be05436fbd791f88fce8df9fbca088b75", size = 14058696, upload-time = "2025-12-16T07:38:59.223Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/96/00df2a4760f10f5af0f45c4955573cae6189931f9a30265a35865f8c1031/notebook-7.5.0-py3-none-any.whl", hash = "sha256:3300262d52905ca271bd50b22617681d95f08a8360d099e097726e6d2efb5811", size = 14460968, upload-time = "2025-11-19T08:36:15.869Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/86/ca516cb58ad2cb2064124d31cf0fd8b012fca64bebeb26da2d2ddf03fc79/notebook-7.5.1-py3-none-any.whl", hash = "sha256:f4e2451c19910c33b88709b84537e11f6368c1cdff1aa0c43db701aea535dd44", size = 14468080, upload-time = "2025-12-16T07:38:55.644Z" },
 ]
 
 [[package]]
@@ -3508,7 +3728,7 @@ wheels = [
 
 [[package]]
 name = "openai"
-version = "2.11.0"
+version = "2.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -3520,9 +3740,9 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/8c/aa6aea6072f985ace9d6515046b9088ff00c157f9654da0c7b1e129d9506/openai-2.11.0.tar.gz", hash = "sha256:b3da01d92eda31524930b6ec9d7167c535e843918d7ba8a76b1c38f1104f321e", size = 624540, upload-time = "2025-12-11T19:11:58.539Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/39/8e347e9fda125324d253084bb1b82407e5e3c7777a03dc398f79b2d95626/openai-2.13.0.tar.gz", hash = "sha256:9ff633b07a19469ec476b1e2b5b26c5ef700886524a7a72f65e6f0b5203142d5", size = 626583, upload-time = "2025-12-16T18:19:44.387Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/f1/d9251b565fce9f8daeb45611e3e0d2f7f248429e40908dcee3b6fe1b5944/openai-2.11.0-py3-none-any.whl", hash = "sha256:21189da44d2e3d027b08c7a920ba4454b8b7d6d30ae7e64d9de11dbe946d4faa", size = 1064131, upload-time = "2025-12-11T19:11:56.816Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/d5/eb52edff49d3d5ea116e225538c118699ddeb7c29fa17ec28af14bc10033/openai-2.13.0-py3-none-any.whl", hash = "sha256:746521065fed68df2f9c2d85613bb50844343ea81f60009b60e6a600c9352c79", size = 1066837, upload-time = "2025-12-16T18:19:43.124Z" },
 ]
 
 [[package]]
@@ -3722,6 +3942,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" },
 ]
 
+[[package]]
+name = "partd"
+version = "1.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "locket" },
+    { name = "toolz" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/3a/3f06f34820a31257ddcabdfafc2672c5816be79c7e353b02c1f318daa7d4/partd-1.4.2.tar.gz", hash = "sha256:d022c33afbdc8405c226621b015e8067888173d85f7f5ecebb3cafed9a20f02c", size = 21029, upload-time = "2024-05-06T19:51:41.945Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl", hash = "sha256:978e4ac767ec4ba5b86c6eaa52e5a2a3bc748a2ca839e8cc798f1cc6ce6efb0f", size = 18905, upload-time = "2024-05-06T19:51:39.271Z" },
+]
+
 [[package]]
 name = "pathlib-abc"
 version = "0.5.2"
@@ -3851,7 +4084,7 @@ wheels = [
 
 [[package]]
 name = "pre-commit"
-version = "4.5.0"
+version = "4.5.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cfgv" },
@@ -3860,9 +4093,9 @@ dependencies = [
     { name = "pyyaml" },
     { name = "virtualenv" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f4/9b/6a4ffb4ed980519da959e1cf3122fc6cb41211daa58dbae1c73c0e519a37/pre_commit-4.5.0.tar.gz", hash = "sha256:dc5a065e932b19fc1d4c653c6939068fe54325af8e741e74e88db4d28a4dd66b", size = 198428, upload-time = "2025-11-22T21:02:42.304Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/c4/b2d28e9d2edf4f1713eb3c29307f1a63f3d67cf09bdda29715a36a68921a/pre_commit-4.5.0-py2.py3-none-any.whl", hash = "sha256:25e2ce09595174d9c97860a95609f9f852c0614ba602de3561e267547f2335e1", size = 226429, upload-time = "2025-11-22T21:02:40.836Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
 ]
 
 [[package]]
@@ -4038,6 +4271,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2f/6a/15135b69e4fd28369433eb03264d201b1b0040ba534b05eddeb02a276684/py_rust_stemmers-0.1.5-cp312-none-win_amd64.whl", hash = "sha256:6ed61e1207f3b7428e99b5d00c055645c6415bb75033bff2d06394cbe035fd8e", size = 209395, upload-time = "2025-02-19T13:55:36.519Z" },
 ]
 
+[[package]]
+name = "pyarrow"
+version = "22.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload-time = "2025-10-24T10:05:21.583Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload-time = "2025-10-24T10:05:29.485Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload-time = "2025-10-24T10:05:38.274Z" },
+    { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload-time = "2025-10-24T10:05:47.314Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload-time = "2025-10-24T10:05:58.254Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload-time = "2025-10-24T10:06:08.08Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload-time = "2025-10-24T10:06:14.204Z" },
+]
+
 [[package]]
 name = "pyasn1"
 version = "0.6.1"
@@ -4294,6 +4542,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/35/76/c34426d532e4dce7ff36e4d92cb20f4cbbd94b619964b93d24e8f5b5510f/pynacl-1.6.1-cp38-abi3-win_arm64.whl", hash = "sha256:5953e8b8cfadb10889a6e7bd0f53041a745d1b3d30111386a1bb37af171e6daf", size = 183970, upload-time = "2025-11-10T16:02:05.786Z" },
 ]
 
+[[package]]
+name = "pynndescent"
+version = "0.5.13"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "joblib" },
+    { name = "llvmlite" },
+    { name = "numba" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7e/58/560a4db5eb3794d922fe55804b10326534ded3d971e1933c1eef91193f5e/pynndescent-0.5.13.tar.gz", hash = "sha256:d74254c0ee0a1eeec84597d5fe89fedcf778593eeabe32c2f97412934a9800fb", size = 2975955, upload-time = "2024-06-17T15:48:32.914Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/53/d23a97e0a2c690d40b165d1062e2c4ccc796be458a1ce59f6ba030434663/pynndescent-0.5.13-py3-none-any.whl", hash = "sha256:69aabb8f394bc631b6ac475a1c7f3994c54adf3f51cd63b2730fefba5771b949", size = 56850, upload-time = "2024-06-17T15:48:31.184Z" },
+]
+
 [[package]]
 name = "pyparsing"
 version = "3.2.5"
@@ -4906,6 +5170,61 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5d/e6/ec8471c8072382cb91233ba7267fd931219753bb43814cbc71757bfd4dab/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755", size = 341380, upload-time = "2025-11-19T15:18:44.427Z" },
 ]
 
+[[package]]
+name = "scanpy"
+version = "1.11.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anndata" },
+    { name = "h5py" },
+    { name = "joblib" },
+    { name = "legacy-api-wrap" },
+    { name = "matplotlib" },
+    { name = "natsort" },
+    { name = "networkx" },
+    { name = "numba" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+    { name = "patsy" },
+    { name = "pynndescent" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+    { name = "seaborn" },
+    { name = "session-info2" },
+    { name = "statsmodels" },
+    { name = "tqdm" },
+    { name = "typing-extensions" },
+    { name = "umap-learn" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d2/a8/285f1a9c995906b7e0ae3c399208fe67cfba8126dd31359dfef0908f6edc/scanpy-1.11.5.tar.gz", hash = "sha256:b2ef5476dfb1144b7dd0fae90b0198699c7988e6b27f083904150642c7ba6b89", size = 14088122, upload-time = "2025-10-21T08:24:43.999Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/e9/c1d43543da87cd27e8e2a74db85cf0b6c5cff2d5f04a86bd584d2fbc2bb0/scanpy-1.11.5-py3-none-any.whl", hash = "sha256:fcd383ddcf7acbf7c0ca232c25ad51b00aec9f8d2f7c8954b8c6ee0962257166", size = 2097836, upload-time = "2025-10-21T08:24:41.741Z" },
+]
+
+[[package]]
+name = "scikit-image"
+version = "0.25.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "imageio" },
+    { name = "lazy-loader" },
+    { name = "networkx" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "scipy" },
+    { name = "tifffile" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/a8/3c0f256012b93dd2cb6fda9245e9f4bff7dc0486880b248005f15ea2255e/scikit_image-0.25.2.tar.gz", hash = "sha256:e5a37e6cd4d0c018a7a55b9d601357e3382826d3888c10d0213fc63bff977dde", size = 22693594, upload-time = "2025-02-18T18:05:24.538Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/35/8c/5df82881284459f6eec796a5ac2a0a304bb3384eec2e73f35cfdfcfbf20c/scikit_image-0.25.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8db8dd03663112783221bf01ccfc9512d1cc50ac9b5b0fe8f4023967564719fb", size = 13986000, upload-time = "2025-02-18T18:04:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/e6/93bebe1abcdce9513ffec01d8af02528b4c41fb3c1e46336d70b9ed4ef0d/scikit_image-0.25.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:483bd8cc10c3d8a7a37fae36dfa5b21e239bd4ee121d91cad1f81bba10cfb0ed", size = 13235893, upload-time = "2025-02-18T18:04:51.049Z" },
+    { url = "https://files.pythonhosted.org/packages/53/4b/eda616e33f67129e5979a9eb33c710013caa3aa8a921991e6cc0b22cea33/scikit_image-0.25.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d1e80107bcf2bf1291acfc0bf0425dceb8890abe9f38d8e94e23497cbf7ee0d", size = 14178389, upload-time = "2025-02-18T18:04:54.245Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/b5/b75527c0f9532dd8a93e8e7cd8e62e547b9f207d4c11e24f0006e8646b36/scikit_image-0.25.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a17e17eb8562660cc0d31bb55643a4da996a81944b82c54805c91b3fe66f4824", size = 15003435, upload-time = "2025-02-18T18:04:57.586Z" },
+    { url = "https://files.pythonhosted.org/packages/34/e3/49beb08ebccda3c21e871b607c1cb2f258c3fa0d2f609fed0a5ba741b92d/scikit_image-0.25.2-cp312-cp312-win_amd64.whl", hash = "sha256:bdd2b8c1de0849964dbc54037f36b4e9420157e67e45a8709a80d727f52c7da2", size = 12899474, upload-time = "2025-02-18T18:05:01.166Z" },
+]
+
 [[package]]
 name = "scikit-learn"
 version = "1.8.0"
@@ -4926,6 +5245,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/24/90/344a67811cfd561d7335c1b96ca21455e7e472d281c3c279c4d3f2300236/scikit_learn-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:8c497fff237d7b4e07e9ef1a640887fa4fb765647f86fbe00f969ff6280ce2bb", size = 7641898, upload-time = "2025-12-10T07:08:01.36Z" },
 ]
 
+[[package]]
+name = "scikit-misc"
+version = "0.5.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/71/d6d2d1710fb56473817b0520212d33874069952dcb417614f6dd24efb51e/scikit_misc-0.5.2.tar.gz", hash = "sha256:49fa30e4051b341edc7422db66a12c0f59d468729285bfe644d10924dc51be0a", size = 298626, upload-time = "2025-11-03T11:56:30.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/56/43/1daca03447aa3bb80e4ca604fac647fc9ce926d928102a2aab9a9426ef18/scikit_misc-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:36f33c33494bea53196e68ba165a03cc0af19d09f83585adb0dc469d62dff0b7", size = 162933, upload-time = "2025-11-03T11:56:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/59/48/5a486b3a9cff8cd8abc0bdc21a1a23f9c5b73962ef6e66a502b7636fad08/scikit_misc-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:efc64474adcec7fc373b13519db19682ae1e75fbed0da044efce1ae232a6bb01", size = 150855, upload-time = "2025-11-03T11:56:17.895Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/7e/f003fd232ec3c3e29ae565e38536dbdef417c76f7c29a67203e05b800f44/scikit_misc-0.5.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd5a6e06864b07e9fe18c2bac756163e87f26615e5ddaa5f6129fd62535b7cfb", size = 182978, upload-time = "2025-11-03T11:56:19.104Z" },
+    { url = "https://files.pythonhosted.org/packages/46/35/fe7a3074c1453b2b8cd259d1797fc5146d2383603f9ac838c92bc0bca148/scikit_misc-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:4e46fd2e8c46625d1e69ea7fa6f4544d73203387e2601f2bbce82ff0a086ada1", size = 150692, upload-time = "2025-11-03T11:56:20.286Z" },
+]
+
 [[package]]
 name = "scipy"
 version = "1.16.3"
@@ -4947,6 +5281,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ce/69/c5c7807fd007dad4f48e0a5f2153038dc96e8725d3345b9ee31b2b7bed46/scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2", size = 25463014, upload-time = "2025-10-28T17:33:25.975Z" },
 ]
 
+[[package]]
+name = "scrublet"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annoy" },
+    { name = "cython" },
+    { name = "matplotlib" },
+    { name = "numba" },
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "scikit-image" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+    { name = "umap-learn" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bf/f8/52cecc93d2ac7b7ffe53662b60c34b2ad7f97eed7360e3d264080f8b1608/scrublet-0.2.3.tar.gz", hash = "sha256:2185f63070290267f82a36e5b4cae8c321f10415d2d0c9f7e5e97b1126bf653a", size = 15331, upload-time = "2020-12-29T03:02:03.561Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/74/82308f7bdcbda730b772a6d1afb6f55b9706601032126c4359afb3fb8986/scrublet-0.2.3-py3-none-any.whl", hash = "sha256:92b8a0206fc710b397c8dd535ac75d26242dea0976d8aa632e3765438b60478a", size = 15491, upload-time = "2020-12-29T03:02:02.62Z" },
+]
+
 [[package]]
 name = "seaborn"
 version = "0.13.2"
@@ -5006,6 +5361,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/49/65/dea992c6a97074f6d8ff9eab34741298cac2ce23e2b6c74fb7d08afdf85c/sentinels-1.1.1-py3-none-any.whl", hash = "sha256:835d3b28f3b47f5284afa4bf2db6e00f2dc5f80f9923d4b7e7aeeeccf6146a11", size = 3744, upload-time = "2025-08-12T07:57:48.858Z" },
 ]
 
+[[package]]
+name = "session-info2"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/45/4f/6333d79d97ccfea6d2199b7e666f8c53c5a31b64968c948a750a0b5c748a/session_info2-0.2.3.tar.gz", hash = "sha256:6d16e3c6bb72ea52e589da4d722d24798aa3511c34ab8446a131d655cba2e2c9", size = 23859, upload-time = "2025-10-09T12:51:28.07Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/b7/7d4c95c7b8525dabea23c548a1bb068d7a61635d544e8c92c51e784dad63/session_info2-0.2.3-py3-none-any.whl", hash = "sha256:f211d9930f73b485b727b6c4d8b964fa1b634351b3079393738f42be9b4c7f5e", size = 16347, upload-time = "2025-10-09T12:51:26.413Z" },
+]
+
 [[package]]
 name = "setuptools"
 version = "80.9.0"
@@ -5450,6 +5814,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" },
 ]
 
+[[package]]
+name = "texttable"
+version = "1.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/dc/0aff23d6036a4d3bf4f1d8c8204c5c79c4437e25e0ae94ffe4bbb55ee3c2/texttable-1.7.0.tar.gz", hash = "sha256:2d2068fb55115807d3ac77a4ca68fa48803e84ebb0ee2340f858107a36522638", size = 12831, upload-time = "2023-10-03T09:48:12.272Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/99/4772b8e00a136f3e01236de33b0efda31ee7077203ba5967fcc76da94d65/texttable-1.7.0-py2.py3-none-any.whl", hash = "sha256:72227d592c82b3d7f672731ae73e4d1f88cd8e2ef5b075a7a7f01a23a3743917", size = 10768, upload-time = "2023-10-03T09:48:10.434Z" },
+]
+
 [[package]]
 name = "thinc"
 version = "8.3.10"
@@ -5489,6 +5862,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },
 ]
 
+[[package]]
+name = "tifffile"
+version = "2025.12.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/31/b9/4253513a66f0a836ec3a5104266cf73f7812bfbbcda9d87d8c0e93b28293/tifffile-2025.12.12.tar.gz", hash = "sha256:97e11fd6b1d8dc971896a098c841d9cd4e6eb958ac040dd6fb8b332c3f7288b6", size = 373597, upload-time = "2025-12-13T03:42:53.765Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/5c/e444e1b024a519e488326525f0c154396c6b16baff17e00623f2c21dfc42/tifffile-2025.12.12-py3-none-any.whl", hash = "sha256:e3e3f1290ec6741ca248a5b5a997125209b5c2962f6bd9aef01ea9352c25d0ee", size = 232132, upload-time = "2025-12-13T03:42:52.072Z" },
+]
+
 [[package]]
 name = "tinycss2"
 version = "1.4.0"
@@ -5543,6 +5928,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/77/b8/0135fadc89e73be292b473cb820b4f5a08197779206b33191e801feeae40/tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b", size = 14408, upload-time = "2025-10-08T22:01:46.04Z" },
 ]
 
+[[package]]
+name = "toolz"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/11/d6/114b492226588d6ff54579d95847662fc69196bdeec318eb45393b24c192/toolz-1.1.0.tar.gz", hash = "sha256:27a5c770d068c110d9ed9323f24f1543e83b2f300a687b7891c1a6d56b697b5b", size = 52613, upload-time = "2025-10-17T04:03:21.661Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl", hash = "sha256:15ccc861ac51c53696de0a5d6d4607f99c210739caf987b5d2054f3efed429d8", size = 58093, upload-time = "2025-10-17T04:03:20.435Z" },
+]
+
 [[package]]
 name = "torch"
 version = "2.9.1"
@@ -5581,21 +5975,21 @@ wheels = [
 
 [[package]]
 name = "tornado"
-version = "6.5.3"
+version = "6.5.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7f/2e/3d22d478f27cb4b41edd4db7f10cd7846d0a28ea443342de3dba97035166/tornado-6.5.3.tar.gz", hash = "sha256:16abdeb0211796ffc73765bc0a20119712d68afeeaf93d1a3f2edf6b3aee8d5a", size = 513348, upload-time = "2025-12-11T04:16:42.225Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/37/1d/0a336abf618272d53f62ebe274f712e213f5a03c0b2339575430b8362ef2/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7", size = 513632, upload-time = "2025-12-15T19:21:03.836Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d3/e9/bf22f66e1d5d112c0617974b5ce86666683b32c09b355dfcd59f8d5c8ef6/tornado-6.5.3-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2dd7d7e8d3e4635447a8afd4987951e3d4e8d1fb9ad1908c54c4002aabab0520", size = 443860, upload-time = "2025-12-11T04:16:26.638Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/9c/594b631f0b8dc5977080c7093d1e96f1377c10552577d2c31bb0208c9362/tornado-6.5.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:5977a396f83496657779f59a48c38096ef01edfe4f42f1c0634b791dde8165d0", size = 442118, upload-time = "2025-12-11T04:16:28.32Z" },
-    { url = "https://files.pythonhosted.org/packages/78/f6/685b869f5b5b9d9547571be838c6106172082751696355b60fc32a4988ed/tornado-6.5.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f72ac800be2ac73ddc1504f7aa21069a4137e8d70c387172c063d363d04f2208", size = 445700, upload-time = "2025-12-11T04:16:29.64Z" },
-    { url = "https://files.pythonhosted.org/packages/91/4c/f0d19edf24912b7f21ae5e941f7798d132ad4d9b71441c1e70917a297265/tornado-6.5.3-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c43c4fc4f5419c6561cfb8b884a8f6db7b142787d47821e1a0e1296253458265", size = 445041, upload-time = "2025-12-11T04:16:30.799Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/2b/e02da94f4a4aef2bb3b923c838ef284a77548a5f06bac2a8682b36b4eead/tornado-6.5.3-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de8b3fed4b3afb65d542d7702ac8767b567e240f6a43020be8eaef59328f117b", size = 445270, upload-time = "2025-12-11T04:16:32.316Z" },
-    { url = "https://files.pythonhosted.org/packages/58/e2/7a7535d23133443552719dba526dacbb7415f980157da9f14950ddb88ad6/tornado-6.5.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dbc4b4c32245b952566e17a20d5c1648fbed0e16aec3fc7e19f3974b36e0e47c", size = 445957, upload-time = "2025-12-11T04:16:33.913Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/1f/9ff92eca81ff17a86286ec440dcd5eab0400326eb81761aa9a4eecb1ffb9/tornado-6.5.3-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:db238e8a174b4bfd0d0238b8cfcff1c14aebb4e2fcdafbf0ea5da3b81caceb4c", size = 445371, upload-time = "2025-12-11T04:16:35.093Z" },
-    { url = "https://files.pythonhosted.org/packages/70/b1/1d03ae4526a393b0b839472a844397337f03c7f3a1e6b5c82241f0e18281/tornado-6.5.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:892595c100cd9b53a768cbfc109dfc55dec884afe2de5290611a566078d9692d", size = 445348, upload-time = "2025-12-11T04:16:36.679Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/7d/7c181feadc8941f418d0d26c3790ee34ffa4bd0a294bc5201d44ebd19c1e/tornado-6.5.3-cp39-abi3-win32.whl", hash = "sha256:88141456525fe291e47bbe1ba3ffb7982549329f09b4299a56813923af2bd197", size = 446433, upload-time = "2025-12-11T04:16:38.332Z" },
-    { url = "https://files.pythonhosted.org/packages/34/98/4f7f938606e21d0baea8c6c39a7c8e95bdf8e50b0595b1bb6f0de2af7a6e/tornado-6.5.3-cp39-abi3-win_amd64.whl", hash = "sha256:ba4b513d221cc7f795a532c1e296f36bcf6a60e54b15efd3f092889458c69af1", size = 446842, upload-time = "2025-12-11T04:16:39.867Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/27/0e3fca4c4edf33fb6ee079e784c63961cd816971a45e5e4cacebe794158d/tornado-6.5.3-cp39-abi3-win_arm64.whl", hash = "sha256:278c54d262911365075dd45e0b6314308c74badd6ff9a54490e7daccdd5ed0ea", size = 445863, upload-time = "2025-12-11T04:16:41.099Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a9/e94a9d5224107d7ce3cc1fab8d5dc97f5ea351ccc6322ee4fb661da94e35/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9", size = 443909, upload-time = "2025-12-15T19:20:48.382Z" },
+    { url = "https://files.pythonhosted.org/packages/db/7e/f7b8d8c4453f305a51f80dbb49014257bb7d28ccb4bbb8dd328ea995ecad/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843", size = 442163, upload-time = "2025-12-15T19:20:49.791Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b5/206f82d51e1bfa940ba366a8d2f83904b15942c45a78dd978b599870ab44/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17", size = 445746, upload-time = "2025-12-15T19:20:51.491Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/9d/1a3338e0bd30ada6ad4356c13a0a6c35fbc859063fa7eddb309183364ac1/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335", size = 445083, upload-time = "2025-12-15T19:20:52.778Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d4/e51d52047e7eb9a582da59f32125d17c0482d065afd5d3bc435ff2120dc5/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f", size = 445315, upload-time = "2025-12-15T19:20:53.996Z" },
+    { url = "https://files.pythonhosted.org/packages/27/07/2273972f69ca63dbc139694a3fc4684edec3ea3f9efabf77ed32483b875c/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84", size = 446003, upload-time = "2025-12-15T19:20:56.101Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/83/41c52e47502bf7260044413b6770d1a48dda2f0246f95ee1384a3cd9c44a/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f", size = 445412, upload-time = "2025-12-15T19:20:57.398Z" },
+    { url = "https://files.pythonhosted.org/packages/10/c7/bc96917f06cbee182d44735d4ecde9c432e25b84f4c2086143013e7b9e52/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8", size = 445392, upload-time = "2025-12-15T19:20:58.692Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/1a/d7592328d037d36f2d2462f4bc1fbb383eec9278bc786c1b111cbbd44cfa/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1", size = 446481, upload-time = "2025-12-15T19:21:00.008Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/6d/c69be695a0a64fd37a97db12355a035a6d90f79067a3cf936ec2b1dc38cd/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc", size = 446886, upload-time = "2025-12-15T19:21:01.287Z" },
+    { url = "https://files.pythonhosted.org/packages/50/49/8dc3fd90902f70084bd2cd059d576ddb4f8bb44c2c7c0e33a11422acb17e/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1", size = 445910, upload-time = "2025-12-15T19:21:02.571Z" },
 ]
 
 [[package]]
@@ -5699,11 +6093,11 @@ wheels = [
 
 [[package]]
 name = "tzdata"
-version = "2025.2"
+version = "2025.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" },
 ]
 
 [[package]]
@@ -5718,6 +6112,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" },
 ]
 
+[[package]]
+name = "umap-learn"
+version = "0.5.9.post2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numba" },
+    { name = "numpy" },
+    { name = "pynndescent" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/ee/6bc65bd375c812026a7af63fe9d09d409382120aff25f2152f1ba12af5ec/umap_learn-0.5.9.post2.tar.gz", hash = "sha256:bdf60462d779bd074ce177a0714ced17e6d161285590fa487f3f9548dd3c31c9", size = 95441, upload-time = "2025-07-03T00:18:02.479Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/b1/c24deeda9baf1fd491aaad941ed89e0fed6c583a117fd7b79e0a33a1e6c0/umap_learn-0.5.9.post2-py3-none-any.whl", hash = "sha256:fbe51166561e0e7fab00ef3d516ac2621243b8d15cf4bef9f656d701736b16a0", size = 90146, upload-time = "2025-07-03T00:18:01.042Z" },
+]
+
 [[package]]
 name = "universal-pathlib"
 version = "0.3.7"
@@ -5980,6 +6391,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/d1/b51471c11592ff9c012bd3e2f7334a6ff2f42a7aed2caffcf0bdddc9cb89/wrapt-2.0.1-py3-none-any.whl", hash = "sha256:4d2ce1bf1a48c5277d7969259232b57645aae5686dba1eaeade39442277afbca", size = 44046, upload-time = "2025-11-07T00:45:32.116Z" },
 ]
 
+[[package]]
+name = "xarray"
+version = "2025.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pandas" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d3/af/7b945f331ba8911fdfff2fdfa092763156119f124be1ba4144615c540222/xarray-2025.12.0.tar.gz", hash = "sha256:73f6a6fadccc69c4d45bdd70821a47c72de078a8a0313ff8b1e97cd54ac59fed", size = 3082244, upload-time = "2025-12-05T21:51:22.432Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/e4/62a677feefde05b12a70a4fc9bdc8558010182a801fbcab68cb56c2b0986/xarray-2025.12.0-py3-none-any.whl", hash = "sha256:9e77e820474dbbe4c6c2954d0da6342aa484e33adaa96ab916b15a786181e970", size = 1381742, upload-time = "2025-12-05T21:51:20.841Z" },
+]
+
 [[package]]
 name = "yarl"
 version = "1.22.0"

From 87ac49d7a304757c8b2e07c49138aef3880255cc Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Fri, 19 Dec 2025 12:53:51 -0800
Subject: [PATCH 26/87] initial add

---
 CLAUDE.md | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 CLAUDE.md

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..7512e7a
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,82 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is an open-source book on building better code for science using AI, authored by Russell Poldrack. The rendered book is published at https://poldrack.github.io/BetterCodeBetterScience/.
+
+## Build Commands
+
+```bash
+# Install dependencies (uses uv package manager)
+uv pip install -r pyproject.toml
+uv pip install -e .
+
+# Build book as HTML and serve locally
+myst build --html
+npx serve _build/html
+
+# Build PDF (requires LaTeX)
+jupyter-book build book/ --builder pdflatex
+
+# Clean build artifacts
+rm -rf book/_build
+```
+
+## Testing
+
+```bash
+# Run all tests
+pytest
+
+# Run tests with coverage
+pytest --cov=src/BetterCodeBetterScience --cov-report term-missing
+
+# Run specific test modules
+pytest tests/textmining/
+pytest tests/property_based_testing/
+pytest tests/narps/
+
+# Run tests with specific markers
+pytest -m unit
+pytest -m integration
+```
+
+Test markers defined in pyproject.toml: `unit` and `integration`.
+
+## Linting and Code Quality
+
+```bash
+# Spell checking (configured in pyproject.toml)
+codespell
+
+# Python linting and formatting
+ruff check .
+ruff format .
+
+# Pre-commit hooks (runs codespell)
+pre-commit run --all-files
+```
+
+## Project Structure
+
+- `book/` - MyST markdown chapters (configured in myst.yml)
+- `src/BetterCodeBetterScience/` - Example Python code referenced in book chapters
+- `tests/` - Test examples demonstrating testing concepts from the book
+- `data/` - Data files for examples
+- `scripts/` - Utility scripts
+- `_build/` - Build output (gitignored)
+
+## Key Configuration Files
+
+- `myst.yml` - MyST book configuration (table of contents, exports, site settings)
+- `pyproject.toml` - Python dependencies, pytest config, codespell settings
+- `.pre-commit-config.yaml` - Pre-commit hooks (codespell)
+
+## Contribution Guidelines
+
+- New text should be authored by a human (AI may be used to check/improve text)
+- Code examples should follow PEP8
+- Avoid introducing new dependencies when possible
+- Custom words for codespell are in `project-words.txt`

From 0541df3198752d857b3f2c97002b647f6e1c25e1 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 20 Dec 2025 12:23:10 -0800
Subject: [PATCH 27/87] initial add

---
 .../rnaseq/immune_scrnaseq_1_dataprep.ipynb   |  406 ++++
 .../rnaseq/immune_scrnaseq_2_preprocess.ipynb | 1984 +++++++++++++++++
 2 files changed, 2390 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_1_dataprep.ipynb
 create mode 100644 src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_2_preprocess.ipynb

diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_1_dataprep.ipynb b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_1_dataprep.ipynb
new file mode 100644
index 0000000..3fbe4cb
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_1_dataprep.ipynb
@@ -0,0 +1,406 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b317a9e1",
+   "metadata": {},
+   "source": [
+    "### Immune system gene expression and aging\n",
+    "\n",
+    "We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total.  These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants.  \n",
+    "\n",
+    "The flagship paper for this study is:\n",
+    "\n",
+    "Yazar S., Alquicira-Hernández J., Wing K., Senabouth A., Gordon G., Andersen S., Lu Q., Rowson A., Taylor T., Clarke L., Maccora L., Chen C., Cook A., Ye J., Fairfax K., Hewitt A., Powell J. Single cell eQTL mapping identified cell type specific control of autoimmune disease. Science, 376, 6589 (2022)\n",
+    "\n",
+    "We will use the data to ask a simple question: how does gene expression in PBMCs change with age?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "0d3385e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import anndata as ad\n",
+    "from anndata.experimental import read_lazy\n",
+    "import dask.array as da\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "import scanpy as sc\n",
+    "from pathlib import Path\n",
+    "import os\n",
+    "\n",
+    "datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "7b67c0b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datafile = datadir / 'a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'\n",
+    "url = 'https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'\n",
+    "dataset_name = 'OneK1K'\n",
+    "\n",
+    "if not datafile.exists():\n",
+    "    cmd = f'wget -O {datafile.as_posix()} {url}'\n",
+    "    print(f'Downloading data from {url} to {datafile.as_posix()}')\n",
+    "    os.system(cmd)\n",
+    "\n",
+    "load_annotation_index = True\n",
+    "adata = read_lazy(h5py.File(datafile, 'r'),\n",
+    "    load_annotation_index=load_annotation_index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "40d53939",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AnnData object with n_obs × n_vars = 1248980 × 35528\n",
+      "    obs: 'orig.ident', 'nCount_RNA', 'nFeature_RNA', 'percent.mt', 'donor_id', 'pool_number', 'predicted.celltype.l2', 'predicted.celltype.l2.score', 'age', 'tissue_ontology_term_id', 'assay_ontology_term_id', 'disease_ontology_term_id', 'cell_type_ontology_term_id', 'self_reported_ethnicity_ontology_term_id', 'development_stage_ontology_term_id', 'sex_ontology_term_id', 'is_primary_data', 'suspension_type', 'tissue_type', 'cell_type', 'assay', 'disease', 'sex', 'tissue', 'self_reported_ethnicity', 'development_stage', 'observation_joinid'\n",
+      "    var: 'vst.mean', 'vst.variance', 'vst.variance.expected', 'vst.variance.standardized', 'vst.variable', 'feature_is_filtered', 'feature_name', 'feature_reference', 'feature_biotype', 'feature_length', 'feature_type'\n",
+      "    uns: 'cell_type_ontology_term_id_colors', 'citation', 'default_embedding', 'organism', 'organism_ontology_term_id', 'schema_reference', 'schema_version', 'title'\n",
+      "    obsm: 'X_azimuth_spca', 'X_azimuth_umap', 'X_harmony', 'X_pca', 'X_umap'\n",
+      "    varm: 'PCs'\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(adata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "7eeca179",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['CD14-low, CD16-positive monocyte' 'CD14-positive monocyte'\n",
+      " 'CD16-negative, CD56-bright natural killer cell, human'\n",
+      " 'CD4-positive, alpha-beta T cell'\n",
+      " 'CD4-positive, alpha-beta cytotoxic T cell'\n",
+      " 'CD8-positive, alpha-beta T cell'\n",
+      " 'central memory CD4-positive, alpha-beta T cell'\n",
+      " 'central memory CD8-positive, alpha-beta T cell'\n",
+      " 'conventional dendritic cell' 'dendritic cell'\n",
+      " 'double negative thymocyte'\n",
+      " 'effector memory CD4-positive, alpha-beta T cell'\n",
+      " 'effector memory CD8-positive, alpha-beta T cell' 'erythrocyte'\n",
+      " 'gamma-delta T cell' 'hematopoietic precursor cell'\n",
+      " 'innate lymphoid cell' 'memory B cell' 'mucosal invariant T cell'\n",
+      " 'naive B cell' 'naive thymus-derived CD4-positive, alpha-beta T cell'\n",
+      " 'naive thymus-derived CD8-positive, alpha-beta T cell'\n",
+      " 'natural killer cell' 'peripheral blood mononuclear cell' 'plasmablast'\n",
+      " 'plasmacytoid dendritic cell' 'platelet' 'regulatory T cell'\n",
+      " 'transitional stage B cell']\n"
+     ]
+    }
+   ],
+   "source": [
+    "unique_cell_types = np.unique(adata.obs['cell_type'])\n",
+    "print(unique_cell_types)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c763a5e1",
+   "metadata": {},
+   "source": [
+    "### Filtering out bad donors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "a0e4918c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Donor Cell Count Statistics:\n",
+      "count     981.000000\n",
+      "mean     1273.170234\n",
+      "std       322.280557\n",
+      "min       333.000000\n",
+      "25%      1070.000000\n",
+      "50%      1246.000000\n",
+      "75%      1446.000000\n",
+      "max      3511.000000\n",
+      "Name: count, dtype: float64\n",
+      "cutoff of 894 would exclude 98 donors\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "from scipy.stats import scoreatpercentile\n",
+    "\n",
+    "# 1. Calculate how many cells each donor has\n",
+    "donor_cell_counts = pd.Series(adata.obs['donor_id']).value_counts()\n",
+    "\n",
+    "# Print some basic statistics to read the exact numbers\n",
+    "print(\"Donor Cell Count Statistics:\")\n",
+    "print(donor_cell_counts.describe())\n",
+    "\n",
+    "# 2. Plot the histogram\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "# Bins set to 'auto' or a fixed number depending on your N of donors\n",
+    "plt.hist(donor_cell_counts.values, bins=50, color='skyblue', edgecolor='black')\n",
+    "\n",
+    "plt.title('Distribution of Total Cells per Donor')\n",
+    "plt.xlabel('Number of Cells Captured')\n",
+    "plt.ylabel('Number of Donors')\n",
+    "plt.grid(axis='y', alpha=0.5)\n",
+    "\n",
+    "# Optional: Draw a vertical line at the propsoed cutoff\n",
+    "# This helps you visualize how many donors you would lose.\n",
+    "cutoff_percentile = 10  # e.g., 10th percentile\n",
+    "min_cells_per_donor = int(scoreatpercentile(donor_cell_counts.values, cutoff_percentile))\n",
+    "print(f'cutoff of {min_cells_per_donor} would exclude {(donor_cell_counts < min_cells_per_donor).sum()} donors')\n",
+    "plt.axvline(min_cells_per_donor, color='red', linestyle='dashed', linewidth=1, label=f'Cutoff ({min_cells_per_donor} cells)')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "8ad05821",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Filtering to keep only donors with at least 894 cells.\n",
+      "Number of donors excluded: 98\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Filtering to keep only donors with at least {min_cells_per_donor} cells.\")\n",
+    "print(f\"Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}\")\n",
+    "valid_donors = donor_cell_counts[donor_cell_counts >= min_cells_per_donor].index\n",
+    "adata = adata[adata.obs['donor_id'].isin(valid_donors)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "5a5e8f9b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of donors after filtering: 883\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'Number of donors after filtering: {len(valid_donors)}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81b16da4",
+   "metadata": {},
+   "source": [
+    "### Filtering cell types by frequency\n",
+    "\n",
+    "Drop cell types that don't have at least 10 cells for at least 95% of people"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "00dff55b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Keeping 8 cell types out of 29\n",
+      "Cell types to keep: ['central memory CD4-positive, alpha-beta T cell', 'effector memory CD4-positive, alpha-beta T cell', 'effector memory CD8-positive, alpha-beta T cell', 'memory B cell', 'naive B cell', 'naive thymus-derived CD4-positive, alpha-beta T cell', 'natural killer cell', 'regulatory T cell']\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "# 1. Calculate the count of cells for each 'cell_type' within each 'donor_id'\n",
+    "# We use pandas crosstab on adata.obs, which is loaded in memory.\n",
+    "counts_per_donor = pd.crosstab(adata.obs['donor_id'], adata.obs['cell_type'])\n",
+    "\n",
+    "# 2. Identify cell types to keep\n",
+    "# Keep if >= 10 cells in at least 90% of donors\n",
+    "\n",
+    "min_cells = 10\n",
+    "percent_donors = 0.9\n",
+    "donor_count = counts_per_donor.shape[0]\n",
+    "cell_types_to_keep = counts_per_donor.columns[\n",
+    "    (counts_per_donor >= min_cells).sum(axis=0) >= (donor_count * percent_donors)]\n",
+    "\n",
+    "print(f\"Keeping {len(cell_types_to_keep)} cell types out of {len(counts_per_donor.columns)}\")\n",
+    "print(f\"Cell types to keep: {cell_types_to_keep.tolist()}\")\n",
+    "\n",
+    "# 3. Filter the AnnData object\n",
+    "# We subset the AnnData to include only observations belonging to the valid cell types.\n",
+    "adata_filtered = adata[adata.obs['cell_type'].isin(cell_types_to_keep)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "ba931464",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Final number of donors after filtering: 698\n"
+     ]
+    }
+   ],
+   "source": [
+    "# now drop subjects who have any zeros in these cell types\n",
+    "donor_celltype_counts = pd.crosstab(adata_filtered.obs['donor_id'], adata_filtered.obs['cell_type'])\n",
+    "valid_donors_final = donor_celltype_counts.index[\n",
+    "    (donor_celltype_counts >= min_cells).all(axis=1)]\n",
+    "adata_filtered = adata_filtered[adata_filtered.obs['donor_id'].isin(valid_donors_final)]\n",
+    "print(f\"Final number of donors after filtering: {len(valid_donors_final)}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "f741845e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading data into memory (this can take a few minutes)...\n",
+      "Filtering genes with zero counts...\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "print(\"Loading data into memory (this can take a few minutes)...\")\n",
+    "adata_loaded = adata_filtered.to_memory()\n",
+    "\n",
+    "# filter out genes with zero counts across all selected cells\n",
+    "print(\"Filtering genes with zero counts...\")\n",
+    "sc.pp.filter_genes(adata_loaded, min_counts=1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "310f8343",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AnnData object with n_obs × n_vars = 785021 × 29331\n",
+      "    obs: 'orig.ident', 'nCount_RNA', 'nFeature_RNA', 'percent.mt', 'donor_id', 'pool_number', 'predicted.celltype.l2', 'predicted.celltype.l2.score', 'age', 'tissue_ontology_term_id', 'assay_ontology_term_id', 'disease_ontology_term_id', 'cell_type_ontology_term_id', 'self_reported_ethnicity_ontology_term_id', 'development_stage_ontology_term_id', 'sex_ontology_term_id', 'is_primary_data', 'suspension_type', 'tissue_type', 'cell_type', 'assay', 'disease', 'sex', 'tissue', 'self_reported_ethnicity', 'development_stage', 'observation_joinid'\n",
+      "    var: 'vst.mean', 'vst.variance', 'vst.variance.expected', 'vst.variance.standardized', 'vst.variable', 'feature_is_filtered', 'feature_name', 'feature_reference', 'feature_biotype', 'feature_length', 'feature_type', 'n_counts'\n",
+      "    uns: 'citation', 'default_embedding', 'organism', 'organism_ontology_term_id', 'schema_reference', 'schema_version', 'title'\n",
+      "    obsm: 'X_azimuth_spca', 'X_azimuth_umap', 'X_harmony', 'X_pca', 'X_umap'\n",
+      "    varm: 'PCs'\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(adata_loaded)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "ecb61446",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adata_loaded.write(datadir /  f'dataset-{dataset_name}_subset-immune_filtered.h5ad')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "10b6c9e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "total 22022184\n",
+      "-rw-r--r--@ 1 poldrack  staff   4.1G Dec 19 09:03 a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad\n",
+      "-rw-r--r--@ 1 poldrack  staff   6.4G Dec 20 09:36 dataset-OneK1K_subset-immune_filtered.h5ad\n",
+      "-rw-r--r--  1 poldrack  staff   185B Dec 19 09:02 get_data.sh\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh /Users/poldrack/data_unsynced/BCBS/immune_aging"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "BetterCodeBetterScience",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_2_preprocess.ipynb b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_2_preprocess.ipynb
new file mode 100644
index 0000000..02a3b5e
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_2_preprocess.ipynb
@@ -0,0 +1,1984 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c3333c8c",
+   "metadata": {},
+   "source": [
+    "Preprocessing based on suggestions from Google Gemini\n",
+    "\n",
+    "based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html\n",
+    "\n",
+    "and https://www.10xgenomics.com/analysis-guides/common-considerations-for-quality-control-filters-for-single-cell-rna-seq-data\n",
+    "\n",
+    "Code in this notebook primarily generated using Gemini 3.0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "5e94c5f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import anndata as ad\n",
+    "import dask.array as da\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "import scanpy as sc\n",
+    "from pathlib import Path\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3c5b35d2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AnnData object with n_obs × n_vars = 785021 × 29331\n",
+      "    obs: 'orig.ident', 'nCount_RNA', 'nFeature_RNA', 'percent.mt', 'donor_id', 'pool_number', 'predicted.celltype.l2', 'predicted.celltype.l2.score', 'age', 'tissue_ontology_term_id', 'assay_ontology_term_id', 'disease_ontology_term_id', 'cell_type_ontology_term_id', 'self_reported_ethnicity_ontology_term_id', 'development_stage_ontology_term_id', 'sex_ontology_term_id', 'is_primary_data', 'suspension_type', 'tissue_type', 'cell_type', 'assay', 'disease', 'sex', 'tissue', 'self_reported_ethnicity', 'development_stage', 'observation_joinid'\n",
+      "    var: 'vst.mean', 'vst.variance', 'vst.variance.expected', 'vst.variance.standardized', 'vst.variable', 'feature_is_filtered', 'feature_name', 'feature_reference', 'feature_biotype', 'feature_length', 'feature_type', 'n_counts'\n",
+      "    uns: 'citation', 'default_embedding', 'organism', 'organism_ontology_term_id', 'schema_reference', 'schema_version', 'title'\n",
+      "    obsm: 'X_azimuth_spca', 'X_azimuth_umap', 'X_harmony', 'X_pca', 'X_umap'\n",
+      "    varm: 'PCs'\n"
+     ]
+    }
+   ],
+   "source": [
+    "adata = ad.read_h5ad(datadir / 'dataset-OneK1K_subset-immune_filtered.h5ad')\n",
+    "print(adata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "003237c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "var_to_feature = dict(zip(adata.var_names, adata.var['feature_name']))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca1edf40",
+   "metadata": {},
+   "source": [
+    "### Quality control\n",
+    "\n",
+    "based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a95e8baa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of mitochondrial genes: 13\n",
+      "Number of ribosomal genes: 107\n",
+      "Number of hemoglobin genes: 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "# mitochondrial genes\n",
+    "adata.var[\"mt\"] = adata.var['feature_name'].str.startswith(\"MT-\")\n",
+    "print(f\"Number of mitochondrial genes: {adata.var['mt'].sum()}\")\n",
+    "\n",
+    "# ribosomal genes\n",
+    "adata.var[\"ribo\"] = adata.var['feature_name'].str.startswith((\"RPS\", \"RPL\"))\n",
+    "print(f\"Number of ribosomal genes: {adata.var['ribo'].sum()}\")\n",
+    "\n",
+    "# hemoglobin genes.\n",
+    "adata.var[\"hb\"] = adata.var['feature_name'].str.contains(\"^HB[^(P)]\")\n",
+    "print(f\"Number of hemoglobin genes: {adata.var['hb'].sum()}\")\n",
+    "\n",
+    "sc.pp.calculate_qc_metrics(\n",
+    "    adata, qc_vars=[\"mt\", \"ribo\", \"hb\"], inplace=True, percent_top=[20], log1p=True\n",
+    ")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c79181f1",
+   "metadata": {},
+   "source": [
+    "#### Visualization of distributions "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a4819733",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1511.11x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 810.02x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "# 1. Violin plots to see the distribution of QC metrics\n",
+    "# Note: I am using the exact column names from your adata output\n",
+    "p1 = sc.pl.violin(adata, ['total_counts', 'n_genes_by_counts', 'pct_counts_mt'],\n",
+    "             jitter=0.4, multi_panel=True)\n",
+    "\n",
+    "# 2. Scatter plot to spot doublets and dying cells\n",
+    "# High mito + low genes = dying cell\n",
+    "# High counts + high genes = potential doublet\n",
+    "sc.pl.scatter(adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f44acde9",
+   "metadata": {},
+   "source": [
+    "####  Check Hemoglobin (RBC contamination)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "73d83421",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.figure(figsize=(6, 4))\n",
+    "sns.histplot(adata.obs['pct_counts_hb'], bins=50, log_scale=(False, True)) # Log scale y to see small RBC populations\n",
+    "plt.title(\"Hemoglobin Content Distribution\")\n",
+    "plt.xlabel(\"% Hemoglobin Counts\")\n",
+    "plt.axvline(5, color='red', linestyle='--', label='5% Cutoff')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dabf25b2",
+   "metadata": {},
+   "source": [
+    "#### Create a copy of the data and apply QC cutoffs\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "be603387",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before filtering: 785021 cells\n",
+      "After filtering: 784929 cells\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create a copy or view to avoid modifying the original if needed\n",
+    "adata_qc = adata.copy()\n",
+    "\n",
+    "# --- Define Thresholds ---\n",
+    "# Low quality (Empty droplets / debris)\n",
+    "min_genes = 200       # Standard for immune cells (T-cells can be small)\n",
+    "min_counts = 500      # Minimum UMIs\n",
+    "\n",
+    "# Doublets (Two cells stuck together)\n",
+    "# Adjust this based on the scatter plot above. \n",
+    "# 4000-6000 is common for 10x Genomics data.\n",
+    "max_genes = 6000      \n",
+    "max_counts = 30000    # Very high counts often indicate doublets\n",
+    "\n",
+    "# Contaminants\n",
+    "max_hb_pct = 5.0      # Remove Red Blood Cells (> 5% hemoglobin)\n",
+    "\n",
+    "# --- Apply Filtering ---\n",
+    "print(f\"Before filtering: {adata_qc.n_obs} cells\")\n",
+    "\n",
+    "# 1. Filter Low Quality & Doublets\n",
+    "adata_qc = adata_qc[\n",
+    "    (adata_qc.obs['n_genes_by_counts'] > min_genes) &\n",
+    "    (adata_qc.obs['n_genes_by_counts'] < max_genes) &\n",
+    "    (adata_qc.obs['total_counts'] > min_counts) &\n",
+    "    (adata_qc.obs['total_counts'] < max_counts)\n",
+    "]\n",
+    "\n",
+    "# 2. Filter Red Blood Cells (Hemoglobin)\n",
+    "# Only run this if you want to remove RBCs\n",
+    "adata_qc = adata_qc[adata_qc.obs['pct_counts_hb'] < max_hb_pct]\n",
+    "\n",
+    "print(f\"After filtering: {adata_qc.n_obs} cells\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "faa4a504",
+   "metadata": {},
+   "source": [
+    "### Perform doublet detection\n",
+    "\n",
+    "According to Gemini:\n",
+    "\n",
+    "You must do this before normalization or clustering because doublets create \"hybrid\" expression profiles that can form fake clusters (e.g., a \"cluster\" that looks like a mix of T-cells and B-cells) or distort your normalization factors.\n",
+    "\n",
+    "**Important: Run Per Donor**\n",
+    "\n",
+    "Since you have multiple people, you must run doublet detection separately for each donor. The doublet rate is a technical artifact of the physical loading of the machine (10x Genomics chip), which varies per run. If you run it on the whole dataset at once, the algorithm will get confused by biological differences between people.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7c89ced5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data shape before doublet detection: (784929, 29331)\n",
+      "Running Scrublet on 698 donors...\n",
+      "Detected 7335 doublets across all donors.\n",
+      "predicted_doublet\n",
+      "False    777594\n",
+      "True       7335\n",
+      "Name: count, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# 1. Check preliminary requirements\n",
+    "# Scrublet needs RAW counts. Ensure adata.X contains integers, not log-normalized data.\n",
+    "# If your main layer is already normalized, use adata.raw or a specific layer.\n",
+    "print(f\"Data shape before doublet detection: {adata_qc.shape}\")\n",
+    "\n",
+    "# 2. Run Scrublet per donor\n",
+    "# We split the data, run detection, and then recombine.\n",
+    "# This prevents the algorithm from comparing a cell from Person A to a cell from Person B.\n",
+    "\n",
+    "adatas_list = []\n",
+    "# Get list of unique donors\n",
+    "donors = adata_qc.obs['donor_id'].unique()\n",
+    "\n",
+    "print(f\"Running Scrublet on {len(donors)} donors...\")\n",
+    "\n",
+    "for donor in donors:\n",
+    "    # Subset to current donor\n",
+    "    curr_adata = adata_qc[adata_qc.obs['donor_id'] == donor].copy()\n",
+    "    \n",
+    "    # Skip donors with too few cells (Scrublet needs statistical power)\n",
+    "    if curr_adata.n_obs < 100:\n",
+    "        print(f\"Skipping donor {donor}: too few cells ({curr_adata.n_obs})\")\n",
+    "        # We still add it back to keep the data, but mark as singlet (or filter later)\n",
+    "        curr_adata.obs['doublet_score'] = 0\n",
+    "        curr_adata.obs['predicted_doublet'] = False\n",
+    "        adatas_list.append(curr_adata)\n",
+    "        continue\n",
+    "\n",
+    "    # Run Scrublet\n",
+    "    # expected_doublet_rate=0.06 is standard for 10x (approx ~0.8% per 1000 cells recovered)\n",
+    "    # If you loaded very heavily (20k cells/well), increase this to 0.10\n",
+    "    sc.pp.scrublet(curr_adata, expected_doublet_rate=0.06)\n",
+    "    \n",
+    "    adatas_list.append(curr_adata)\n",
+    "\n",
+    "# 3. Merge back into one object\n",
+    "adata_qc = sc.concat(adatas_list)\n",
+    "\n",
+    "# 4. Check results\n",
+    "print(f\"Detected {adata_qc.obs['predicted_doublet'].sum()} doublets across all donors.\")\n",
+    "print(adata_qc.obs['predicted_doublet'].value_counts())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04d2984a",
+   "metadata": {},
+   "source": [
+    "#### Visualize doublets\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5882e417",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1455.6x480 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sc.pl.umap(adata_qc, color=['doublet_score', 'predicted_doublet'], size=20)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "25f6e3fb",
+   "metadata": {},
+   "source": [
+    "#### Filter doublets\n",
+    "- Question: how consistent are these results with other methods for doublet detection? https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html#doublet-detection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "dd9b6443",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "found 7335 predicted doublets\n",
+      "Remaining cells: 777594\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Check how many doublets were found\n",
+    "print(f'found {adata_qc.obs[\"predicted_doublet\"].sum()} predicted doublets')\n",
+    "\n",
+    "# Filter the data to keep only singlets (False)\n",
+    "# write back to adata for simplicity\n",
+    "adata = adata_qc[adata_qc.obs['predicted_doublet'] == False, :]\n",
+    "print(f\"Remaining cells: {adata.n_obs}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71f3bbaa",
+   "metadata": {},
+   "source": [
+    "#### Save raw counts for later use"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "00da60cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/r2/f85nyfr1785fj4257wkdj7480000gn/T/ipykernel_48619/871672687.py:2: ImplicitModificationWarning: Setting element `.layers['counts']` of view, initializing view as actual.\n",
+      "  adata.layers['counts'] = adata.X.copy()\n"
+     ]
+    }
+   ],
+   "source": [
+    "#  set the .raw attribute (standard Scanpy convention)\n",
+    "adata.layers['counts'] = adata.X.copy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d97842a3",
+   "metadata": {},
+   "source": [
+    "### Total Count Normalization\n",
+    "This scales each cell so that they all have the same total number of counts (default is often 10,000, known as \"CP10k\")."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2d2d9b0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Normalize to 10,000 reads per cell\n",
+    "# target_sum=1e4 is the standard for 10x data\n",
+    "sc.pp.normalize_total(adata, target_sum=1e4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0efc2045",
+   "metadata": {},
+   "source": [
+    "### Log Transformation (Log1p)\n",
+    "This applies a natural logarithm to the data:  log(X+1). This reduces the skewness of the data (since gene expression follows a power law) and stabilizes the variance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d412ddd8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Logarithmically transform the data\n",
+    "sc.pp.log1p(adata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd5a1cde",
+   "metadata": {},
+   "source": [
+    "### select high-variance features\n",
+    "\n",
+    "according to Gemini:\n",
+    "For a large immune dataset (PBMCs, ~1.2M cells), the standard defaults often fail to capture the subtle biological variation needed to distinguish similar cell types (like CD4+ T-cell subsets).\n",
+    "\n",
+    "Here are the reasonable parameters and, more importantly, the **immune-specific strategy** you should use.\n",
+    "\n",
+    "#### The Recommended Parameters\n",
+    "\n",
+    "For a dataset of your size, the **`seurat_v3`** flavor is generally superior because it selects genes based on standardized variance (handling the mean-variance relationship better than the dispersion-based method).\n",
+    "\n",
+    "*   **`flavor`**: `'seurat_v3'` (Requires **RAW integer counts** in `adata.X` or a layer)\n",
+    "*   **`n_top_genes`**: **2000 - 3000** (3000 is safer for immune data to capture rare cytokines/markers)\n",
+    "*   **`batch_key`**: **`'donor_id'`** (CRITICAL)\n",
+    "    *   *Why?* With 1.2M cells across many people, you have massive batch effects. If you don't set this, \"highly variable genes\" will just be the genes that differ between Person A and Person B (e.g., HLA genes, gender-specific genes like XIST/RPS4Y1), rather than genes distinguishing cell types.\n",
+    "\n",
+    "#### The \"Expert\" Trick: Blocklisting Nuisance Genes\n",
+    "In immune datasets, \"highly variable\" does not always mean \"biologically interesting.\" You often need to **exclude** specific gene families from the HVG list *after* calculation but *before* PCA, or they will hijack your clustering:\n",
+    "1.  **TCR/BCR Variable Regions (IG*, TR*):** These are hyper-variable by definition (V(D)J recombination). If you keep them, T-cells will cluster by **clone** (clonotype) rather than by **phenotype** (state).\n",
+    "2.  **Mitochondrial/Ribosomal:** Usually technical noise.\n",
+    "3.  **Cell Cycle:** (Optional) If you don't want proliferating cells to cluster separately.\n",
+    "\n",
+    "\n",
+    "\n",
+    "#### Why 3000 genes instead of 2000?\n",
+    "Immune cells are dense with specific markers. The difference between a *Naive CD8 T-cell* and a *Central Memory CD8 T-cell* might rest on a handful of genes (e.g., *CCR7, SELL, IL7R* vs *GZMK*). If you limit to 2000 genes in a massive, diverse dataset, you might accidentally drop a subtle marker required to resolve these fine-grained states."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5a64c2c4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Blocked 0 immune receptor genes from HVG list.\n",
+      "Final HVG count: 3000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/poldrack/Dropbox/code/BetterCodeBetterScience/.venv/lib/python3.12/site-packages/scanpy/preprocessing/_pca/__init__.py:226: FutureWarning: Argument `use_highly_variable` is deprecated, consider using the mask argument. Use_highly_variable=True can be called through mask_var=\"highly_variable\". Use_highly_variable=False can be called through mask_var=None\n",
+      "  mask_var_param, mask_var = _handle_mask_var(\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "import scanpy as sc\n",
+    "import pandas as pd\n",
+    "\n",
+    "\n",
+    "# 2. Run Highly Variable Gene Selection\n",
+    "# batch_key is critical here to find genes variable WITHIN donors, not BETWEEN them.\n",
+    "sc.pp.highly_variable_genes(\n",
+    "    adata,\n",
+    "    n_top_genes=3000,\n",
+    "    flavor='seurat_v3',\n",
+    "    batch_key='donor_id',\n",
+    "    span=0.8,  # helps avoid numerical issues with LOESS\n",
+    "    layer='counts',  # Change this to None if adata.X is raw counts\n",
+    "    subset=False     # Keep False so we can manually filter the list below\n",
+    ")\n",
+    "\n",
+    "# 3. Filter out \"Nuisance\" Genes from the HVG list\n",
+    "# We don't remove the genes from the object, we just set their 'highly_variable' status to False\n",
+    "# so they aren't used in PCA.\n",
+    "\n",
+    "# A. Identify TCR/BCR genes (starts with IG or TR)\n",
+    "# Regex: IG or TR followed by a V, D, J, or C gene part\n",
+    "import re\n",
+    "immune_receptor_genes = [\n",
+    "    name for name in adata.var_names \n",
+    "    if re.match(r'^(IG[HKL]|TR[ABDG])[VDJC]', name)\n",
+    "]\n",
+    "\n",
+    "# B. Identify Ribosomal/Mitochondrial (if not already handled)\n",
+    "mt_genes = adata.var_names[adata.var_names.str.startswith('MT-')]\n",
+    "rb_genes = adata.var_names[adata.var_names.str.startswith(('RPS', 'RPL'))]\n",
+    "\n",
+    "# C. Manually set them to False\n",
+    "genes_to_block = list(immune_receptor_genes) + list(mt_genes) + list(rb_genes)\n",
+    "\n",
+    "# Using set operations for speed\n",
+    "adata.var.loc[adata.var_names.isin(genes_to_block), 'highly_variable'] = False\n",
+    "\n",
+    "print(f\"Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.\")\n",
+    "print(f\"Final HVG count: {adata.var['highly_variable'].sum()}\")\n",
+    "\n",
+    "# 4. Proceed to PCA\n",
+    "sc.tl.pca(adata, svd_solver='arpack', use_highly_variable=True)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2055120b",
+   "metadata": {},
+   "source": [
+    "### Dimensionality reduction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "93802dfb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-12-20 10:37:58,784 - harmonypy - INFO - Computing initial centroids with sklearn.KMeans...\n",
+      "2025-12-20 10:38:23,074 - harmonypy - INFO - sklearn.KMeans initialization complete.\n",
+      "2025-12-20 10:38:25,994 - harmonypy - INFO - Iteration 1 of 10\n",
+      "2025-12-20 10:49:03,832 - harmonypy - INFO - Iteration 2 of 10\n",
+      "2025-12-20 10:59:50,478 - harmonypy - INFO - Iteration 3 of 10\n",
+      "2025-12-20 11:10:24,641 - harmonypy - INFO - Iteration 4 of 10\n",
+      "2025-12-20 11:20:50,945 - harmonypy - INFO - Iteration 5 of 10\n",
+      "2025-12-20 11:30:24,097 - harmonypy - INFO - Converged after 5 iterations\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Harmony integration successful. Using corrected PCA.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import scanpy.external as sce\n",
+    "\n",
+    "# 1. Run Harmony\n",
+    "# This adjusts the PCA coordinates to mix donors together while preserving biology.\n",
+    "# It creates a new entry in obsm: 'X_pca_harmony'\n",
+    "try:\n",
+    "    sce.pp.harmony_integrate(adata, key='donor_id', basis='X_pca', adjusted_basis='X_pca_harmony')\n",
+    "    use_rep = 'X_pca_harmony'\n",
+    "    print(\"Harmony integration successful. Using corrected PCA.\")\n",
+    "except ImportError:\n",
+    "    print(\"Harmony not installed. Proceeding with standard PCA (Warning: Batch effects may persist).\")\n",
+    "    print(\"To install: pip install harmony-pytorch\")\n",
+    "    use_rep = 'X_pca'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "55f80ce1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1455.6x480 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Reality check: Check if PC1 is just \"Cell Size\":\n",
+    "\n",
+    "sc.pl.pca(adata, color=['total_counts', 'cell_type'], components=['1,2'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "406256c8",
+   "metadata": {},
+   "source": [
+    "PC1 separates cell types and isn't driven only by the number of cells."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "5cde35ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 2. Compute Neighbors\n",
+    "# n_neighbors: 15-30 is standard. Higher (30-50) is better for large datasets to preserve global structure.\n",
+    "# n_pcs: 30-50 is standard.\n",
+    "sc.pp.neighbors(adata, n_neighbors=30, n_pcs=40, use_rep=use_rep)\n",
+    "\n",
+    "# 3. Compute UMAP\n",
+    "# This projects the graph into 2D for you to look at.\n",
+    "sc.tl.umap(adata, init_pos='X_pca_harmony')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "ce2bc327",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sc.pl.umap(adata, color=\"total_counts\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2209ee21",
+   "metadata": {},
+   "source": [
+    "### Clustering\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "35247ba6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 4. Run Clustering (Leiden algorithm)\n",
+    "# We run multiple resolutions so you can choose the best one later.\n",
+    "#sc.tl.leiden(adata, resolution=0.5, key_added='leiden_0.5')\n",
+    "sc.tl.leiden(adata, resolution=1.0, key_added='leiden_1.0',\n",
+    "    flavor=\"igraph\", n_iterations=2)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "1e9ab973",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1664x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot UMAP colored by Donor (to check integration) and Clusters\n",
+    "sc.pl.umap(adata, color=['cell_type', 'leiden_1.0'], wspace=0.3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "44a42466",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cell_type   natural killer cell  memory B cell  naive B cell  \\\n",
+      "leiden_1.0                                                     \n",
+      "0                            16              0             0   \n",
+      "1                          3307              0             0   \n",
+      "2                             4              2             0   \n",
+      "3                             0              0             0   \n",
+      "4                             1              4             0   \n",
+      "5                        115151              0             7   \n",
+      "6                             4          13789         31184   \n",
+      "7                             3           9320         19541   \n",
+      "\n",
+      "cell_type   regulatory T cell  \\\n",
+      "leiden_1.0                      \n",
+      "0                         562   \n",
+      "1                          24   \n",
+      "2                        6528   \n",
+      "3                        5765   \n",
+      "4                        8161   \n",
+      "5                           1   \n",
+      "6                          67   \n",
+      "7                          29   \n",
+      "\n",
+      "cell_type   naive thymus-derived CD4-positive, alpha-beta T cell  \\\n",
+      "leiden_1.0                                                         \n",
+      "0                                                        2518      \n",
+      "1                                                          73      \n",
+      "2                                                      100187      \n",
+      "3                                                       69940      \n",
+      "4                                                       23760      \n",
+      "5                                                           3      \n",
+      "6                                                          79      \n",
+      "7                                                          33      \n",
+      "\n",
+      "cell_type   central memory CD4-positive, alpha-beta T cell  \\\n",
+      "leiden_1.0                                                   \n",
+      "0                                                    51618   \n",
+      "1                                                      427   \n",
+      "2                                                    34061   \n",
+      "3                                                    37446   \n",
+      "4                                                   104032   \n",
+      "5                                                       51   \n",
+      "6                                                      145   \n",
+      "7                                                       93   \n",
+      "\n",
+      "cell_type   effector memory CD4-positive, alpha-beta T cell  \\\n",
+      "leiden_1.0                                                    \n",
+      "0                                                     17521   \n",
+      "1                                                      2570   \n",
+      "2                                                      1341   \n",
+      "3                                                      1125   \n",
+      "4                                                      2417   \n",
+      "5                                                        62   \n",
+      "6                                                        23   \n",
+      "7                                                         7   \n",
+      "\n",
+      "cell_type   effector memory CD8-positive, alpha-beta T cell  \n",
+      "leiden_1.0                                                   \n",
+      "0                                                      2877  \n",
+      "1                                                    102572  \n",
+      "2                                                       211  \n",
+      "3                                                       150  \n",
+      "4                                                       142  \n",
+      "5                                                      8594  \n",
+      "6                                                        35  \n",
+      "7                                                        11  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# compute overlap between clusters and cell types\n",
+    "contingency_table = pd.crosstab(adata.obs['leiden_1.0'], adata.obs['cell_type'])\n",
+    "print(contingency_table)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb9e87c0",
+   "metadata": {},
+   "source": [
+    "### Pseudobulking"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "28538794",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Aggregating counts...\n",
+      "Pseudobulk complete.\n",
+      "Original shape: (777594, 29331)\n",
+      "Pseudobulk shape: (5584, 29331) (Samples x Genes)\n",
+      "                                                                                         cell_type  \\\n",
+      "central memory CD4-positive, alpha-beta T cell:...  central memory CD4-positive, alpha-beta T cell   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  central memory CD4-positive, alpha-beta T cell   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  central memory CD4-positive, alpha-beta T cell   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  central memory CD4-positive, alpha-beta T cell   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  central memory CD4-positive, alpha-beta T cell   \n",
+      "\n",
+      "                                                     donor_id  n_cells  \\\n",
+      "central memory CD4-positive, alpha-beta T cell:...  1000_1001      562   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  1001_1002      392   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  1003_1004      414   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  1004_1005      248   \n",
+      "central memory CD4-positive, alpha-beta T cell:...  1008_1009      656   \n",
+      "\n",
+      "                                                    development_stage     sex  \n",
+      "central memory CD4-positive, alpha-beta T cell:...  73-year-old stage  female  \n",
+      "central memory CD4-positive, alpha-beta T cell:...  57-year-old stage  female  \n",
+      "central memory CD4-positive, alpha-beta T cell:...  58-year-old stage  female  \n",
+      "central memory CD4-positive, alpha-beta T cell:...  74-year-old stage  female  \n",
+      "central memory CD4-positive, alpha-beta T cell:...  71-year-old stage    male  \n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import anndata as ad\n",
+    "from scipy import sparse\n",
+    "from sklearn.preprocessing import OneHotEncoder\n",
+    "\n",
+    "def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols=None):\n",
+    "    \"\"\"\n",
+    "    Sum raw counts for each (Donor, CellType) pair.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    -----------\n",
+    "    adata : AnnData\n",
+    "        Input single-cell data\n",
+    "    group_col : str\n",
+    "        Column name for grouping (e.g., 'cell_type')\n",
+    "    donor_col : str\n",
+    "        Column name for donor ID\n",
+    "    layer : str\n",
+    "        Layer to use for aggregation (default: 'counts')\n",
+    "    metadata_cols : list of str, optional\n",
+    "        Additional metadata columns to preserve from obs (e.g., ['development_stage', 'sex'])\n",
+    "        These should have consistent values within each donor\n",
+    "    \"\"\"\n",
+    "    # 1. Create a combined key (e.g., \"Bcell::Donor1\")\n",
+    "    groups = adata.obs[group_col].astype(str)\n",
+    "    donors = adata.obs[donor_col].astype(str)\n",
+    "    \n",
+    "    # Create a DataFrame to manage the unique combinations\n",
+    "    group_df = pd.DataFrame({'group': groups, 'donor': donors})\n",
+    "    group_df['combined'] = group_df['group'] + \"::\" + group_df['donor']\n",
+    "    \n",
+    "    # 2. Build the Aggregation Matrix (One-Hot Encoding)\n",
+    "    enc = OneHotEncoder(sparse_output=True, dtype=np.float32)\n",
+    "    membership_matrix = enc.fit_transform(group_df[['combined']])\n",
+    "    \n",
+    "    # 3. Aggregation (Summing)\n",
+    "    if layer is not None and layer in adata.layers:\n",
+    "        X_source = adata.layers[layer]\n",
+    "    else:\n",
+    "        X_source = adata.X\n",
+    "        \n",
+    "    pseudobulk_X = membership_matrix.T @ X_source\n",
+    "    \n",
+    "    # 4. Create the Obs Metadata for the new object\n",
+    "    unique_ids = enc.categories_[0]\n",
+    "    \n",
+    "    # Split back into Donor and Cell Type\n",
+    "    obs_data = []\n",
+    "    for uid in unique_ids:\n",
+    "        ctype, donor = uid.split(\"::\")\n",
+    "        obs_data.append({'cell_type': ctype, 'donor_id': donor})\n",
+    "    \n",
+    "    pb_obs = pd.DataFrame(obs_data, index=unique_ids)\n",
+    "    \n",
+    "    # 5. Count how many cells went into each sum\n",
+    "    cell_counts = np.array(membership_matrix.sum(axis=0)).flatten()\n",
+    "    pb_obs['n_cells'] = cell_counts.astype(int)\n",
+    "    \n",
+    "    # 6. Add additional metadata columns\n",
+    "    if metadata_cols is not None:\n",
+    "        for col in metadata_cols:\n",
+    "            if col in adata.obs.columns:\n",
+    "                # For each pseudobulk sample, get the first (should be consistent) value\n",
+    "                # from the original data for that donor\n",
+    "                col_values = []\n",
+    "                for uid in unique_ids:\n",
+    "                    ctype, donor = uid.split(\"::\")\n",
+    "                    # Get value from any cell with this donor (should all be the same)\n",
+    "                    donor_mask = adata.obs[donor_col] == donor\n",
+    "                    if donor_mask.any():\n",
+    "                        col_values.append(adata.obs.loc[donor_mask, col].iloc[0])\n",
+    "                    else:\n",
+    "                        col_values.append(None)\n",
+    "                pb_obs[col] = col_values\n",
+    "    \n",
+    "    # 7. Assemble the AnnData\n",
+    "    pb_adata = ad.AnnData(X=pseudobulk_X, obs=pb_obs, var=adata.var.copy())\n",
+    "    \n",
+    "    return pb_adata\n",
+    "\n",
+    "# --- Execute ---\n",
+    "\n",
+    "target_cluster_col = 'cell_type'\n",
+    "\n",
+    "print(\"Aggregating counts...\")\n",
+    "pb_adata = create_pseudobulk(\n",
+    "    adata, \n",
+    "    group_col=target_cluster_col, \n",
+    "    donor_col='donor_id', \n",
+    "    layer='counts',\n",
+    "    metadata_cols=['development_stage', 'sex']  # Add any other donor-level metadata here\n",
+    ")\n",
+    "\n",
+    "print(f\"Pseudobulk complete.\")\n",
+    "print(f\"Original shape: {adata.shape}\")\n",
+    "print(f\"Pseudobulk shape: {pb_adata.shape} (Samples x Genes)\")\n",
+    "print(pb_adata.obs.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "8fb76888",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dropping samples with < 10 cells...\n",
+      "Remaining samples: 5561\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1011.11x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "min_cells = 10\n",
+    "print(f\"Dropping samples with < {min_cells} cells...\")\n",
+    "\n",
+    "pb_adata = pb_adata[pb_adata.obs['n_cells'] >= min_cells].copy()\n",
+    "\n",
+    "print(f\"Remaining samples: {pb_adata.n_obs}\")\n",
+    "\n",
+    "# Optional: Visualize the 'depth' of your new pseudobulk samples\n",
+    "import scanpy as sc\n",
+    "pb_adata.obs['total_counts'] = np.array(pb_adata.X.sum(axis=1)).flatten()\n",
+    "sc.pl.violin(pb_adata, ['n_cells', 'total_counts'], multi_panel=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2907db1a",
+   "metadata": {},
+   "source": [
+    "### Differential expression with age\n",
+    "\n",
+    "First need to z-score the age variable to put it on same scale as expression, to help with convergence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "b6298767",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# first need to create 'age_scaled' variable from 'development_stage'\n",
+    "# eg. from '19-year-old stage' to 19\n",
+    "ages = pb_adata.obs['development_stage'].str.extract(r'(\\d+)-year-old').astype(float)\n",
+    "pb_adata.obs['age'] = ages\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "f5fade97",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                                     age  age_scaled\n",
+      "central memory CD4-positive, alpha-beta T cell:...  73.0    0.632347\n",
+      "central memory CD4-positive, alpha-beta T cell:...  57.0   -0.313739\n",
+      "central memory CD4-positive, alpha-beta T cell:...  58.0   -0.254608\n",
+      "central memory CD4-positive, alpha-beta T cell:...  74.0    0.691478\n",
+      "central memory CD4-positive, alpha-beta T cell:...  71.0    0.514087\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "from pydeseq2.dds import DeseqDataSet\n",
+    "from pydeseq2.ds import DeseqStats\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "\n",
+    "# Assume pb_adata is your pseudobulk object from the previous step\n",
+    "# 1. Extract counts and metadata\n",
+    "counts_df = pd.DataFrame(\n",
+    "    pb_adata.X.toarray(), \n",
+    "    index=pb_adata.obs_names, \n",
+    "    columns=[var_to_feature.get(var, var) for var in pb_adata.var_names]\n",
+    ")\n",
+    "# remove duplicate columns if any\n",
+    "counts_df = counts_df.loc[:,~counts_df.columns.duplicated()]\n",
+    "\n",
+    "metadata = pb_adata.obs.copy()\n",
+    "\n",
+    "# 2. IMPORTANT: Scale the continuous variable\n",
+    "# This prevents convergence errors.\n",
+    "scaler = StandardScaler()\n",
+    "metadata['age_scaled'] = scaler.fit_transform(metadata[['age']]).flatten()\n",
+    "metadata['age_scaled'] = metadata['age_scaled'].astype(float)\n",
+    "\n",
+    "\n",
+    "# Check the scaling (Mean should be ~0, Std ~1)\n",
+    "print(metadata[['age', 'age_scaled']].head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "0e30e949",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/r2/f85nyfr1785fj4257wkdj7480000gn/T/ipykernel_48619/2983949029.py:14: DeprecationWarning: design_factors is deprecated and will soon be removed.Please consider providing a formulaic formula using the design argumentinstead.\n",
+      "  dds = DeseqDataSet(\n",
+      "Fitting size factors...\n",
+      "... done in 0.18 seconds.\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using None as control genes, passed at DeseqDataSet initialization\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Fitting dispersions...\n",
+      "... done in 1.58 seconds.\n",
+      "\n",
+      "Fitting dispersion trend curve...\n",
+      "... done in 0.19 seconds.\n",
+      "\n",
+      "Fitting MAP dispersions...\n",
+      "... done in 2.87 seconds.\n",
+      "\n",
+      "Fitting LFCs...\n",
+      "... done in 1.74 seconds.\n",
+      "\n",
+      "Calculating cook's distance...\n",
+      "... done in 0.29 seconds.\n",
+      "\n",
+      "Replacing 1 outlier genes.\n",
+      "\n",
+      "Fitting dispersions...\n",
+      "... done in 0.01 seconds.\n",
+      "\n",
+      "Fitting MAP dispersions...\n",
+      "... done in 0.01 seconds.\n",
+      "\n",
+      "Fitting LFCs...\n",
+      "... done in 0.01 seconds.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Perform DE analysis separately for each cell type\n",
+    "# For this example we just choose one of them\n",
+    "\n",
+    "cell_type = 'central memory CD4-positive, alpha-beta T cell'\n",
+    "pb_adata_ct = pb_adata[pb_adata.obs['cell_type'] == cell_type].copy()\n",
+    "counts_df_ct = counts_df.loc[pb_adata_ct.obs_names].copy()\n",
+    "\n",
+    "metadata_ct = metadata.loc[pb_adata_ct.obs_names].copy()\n",
+    "\n",
+    "assert 'age_scaled' in metadata_ct.columns, \"age_scaled column missing in metadata\"\n",
+    "assert 'sex' in metadata_ct.columns, \"sex column missing in metadata\"\n",
+    "\n",
+    "# 3. Initialize DeseqDataSet\n",
+    "dds = DeseqDataSet(\n",
+    "    counts=counts_df_ct,\n",
+    "    metadata=metadata_ct,\n",
+    "    design_factors=[\"age_scaled\", \"sex\"],  # Use the scaled column\n",
+    "    refit_cooks=True,\n",
+    "    n_cpus=8\n",
+    ")\n",
+    "\n",
+    "# 4. Run the fitting (Dispersions & LFCs)\n",
+    "dds.deseq2()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c867e35",
+   "metadata": {},
+   "source": [
+    "#### Compute statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "0ab33f40",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "contrast: [0 1 0], model_vars: Index(['Intercept', 'age_scaled', 'sex[T.male]'], dtype='object')\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running Wald tests...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Log2 fold change & Wald test p-value, contrast vector: [0 1 0]\n",
+      "                    baseMean  log2FoldChange     lfcSE      stat  \\\n",
+      "OR4F5               0.000000             NaN       NaN       NaN   \n",
+      "ENSG00000239945     0.005952       -0.100132  0.949557 -0.105451   \n",
+      "ENSG00000241860     0.365122        0.025313  0.091008  0.278135   \n",
+      "ENSG00000241599     0.001283       -0.103422  1.448770 -0.071386   \n",
+      "ENSG00000229905     0.000000             NaN       NaN       NaN   \n",
+      "...                      ...             ...       ...       ...   \n",
+      "MT-ND4L           102.560848        0.079307  0.014440  5.492099   \n",
+      "MT-ND4           2574.820764        0.015613  0.009306  1.677810   \n",
+      "MT-ND5            759.807343        0.007827  0.010848  0.721464   \n",
+      "MT-ND6             37.003224        0.029722  0.013672  2.173891   \n",
+      "MT-CYB           2443.119315        0.030728  0.011338  2.710161   \n",
+      "\n",
+      "                       pvalue      padj  \n",
+      "OR4F5                     NaN       NaN  \n",
+      "ENSG00000239945  9.160176e-01       NaN  \n",
+      "ENSG00000241860  7.809089e-01       NaN  \n",
+      "ENSG00000241599  9.430907e-01       NaN  \n",
+      "ENSG00000229905           NaN       NaN  \n",
+      "...                       ...       ...  \n",
+      "MT-ND4L          3.971854e-08  0.000002  \n",
+      "MT-ND4           9.338413e-02  0.226846  \n",
+      "MT-ND5           4.706241e-01  0.658790  \n",
+      "MT-ND6           2.971332e-02  0.099708  \n",
+      "MT-CYB           6.725063e-03  0.032845  \n",
+      "\n",
+      "[29324 rows x 6 columns]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "... done in 2.22 seconds.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_vars = dds.varm[\"LFC\"].columns\n",
+    "contrast = np.array([0, 1, 0])\n",
+    "print(f\"contrast: {contrast}, model_vars: {model_vars}\")\n",
+    "\n",
+    "# 5. Statistical Test (Wald Test)\n",
+    "# Syntax for continuous: [\"variable\", \"\", \"\"]\n",
+    "stat_res = DeseqStats(\n",
+    "    dds, \n",
+    "    contrast=contrast\n",
+    ")\n",
+    "\n",
+    "stat_res.summary()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "6598e6ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Running Wald tests...\n",
+      "... done in 0.62 seconds.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "stat_res.run_wald_test()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01e512d6",
+   "metadata": {},
+   "source": [
+    "#### Find significant genes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "cd4ccda1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 3124 significant genes.\n",
+      "                 log2FoldChange          padj\n",
+      "ENSG00000260613        0.662743  6.155660e-05\n",
+      "GTSCR1                 0.529188  2.553945e-35\n",
+      "PHLDA3                 0.518890  7.488643e-12\n",
+      "GABRE                  0.494251  4.340036e-04\n",
+      "DONSON                 0.488810  5.428557e-09\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 1. Get the results dataframe\n",
+    "res = stat_res.results_df\n",
+    "\n",
+    "# 2. Filter for significant genes (e.g., FDR < 0.05)\n",
+    "# This automatically excludes NaNs (since NaN < 0.05 is False)\n",
+    "sigs = res[res['padj'] < 0.05]\n",
+    "\n",
+    "# 3. Sort by effect size (Log2 Fold Change) to see top hits\n",
+    "sigs = sigs.sort_values('log2FoldChange', ascending=False)\n",
+    "\n",
+    "print(f\"Found {len(sigs)} significant genes.\")\n",
+    "print(sigs[['log2FoldChange', 'padj']].head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c68688e2",
+   "metadata": {},
+   "source": [
+    "### Pathway enrichment: GSEA\n",
+    "\n",
+    "- what pathways are enriched in the differentially expressed genes?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "7f64589e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-12-20 11:59:18,597 [WARNING] Duplicated values found in preranked stats: 5.93% of genes\n",
+      "The order of those genes will be arbitrary, which may produce unexpected results.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Top Upregulated Pathways:\n",
+      "                                                 Term       NES FDR q-val\n",
+      "0   MSigDB_Hallmark_2020__TNF-alpha Signaling via ...  2.097542       0.0\n",
+      "1                       MSigDB_Hallmark_2020__Hypoxia  1.782058  0.003216\n",
+      "2     MSigDB_Hallmark_2020__Interferon Gamma Response  1.750043  0.003216\n",
+      "3                     MSigDB_Hallmark_2020__Apoptosis  1.660934  0.004824\n",
+      "4                   MSigDB_Hallmark_2020__p53 Pathway  1.652138  0.005788\n",
+      "5   MSigDB_Hallmark_2020__Reactive Oxygen Species ...  1.601382  0.008039\n",
+      "6     MSigDB_Hallmark_2020__Interferon Alpha Response  1.550408  0.014701\n",
+      "7          MSigDB_Hallmark_2020__IL-2/STAT5 Signaling    1.4815  0.023314\n",
+      "8     MSigDB_Hallmark_2020__Oxidative Phosphorylation  1.473942  0.023582\n",
+      "10      MSigDB_Hallmark_2020__Cholesterol Homeostasis  1.429341  0.031836\n",
+      "\n",
+      "Top Downregulated Pathways:\n",
+      "                                                Term       NES FDR q-val\n",
+      "40             MSigDB_Hallmark_2020__Spermatogenesis -1.003029  0.778001\n",
+      "39           MSigDB_Hallmark_2020__Androgen Response -1.023541  0.776461\n",
+      "36       MSigDB_Hallmark_2020__Xenobiotic Metabolism -1.042344  0.787156\n",
+      "31              MSigDB_Hallmark_2020__Myc Targets V2 -1.143465  0.462271\n",
+      "25             MSigDB_Hallmark_2020__Apical Junction   -1.2273  0.266236\n",
+      "23    MSigDB_Hallmark_2020__PI3K/AKT/mTOR  Signaling  -1.24776   0.26635\n",
+      "21           MSigDB_Hallmark_2020__Protein Secretion -1.251274  0.320531\n",
+      "14          MSigDB_Hallmark_2020__TGF-beta Signaling -1.369893  0.120925\n",
+      "12             MSigDB_Hallmark_2020__Notch Signaling -1.394944  0.128555\n",
+      "9   MSigDB_Hallmark_2020__Wnt-beta Catenin Signaling -1.468539  0.102245\n"
+     ]
+    }
+   ],
+   "source": [
+    "import gseapy as gp\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "\n",
+    "# 1. Prepare the Ranked List\n",
+    "# We use the 'stat' column if available (best metric). \n",
+    "# If 'stat' isn't there, approximate it with -log10(pvalue) * sign(log2FoldChange)\n",
+    "rank_df = res[['stat']].dropna().sort_values('stat', ascending=False)\n",
+    "\n",
+    "# 2. Run GSEA Preranked\n",
+    "# We look at GO Biological Process and the \"Hallmark\" set (good for general states)\n",
+    "# For immune specific, you can also add 'Reactome_2022' or 'KEGG_2021_Human'\n",
+    "prerank_res = gp.prerank(\n",
+    "    rnk=rank_df, \n",
+    "    gene_sets=['MSigDB_Hallmark_2020'],\n",
+    "    threads=4,\n",
+    "    min_size=10, # Min genes in pathway\n",
+    "    max_size=1000, \n",
+    "    permutation_num=1000, # Reduce to 100 for speed if testing\n",
+    "    seed=42\n",
+    ")\n",
+    "\n",
+    "# 3. View Results\n",
+    "# 'NES' = Normalized Enrichment Score (Positive = Upregulated in Age, Negative = Downregulated)\n",
+    "# 'FDR q-val' = Significance\n",
+    "terms = prerank_res.res2d.sort_values('NES', ascending=False)\n",
+    "\n",
+    "print(\"Top Upregulated Pathways:\")\n",
+    "print(terms[['Term', 'NES', 'FDR q-val']].head(10))\n",
+    "\n",
+    "print(\"\\nTop Downregulated Pathways:\")\n",
+    "print(terms[['Term', 'NES', 'FDR q-val']].tail(10))\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "573c2d0a",
+   "metadata": {},
+   "source": [
+    "#### Create a plot for the results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "217bc4f9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting 20 pathways.\n",
+      "                            Term       NES  FDR q-val  Count\n",
+      "0  TNF-alpha Signaling via NF-kB  2.097542   0.000000     86\n",
+      "1                        Hypoxia  1.782058   0.003216     51\n",
+      "2      Interferon Gamma Response  1.750043   0.003216     80\n",
+      "3                      Apoptosis  1.660934   0.004824     51\n",
+      "4                    p53 Pathway  1.652138   0.005788     59\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# 1. Get the results table\n",
+    "# (Assumes 'prerank_res' is your output from gp.prerank)\n",
+    "gsea_df = prerank_res.res2d.copy()\n",
+    "\n",
+    "# 2. Sort by NES to separate Up vs Down\n",
+    "gsea_df = gsea_df.sort_values('NES', ascending=False)\n",
+    "\n",
+    "# 3. Select Top 10 Up and Top 10 Down\n",
+    "top_up = gsea_df.head(10).copy()\n",
+    "top_down = gsea_df.tail(10).copy()\n",
+    "\n",
+    "# 4. Combine them\n",
+    "combined_gsea = pd.concat([top_up, top_down])\n",
+    "\n",
+    "# 5. Create metrics for plotting\n",
+    "# Direction based on NES sign\n",
+    "combined_gsea['Direction'] = combined_gsea['NES'].apply(lambda x: 'Upregulated' if x > 0 else 'Downregulated')\n",
+    "\n",
+    "# Significance for X-axis (-log10 FDR)\n",
+    "# We add a tiny epsilon (1e-10) to avoid log(0) errors if FDR is exactly 0\n",
+    "combined_gsea['FDR q-val'] = pd.to_numeric(combined_gsea['FDR q-val'], errors='coerce')\n",
+    "combined_gsea['log_FDR'] = -np.log10(combined_gsea['FDR q-val'] + 1e-10)\n",
+    "\n",
+    "# Gene Count for Dot Size\n",
+    "# GSEApy stores the leading edge genes as a semi-colon separated string in 'Lead_genes'\n",
+    "combined_gsea['Count'] = combined_gsea['Lead_genes'].apply(lambda x: len(str(x).split(';')))\n",
+    "\n",
+    "## remove MSigDB label from Term\n",
+    "combined_gsea['Term'] = combined_gsea['Term'].str.replace('MSigDB_Hallmark_2020__', '', regex=False)\n",
+    "\n",
+    "print(f\"Plotting {len(combined_gsea)} pathways.\")\n",
+    "print(combined_gsea[['Term', 'NES', 'FDR q-val', 'Count']].head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "3da89ee8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10, 8))\n",
+    "\n",
+    "# Create the scatter plot\n",
+    "sns.scatterplot(\n",
+    "    data=combined_gsea,\n",
+    "    x='log_FDR',\n",
+    "    y='Term',\n",
+    "    hue='Direction',     # Color by NES Direction\n",
+    "    size='Count',        # Size by number of Leading Edge genes\n",
+    "    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue\n",
+    "    sizes=(50, 400),     # Range of dot sizes\n",
+    "    alpha=0.8\n",
+    ")\n",
+    "\n",
+    "# Customization\n",
+    "plt.title('Top GSEA Pathways (Up vs Down)', fontsize=14)\n",
+    "plt.xlabel('-log10(FDR q-value)', fontsize=12)\n",
+    "plt.ylabel('')\n",
+    "\n",
+    "# Add a vertical line for significance (FDR < 0.05 => -log10(0.05) ~= 1.3)\n",
+    "plt.axvline(-np.log10(0.25), color='gray', linestyle=':', label='FDR=0.25 (GSEA standard)')\n",
+    "plt.axvline(-np.log10(0.05), color='gray', linestyle='--', label='FDR=0.05')\n",
+    "\n",
+    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n",
+    "plt.grid(axis='x', alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ceaad09c",
+   "metadata": {},
+   "source": [
+    "### Enrichr analysis for overrepresentation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "7f5e6224",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Analyzing 1205 upregulated and 1919 downregulated genes.\n",
+      "Upregulated Pathways:\n",
+      "                              Term  Adjusted P-value Overlap\n",
+      "0    TNF-alpha Signaling via NF-kB      3.695219e-15  48/200\n",
+      "1                   Myc Targets V1      2.231576e-13  45/200\n",
+      "2                      p53 Pathway      5.909649e-11  41/200\n",
+      "3                        Apoptosis      6.464364e-11  36/161\n",
+      "4        Interferon Gamma Response      2.287547e-09  38/200\n",
+      "5                          Hypoxia      2.679064e-07  34/200\n",
+      "6        Oxidative Phosphorylation      2.679064e-07  34/200\n",
+      "7  Reactive Oxygen Species Pathway      4.441324e-06   14/49\n",
+      "8        Unfolded Protein Response      1.912995e-05  21/113\n",
+      "9                 mTORC1 Signaling      4.982898e-05  29/200\n",
+      "Downregulated Pathways:\n",
+      "                         Term  Adjusted P-value Overlap\n",
+      "0              Myc Targets V1          0.001618  38/200\n",
+      "1           Protein Secretion          0.005788   21/96\n",
+      "2    PI3K/AKT/mTOR  Signaling          0.005788  22/105\n",
+      "3           Androgen Response          0.014601  20/100\n",
+      "4  Wnt-beta Catenin Signaling          0.054265   10/42\n",
+      "5          TGF-beta Signaling          0.102715   11/54\n",
+      "6   Oxidative Phosphorylation          0.115051  29/200\n",
+      "7       Fatty Acid Metabolism          0.301496  22/158\n",
+      "8             G2-M Checkpoint          0.342076  26/200\n",
+      "9            mTORC1 Signaling          0.342076  26/200\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 1. Define your significant gene lists\n",
+    "# Up in Age\n",
+    "up_genes = res[\n",
+    "    (res['padj'] < 0.05) & (res['log2FoldChange'] > 0)\n",
+    "].index.tolist()\n",
+    "\n",
+    "# Down in Age\n",
+    "down_genes = res[\n",
+    "    (res['padj'] < 0.05) & (res['log2FoldChange'] < 0)\n",
+    "].index.tolist()\n",
+    "\n",
+    "print(f\"Analyzing {len(up_genes)} upregulated and {len(down_genes)} downregulated genes.\")\n",
+    "\n",
+    "# 2. Run Enrichr (Over-Representation Analysis)\n",
+    "if len(up_genes) > 0:\n",
+    "    enr_up = gp.enrichr(\n",
+    "        gene_list=up_genes,\n",
+    "        gene_sets=['MSigDB_Hallmark_2020'],\n",
+    "        organism='human', \n",
+    "        outdir=None\n",
+    "    )\n",
+    "    print(\"Upregulated Pathways:\")\n",
+    "    print(enr_up.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))\n",
+    "    \n",
+    "\n",
+    "if len(down_genes) > 0:\n",
+    "    enr_down = gp.enrichr(\n",
+    "        gene_list=down_genes,\n",
+    "        gene_sets=['MSigDB_Hallmark_2020'],\n",
+    "        organism='human', \n",
+    "        outdir=None\n",
+    "    )\n",
+    "    print(\"Downregulated Pathways:\")\n",
+    "    print(enr_down.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "390796aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting 20 pathways.\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# 1. Add a \"Direction\" column to distinguish them\n",
+    "up_res = enr_up.results.copy()\n",
+    "up_res['Direction'] = 'Upregulated'\n",
+    "up_res['Color'] = 'Red'  # For custom palette\n",
+    "\n",
+    "down_res = enr_down.results.copy()\n",
+    "down_res['Direction'] = 'Downregulated'\n",
+    "down_res['Color'] = 'Blue'\n",
+    "\n",
+    "# 2. Filter for top 10 pathways by Adjusted P-value\n",
+    "# (You can also filter by 'Combined Score' if you prefer)\n",
+    "top_up = up_res.sort_values('Adjusted P-value').head(10)\n",
+    "top_down = down_res.sort_values('Adjusted P-value').head(10)\n",
+    "\n",
+    "# 3. Concatenate\n",
+    "combined = pd.concat([top_up, top_down])\n",
+    "\n",
+    "# 4. Create a \"-log10(P-value)\" column for plotting\n",
+    "combined['log_p'] = -np.log10(combined['Adjusted P-value'])\n",
+    "\n",
+    "# 5. Extract \"Count\" from the \"Overlap\" column (e.g., \"5/200\" -> 5)\n",
+    "# This is used to size the dots\n",
+    "combined['Gene_Count'] = combined['Overlap'].apply(lambda x: int(x.split('/')[0]))\n",
+    "\n",
+    "print(f\"Plotting {len(combined)} pathways.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "290615f7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.figure(figsize=(10, 8))\n",
+    "\n",
+    "# Create the scatter plot\n",
+    "sns.scatterplot(\n",
+    "    data=combined,\n",
+    "    x='log_p',\n",
+    "    y='Term',\n",
+    "    hue='Direction',    # Color by Up/Down\n",
+    "    size='Gene_Count',  # Size by number of genes in pathway\n",
+    "    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue\n",
+    "    sizes=(50, 400),    # Range of dot sizes\n",
+    "    alpha=0.8\n",
+    ")\n",
+    "\n",
+    "# Customization\n",
+    "plt.title('Top Enriched Pathways (Up vs Down)', fontsize=14)\n",
+    "plt.xlabel('-log10(Adjusted P-value)', fontsize=12)\n",
+    "plt.ylabel('')\n",
+    "plt.axvline(-np.log10(0.05), color='gray', linestyle='--', alpha=0.5, label='p=0.05') # Significance threshold line\n",
+    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n",
+    "plt.grid(axis='x', alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc7868dc",
+   "metadata": {},
+   "source": [
+    "### Age prediction from gene expression\n",
+    "\n",
+    "Here we will build a predictive model and assess our ability to predict age from held-out individuals.  We also test against a baseline model with only sex as a covariate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b826767b",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "086597f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature matrix shape: (698, 29325)\n",
+      "Number of samples: 698\n",
+      "Age range: 19.0 - 97.0 years\n",
+      "\n",
+      "Fold 1/5\n",
+      "  R² Score: 0.310\n",
+      "  MAE: 11.38 years\n",
+      "\n",
+      "Fold 2/5\n",
+      "  R² Score: 0.305\n",
+      "  MAE: 11.63 years\n",
+      "\n",
+      "Fold 3/5\n",
+      "  R² Score: 0.247\n",
+      "  MAE: 11.94 years\n",
+      "\n",
+      "Fold 4/5\n",
+      "  R² Score: 0.314\n",
+      "  MAE: 10.67 years\n",
+      "\n",
+      "Fold 5/5\n",
+      "  R² Score: 0.240\n",
+      "  MAE: 10.87 years\n",
+      "\n",
+      "==================================================\n",
+      "CROSS-VALIDATION RESULTS\n",
+      "==================================================\n",
+      "R² Score: 0.283 ± 0.033\n",
+      "MAE: 11.30 ± 0.47 years\n",
+      "==================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.svm import LinearSVR\n",
+    "from sklearn.model_selection import ShuffleSplit\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.metrics import r2_score, mean_absolute_error\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "# 1. Prepare features and target\n",
+    "# Features: all genes from counts_df_ct + sex variable\n",
+    "X_genes = counts_df_ct.copy()\n",
+    "\n",
+    "# Add sex as a binary feature (encode as 0/1)\n",
+    "sex_encoded = pd.get_dummies(metadata_ct['sex'], drop_first=True)\n",
+    "X = pd.concat([X_genes, sex_encoded], axis=1)\n",
+    "\n",
+    "# Target: age\n",
+    "y = metadata_ct['age'].values\n",
+    "\n",
+    "print(f\"Feature matrix shape: {X.shape}\")\n",
+    "print(f\"Number of samples: {len(y)}\")\n",
+    "print(f\"Age range: {y.min():.1f} - {y.max():.1f} years\")\n",
+    "\n",
+    "# 2. Set up ShuffleSplit cross-validation\n",
+    "# Using 5 splits with 20% test size\n",
+    "cv = ShuffleSplit(n_splits=5, test_size=0.2, random_state=42)\n",
+    "\n",
+    "# 3. Store results\n",
+    "r2_scores = []\n",
+    "mae_scores = []\n",
+    "predictions_list = []\n",
+    "actual_list = []\n",
+    "\n",
+    "# 4. Train and evaluate model for each split\n",
+    "for fold, (train_idx, test_idx) in enumerate(cv.split(X)):\n",
+    "    print(f\"\\nFold {fold + 1}/5\")\n",
+    "    \n",
+    "    # Split data\n",
+    "    X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]\n",
+    "    y_train, y_test = y[train_idx], y[test_idx]\n",
+    "    \n",
+    "    # Scale features (important for SVR)\n",
+    "    scaler = StandardScaler()\n",
+    "    X_train_scaled = scaler.fit_transform(X_train)\n",
+    "    X_test_scaled = scaler.transform(X_test)\n",
+    "    \n",
+    "    # Train Linear SVR\n",
+    "    # C parameter controls regularization (smaller = more regularization)\n",
+    "    model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')\n",
+    "    model.fit(X_train_scaled, y_train)\n",
+    "    \n",
+    "    # Predict on test set\n",
+    "    y_pred = model.predict(X_test_scaled)\n",
+    "    \n",
+    "    # Calculate metrics\n",
+    "    r2 = r2_score(y_test, y_pred)\n",
+    "    mae = mean_absolute_error(y_test, y_pred)\n",
+    "    \n",
+    "    r2_scores.append(r2)\n",
+    "    mae_scores.append(mae)\n",
+    "    predictions_list.extend(y_pred)\n",
+    "    actual_list.extend(y_test)\n",
+    "    \n",
+    "    print(f\"  R² Score: {r2:.3f}\")\n",
+    "    print(f\"  MAE: {mae:.2f} years\")\n",
+    "\n",
+    "# 5. Summary statistics\n",
+    "print(\"\\n\" + \"=\"*50)\n",
+    "print(\"CROSS-VALIDATION RESULTS\")\n",
+    "print(\"=\"*50)\n",
+    "print(f\"R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}\")\n",
+    "print(f\"MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years\")\n",
+    "print(\"=\"*50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "9a1f7eda",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualize predictions vs actual ages\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "\n",
+    "# Scatter plot of predictions vs actual\n",
+    "plt.scatter(actual_list, predictions_list, alpha=0.6, s=80)\n",
+    "\n",
+    "# Add diagonal line (perfect predictions)\n",
+    "min_age = min(min(actual_list), min(predictions_list))\n",
+    "max_age = max(max(actual_list), max(predictions_list))\n",
+    "plt.plot([min_age, max_age], [min_age, max_age], 'r--', linewidth=2, label='Perfect Prediction')\n",
+    "\n",
+    "plt.xlabel('Actual Age (years)', fontsize=12)\n",
+    "plt.ylabel('Predicted Age (years)', fontsize=12)\n",
+    "plt.title(f'Age Prediction Performance\\nR² = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years', \n",
+    "          fontsize=14)\n",
+    "plt.legend()\n",
+    "plt.grid(alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "902799f5",
+   "metadata": {},
+   "source": [
+    "#### Baseline model: Sex only\n",
+    "\n",
+    "Compare against a baseline model that only uses sex as a predictor to assess the contribution of gene expression."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "781a934c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "============================================================\n",
+      "MODEL COMPARISON\n",
+      "============================================================\n",
+      "Full Model (Genes + Sex):\n",
+      "  R² Score: 0.283 ± 0.033\n",
+      "  MAE: 11.30 ± 0.47 years\n",
+      "\n",
+      "Baseline Model (Sex Only):\n",
+      "  R² Score: -0.027 ± 0.018\n",
+      "  MAE: 13.55 ± 0.54 years\n",
+      "\n",
+      "Improvement:\n",
+      "  ΔR²: 0.310\n",
+      "  ΔMAE: 2.25 years\n",
+      "============================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Baseline model: Sex only\n",
+    "X_baseline = sex_encoded.copy()\n",
+    "\n",
+    "# Store baseline results\n",
+    "baseline_r2_scores = []\n",
+    "baseline_mae_scores = []\n",
+    "\n",
+    "# Train and evaluate baseline model for each split\n",
+    "for fold, (train_idx, test_idx) in enumerate(cv.split(X_baseline)):\n",
+    "    # Split data\n",
+    "    X_train, X_test = X_baseline.iloc[train_idx], X_baseline.iloc[test_idx]\n",
+    "    y_train, y_test = y[train_idx], y[test_idx]\n",
+    "    \n",
+    "    # Scale features\n",
+    "    scaler = StandardScaler()\n",
+    "    X_train_scaled = scaler.fit_transform(X_train)\n",
+    "    X_test_scaled = scaler.transform(X_test)\n",
+    "    \n",
+    "    # Train Linear SVR\n",
+    "    model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')\n",
+    "    model.fit(X_train_scaled, y_train)\n",
+    "    \n",
+    "    # Predict on test set\n",
+    "    y_pred = model.predict(X_test_scaled)\n",
+    "    \n",
+    "    # Calculate metrics\n",
+    "    r2 = r2_score(y_test, y_pred)\n",
+    "    mae = mean_absolute_error(y_test, y_pred)\n",
+    "    \n",
+    "    baseline_r2_scores.append(r2)\n",
+    "    baseline_mae_scores.append(mae)\n",
+    "\n",
+    "# Summary comparison\n",
+    "print(\"=\"*60)\n",
+    "print(\"MODEL COMPARISON\")\n",
+    "print(\"=\"*60)\n",
+    "print(f\"Full Model (Genes + Sex):\")\n",
+    "print(f\"  R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}\")\n",
+    "print(f\"  MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years\")\n",
+    "print(f\"\\nBaseline Model (Sex Only):\")\n",
+    "print(f\"  R² Score: {np.mean(baseline_r2_scores):.3f} ± {np.std(baseline_r2_scores):.3f}\")\n",
+    "print(f\"  MAE: {np.mean(baseline_mae_scores):.2f} ± {np.std(baseline_mae_scores):.2f} years\")\n",
+    "print(f\"\\nImprovement:\")\n",
+    "print(f\"  ΔR²: {np.mean(r2_scores) - np.mean(baseline_r2_scores):.3f}\")\n",
+    "print(f\"  ΔMAE: {np.mean(baseline_mae_scores) - np.mean(mae_scores):.2f} years\")\n",
+    "print(\"=\"*60)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "052f9c31",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "BetterCodeBetterScience",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 91d26f880d6da49140b18440e89c610a8a8e094f Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 20 Dec 2025 12:27:29 -0800
Subject: [PATCH 28/87] initial add

---
 .../rnaseq/immune_scrnaseq_monolithic.py      | 1119 +++++++++++++++++
 1 file changed, 1119 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py

diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
new file mode 100644
index 0000000..7c8d32c
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
@@ -0,0 +1,1119 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.18.1
+#   kernelspec:
+#     display_name: BetterCodeBetterScience
+#     language: python
+#     name: python3
+# ---
+
+# %% [markdown]
+# ### Immune system gene expression and aging
+#
+# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total.  These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants.  
+#
+# The flagship paper for this study is:
+#
+# Yazar S., Alquicira-Hernández J., Wing K., Senabouth A., Gordon G., Andersen S., Lu Q., Rowson A., Taylor T., Clarke L., Maccora L., Chen C., Cook A., Ye J., Fairfax K., Hewitt A., Powell J. Single cell eQTL mapping identified cell type specific control of autoimmune disease. Science, 376, 6589 (2022)
+#
+# We will use the data to ask a simple question: how does gene expression in PBMCs change with age?
+
+
+
+# %%
+import anndata as ad
+import dask.array as da
+import h5py
+import numpy as np
+import scanpy as sc
+from pathlib import Path
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')
+
+
+# %% [markdown]
+# ### Immune system gene expression and aging
+#
+# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total.  These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants.  
+#
+# The flagship paper for this study is:
+#
+# Yazar S., Alquicira-Hernández J., Wing K., Senabouth A., Gordon G., Andersen S., Lu Q., Rowson A., Taylor T., Clarke L., Maccora L., Chen C., Cook A., Ye J., Fairfax K., Hewitt A., Powell J. Single cell eQTL mapping identified cell type specific control of autoimmune disease. Science, 376, 6589 (2022)
+#
+# We will use the data to ask a simple question: how does gene expression in PBMCs change with age?
+# 
+# # Code in this notebook primarily generated using Gemini 3.0
+
+
+# %%
+import anndata as ad
+from anndata.experimental import read_lazy
+import dask.array as da
+import h5py
+import numpy as np
+import scanpy as sc
+from pathlib import Path
+import os
+
+datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')
+
+# %%
+datafile = datadir / 'a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'
+url = 'https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'
+dataset_name = 'OneK1K'
+
+if not datafile.exists():
+    cmd = f'wget -O {datafile.as_posix()} {url}'
+    print(f'Downloading data from {url} to {datafile.as_posix()}')
+    os.system(cmd)
+
+load_annotation_index = True
+adata = read_lazy(h5py.File(datafile, 'r'),
+    load_annotation_index=load_annotation_index)
+
+# %%
+print(adata)
+
+# %%
+unique_cell_types = np.unique(adata.obs['cell_type'])
+print(unique_cell_types)
+
+# %% [markdown]
+# ### Filtering out bad donors
+
+# %%
+import matplotlib.pyplot as plt
+import pandas as pd
+from scipy.stats import scoreatpercentile
+
+# 1. Calculate how many cells each donor has
+donor_cell_counts = pd.Series(adata.obs['donor_id']).value_counts()
+
+# Print some basic statistics to read the exact numbers
+print("Donor Cell Count Statistics:")
+print(donor_cell_counts.describe())
+
+# 2. Plot the histogram
+plt.figure(figsize=(10, 6))
+# Bins set to 'auto' or a fixed number depending on your N of donors
+plt.hist(donor_cell_counts.values, bins=50, color='skyblue', edgecolor='black')
+
+plt.title('Distribution of Total Cells per Donor')
+plt.xlabel('Number of Cells Captured')
+plt.ylabel('Number of Donors')
+plt.grid(axis='y', alpha=0.5)
+
+# Optional: Draw a vertical line at the propsoed cutoff
+# This helps you visualize how many donors you would lose.
+cutoff_percentile = 10  # e.g., 10th percentile
+min_cells_per_donor = int(scoreatpercentile(donor_cell_counts.values, cutoff_percentile))
+print(f'cutoff of {min_cells_per_donor} would exclude {(donor_cell_counts < min_cells_per_donor).sum()} donors')
+plt.axvline(min_cells_per_donor, color='red', linestyle='dashed', linewidth=1, label=f'Cutoff ({min_cells_per_donor} cells)')
+plt.legend()
+
+plt.show()
+
+# %%
+print(f"Filtering to keep only donors with at least {min_cells_per_donor} cells.")
+print(f"Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}")
+valid_donors = donor_cell_counts[donor_cell_counts >= min_cells_per_donor].index
+adata = adata[adata.obs['donor_id'].isin(valid_donors)]
+
+# %%
+print(f'Number of donors after filtering: {len(valid_donors)}')
+
+# %% [markdown]
+# ### Filtering cell types by frequency
+#
+# Drop cell types that don't have at least 10 cells for at least 95% of people
+
+# %%
+import pandas as pd
+
+# 1. Calculate the count of cells for each 'cell_type' within each 'donor_id'
+# We use pandas crosstab on adata.obs, which is loaded in memory.
+counts_per_donor = pd.crosstab(adata.obs['donor_id'], adata.obs['cell_type'])
+
+# 2. Identify cell types to keep
+# Keep if >= 10 cells in at least 90% of donors
+
+min_cells = 10
+percent_donors = 0.9
+donor_count = counts_per_donor.shape[0]
+cell_types_to_keep = counts_per_donor.columns[
+    (counts_per_donor >= min_cells).sum(axis=0) >= (donor_count * percent_donors)]
+
+print(f"Keeping {len(cell_types_to_keep)} cell types out of {len(counts_per_donor.columns)}")
+print(f"Cell types to keep: {cell_types_to_keep.tolist()}")
+
+# 3. Filter the AnnData object
+# We subset the AnnData to include only observations belonging to the valid cell types.
+adata_filtered = adata[adata.obs['cell_type'].isin(cell_types_to_keep)]
+
+# %%
+# now drop subjects who have any zeros in these cell types
+donor_celltype_counts = pd.crosstab(adata_filtered.obs['donor_id'], adata_filtered.obs['cell_type'])
+valid_donors_final = donor_celltype_counts.index[
+    (donor_celltype_counts >= min_cells).all(axis=1)]
+adata_filtered = adata_filtered[adata_filtered.obs['donor_id'].isin(valid_donors_final)]
+print(f"Final number of donors after filtering: {len(valid_donors_final)}")
+
+# %%
+
+print("Loading data into memory (this can take a few minutes)...")
+adata_loaded = adata_filtered.to_memory()
+
+# filter out genes with zero counts across all selected cells
+print("Filtering genes with zero counts...")
+sc.pp.filter_genes(adata_loaded, min_counts=1)
+
+
+# %%
+print(adata_loaded)
+
+
+# %%
+adata_loaded.write(datadir /  f'dataset-{dataset_name}_subset-immune_filtered.h5ad')
+del adata_loaded
+
+# %%
+adata = ad.read_h5ad(datadir / f'dataset-{dataset_name}_subset-immune_filtered.h5ad')
+print(adata)
+
+# %%
+var_to_feature = dict(zip(adata.var_names, adata.var['feature_name']))
+
+# %% [markdown]
+# Preprocessing based on suggestions from Google Gemini
+#
+# based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html
+#
+# and https://www.10xgenomics.com/analysis-guides/common-considerations-for-quality-control-filters-for-single-cell-rna-seq-data
+#
+
+# %% [markdown]
+# ### Quality control
+#
+# based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html
+#
+
+# %%
+# mitochondrial genes
+adata.var["mt"] = adata.var['feature_name'].str.startswith("MT-")
+print(f"Number of mitochondrial genes: {adata.var['mt'].sum()}")
+
+# ribosomal genes
+adata.var["ribo"] = adata.var['feature_name'].str.startswith(("RPS", "RPL"))
+print(f"Number of ribosomal genes: {adata.var['ribo'].sum()}")
+
+# hemoglobin genes.
+adata.var["hb"] = adata.var['feature_name'].str.contains("^HB[^(P)]")
+print(f"Number of hemoglobin genes: {adata.var['hb'].sum()}")
+
+sc.pp.calculate_qc_metrics(
+    adata, qc_vars=["mt", "ribo", "hb"], inplace=True, percent_top=[20], log1p=True
+)
+
+
+
+# %% [markdown]
+# #### Visualization of distributions 
+
+# %%
+
+# 1. Violin plots to see the distribution of QC metrics
+# Note: I am using the exact column names from your adata output
+p1 = sc.pl.violin(adata, ['total_counts', 'n_genes_by_counts', 'pct_counts_mt'],
+             jitter=0.4, multi_panel=True)
+
+# 2. Scatter plot to spot doublets and dying cells
+# High mito + low genes = dying cell
+# High counts + high genes = potential doublet
+sc.pl.scatter(adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt')
+
+# %% [markdown]
+# ####  Check Hemoglobin (RBC contamination)
+#
+
+# %%
+
+plt.figure(figsize=(6, 4))
+sns.histplot(adata.obs['pct_counts_hb'], bins=50, log_scale=(False, True)) # Log scale y to see small RBC populations
+plt.title("Hemoglobin Content Distribution")
+plt.xlabel("% Hemoglobin Counts")
+plt.axvline(5, color='red', linestyle='--', label='5% Cutoff')
+plt.legend()
+plt.show()
+
+# %% [markdown]
+# #### Create a copy of the data and apply QC cutoffs
+#
+
+# %%
+# Create a copy or view to avoid modifying the original if needed
+adata_qc = adata.copy()
+
+# --- Define Thresholds ---
+# Low quality (Empty droplets / debris)
+min_genes = 200       # Standard for immune cells (T-cells can be small)
+min_counts = 500      # Minimum UMIs
+
+# Doublets (Two cells stuck together)
+# Adjust this based on the scatter plot above. 
+# 4000-6000 is common for 10x Genomics data.
+max_genes = 6000      
+max_counts = 30000    # Very high counts often indicate doublets
+
+# Contaminants
+max_hb_pct = 5.0      # Remove Red Blood Cells (> 5% hemoglobin)
+
+# --- Apply Filtering ---
+print(f"Before filtering: {adata_qc.n_obs} cells")
+
+# 1. Filter Low Quality & Doublets
+adata_qc = adata_qc[
+    (adata_qc.obs['n_genes_by_counts'] > min_genes) &
+    (adata_qc.obs['n_genes_by_counts'] < max_genes) &
+    (adata_qc.obs['total_counts'] > min_counts) &
+    (adata_qc.obs['total_counts'] < max_counts)
+]
+
+# 2. Filter Red Blood Cells (Hemoglobin)
+# Only run this if you want to remove RBCs
+adata_qc = adata_qc[adata_qc.obs['pct_counts_hb'] < max_hb_pct]
+
+print(f"After filtering: {adata_qc.n_obs} cells")
+
+# %% [markdown]
+# ### Perform doublet detection
+#
+# According to Gemini:
+#
+# You must do this before normalization or clustering because doublets create "hybrid" expression profiles that can form fake clusters (e.g., a "cluster" that looks like a mix of T-cells and B-cells) or distort your normalization factors.
+#
+# **Important: Run Per Donor**
+#
+# Since you have multiple people, you must run doublet detection separately for each donor. The doublet rate is a technical artifact of the physical loading of the machine (10x Genomics chip), which varies per run. If you run it on the whole dataset at once, the algorithm will get confused by biological differences between people.
+#
+
+# %%
+
+# 1. Check preliminary requirements
+# Scrublet needs RAW counts. Ensure adata.X contains integers, not log-normalized data.
+# If your main layer is already normalized, use adata.raw or a specific layer.
+print(f"Data shape before doublet detection: {adata_qc.shape}")
+
+# 2. Run Scrublet per donor
+# We split the data, run detection, and then recombine.
+# This prevents the algorithm from comparing a cell from Person A to a cell from Person B.
+
+adatas_list = []
+# Get list of unique donors
+donors = adata_qc.obs['donor_id'].unique()
+
+print(f"Running Scrublet on {len(donors)} donors...")
+
+for donor in donors:
+    # Subset to current donor
+    curr_adata = adata_qc[adata_qc.obs['donor_id'] == donor].copy()
+    
+    # Skip donors with too few cells (Scrublet needs statistical power)
+    if curr_adata.n_obs < 100:
+        print(f"Skipping donor {donor}: too few cells ({curr_adata.n_obs})")
+        # We still add it back to keep the data, but mark as singlet (or filter later)
+        curr_adata.obs['doublet_score'] = 0
+        curr_adata.obs['predicted_doublet'] = False
+        adatas_list.append(curr_adata)
+        continue
+
+    # Run Scrublet
+    # expected_doublet_rate=0.06 is standard for 10x (approx ~0.8% per 1000 cells recovered)
+    # If you loaded very heavily (20k cells/well), increase this to 0.10
+    sc.pp.scrublet(curr_adata, expected_doublet_rate=0.06)
+    
+    adatas_list.append(curr_adata)
+
+# 3. Merge back into one object
+adata_qc = sc.concat(adatas_list)
+
+# 4. Check results
+print(f"Detected {adata_qc.obs['predicted_doublet'].sum()} doublets across all donors.")
+print(adata_qc.obs['predicted_doublet'].value_counts())
+
+# %% [markdown]
+# #### Visualize doublets
+#
+#
+
+# %%
+sc.pl.umap(adata_qc, color=['doublet_score', 'predicted_doublet'], size=20)
+
+# %% [markdown]
+# #### Filter doublets
+# - Question: how consistent are these results with other methods for doublet detection? https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html#doublet-detection
+
+# %%
+# Check how many doublets were found
+print(f'found {adata_qc.obs["predicted_doublet"].sum()} predicted doublets')
+
+# Filter the data to keep only singlets (False)
+# write back to adata for simplicity
+adata = adata_qc[adata_qc.obs['predicted_doublet'] == False, :]
+print(f"Remaining cells: {adata.n_obs}")
+
+# %% [markdown]
+# #### Save raw counts for later use
+
+# %%
+#  set the .raw attribute (standard Scanpy convention)
+adata.layers['counts'] = adata.X.copy()
+
+# %% [markdown]
+# ### Total Count Normalization
+# This scales each cell so that they all have the same total number of counts (default is often 10,000, known as "CP10k").
+
+# %%
+# Normalize to 10,000 reads per cell
+# target_sum=1e4 is the standard for 10x data
+sc.pp.normalize_total(adata, target_sum=1e4)
+
+# %% [markdown]
+# ### Log Transformation (Log1p)
+# This applies a natural logarithm to the data:  log(X+1). This reduces the skewness of the data (since gene expression follows a power law) and stabilizes the variance.
+
+# %%
+# Logarithmically transform the data
+sc.pp.log1p(adata)
+
+# %% [markdown]
+# ### select high-variance features
+#
+# according to Gemini:
+# For a large immune dataset (PBMCs, ~1.2M cells), the standard defaults often fail to capture the subtle biological variation needed to distinguish similar cell types (like CD4+ T-cell subsets).
+#
+# Here are the reasonable parameters and, more importantly, the **immune-specific strategy** you should use.
+#
+# #### The Recommended Parameters
+#
+# For a dataset of your size, the **`seurat_v3`** flavor is generally superior because it selects genes based on standardized variance (handling the mean-variance relationship better than the dispersion-based method).
+#
+# *   **`flavor`**: `'seurat_v3'` (Requires **RAW integer counts** in `adata.X` or a layer)
+# *   **`n_top_genes`**: **2000 - 3000** (3000 is safer for immune data to capture rare cytokines/markers)
+# *   **`batch_key`**: **`'donor_id'`** (CRITICAL)
+#     *   *Why?* With 1.2M cells across many people, you have massive batch effects. If you don't set this, "highly variable genes" will just be the genes that differ between Person A and Person B (e.g., HLA genes, gender-specific genes like XIST/RPS4Y1), rather than genes distinguishing cell types.
+#
+# #### The "Expert" Trick: Blocklisting Nuisance Genes
+# In immune datasets, "highly variable" does not always mean "biologically interesting." You often need to **exclude** specific gene families from the HVG list *after* calculation but *before* PCA, or they will hijack your clustering:
+# 1.  **TCR/BCR Variable Regions (IG*, TR*):** These are hyper-variable by definition (V(D)J recombination). If you keep them, T-cells will cluster by **clone** (clonotype) rather than by **phenotype** (state).
+# 2.  **Mitochondrial/Ribosomal:** Usually technical noise.
+# 3.  **Cell Cycle:** (Optional) If you don't want proliferating cells to cluster separately.
+#
+#
+#
+# #### Why 3000 genes instead of 2000?
+# Immune cells are dense with specific markers. The difference between a *Naive CD8 T-cell* and a *Central Memory CD8 T-cell* might rest on a handful of genes (e.g., *CCR7, SELL, IL7R* vs *GZMK*). If you limit to 2000 genes in a massive, diverse dataset, you might accidentally drop a subtle marker required to resolve these fine-grained states.
+
+# %%
+
+import scanpy as sc
+import pandas as pd
+
+
+# 2. Run Highly Variable Gene Selection
+# batch_key is critical here to find genes variable WITHIN donors, not BETWEEN them.
+sc.pp.highly_variable_genes(
+    adata,
+    n_top_genes=3000,
+    flavor='seurat_v3',
+    batch_key='donor_id',
+    span=0.8,  # helps avoid numerical issues with LOESS
+    layer='counts',  # Change this to None if adata.X is raw counts
+    subset=False     # Keep False so we can manually filter the list below
+)
+
+# 3. Filter out "Nuisance" Genes from the HVG list
+# We don't remove the genes from the object, we just set their 'highly_variable' status to False
+# so they aren't used in PCA.
+
+# A. Identify TCR/BCR genes (starts with IG or TR)
+# Regex: IG or TR followed by a V, D, J, or C gene part
+import re
+immune_receptor_genes = [
+    name for name in adata.var_names 
+    if re.match(r'^(IG[HKL]|TR[ABDG])[VDJC]', name)
+]
+
+# B. Identify Ribosomal/Mitochondrial (if not already handled)
+mt_genes = adata.var_names[adata.var_names.str.startswith('MT-')]
+rb_genes = adata.var_names[adata.var_names.str.startswith(('RPS', 'RPL'))]
+
+# C. Manually set them to False
+genes_to_block = list(immune_receptor_genes) + list(mt_genes) + list(rb_genes)
+
+# Using set operations for speed
+adata.var.loc[adata.var_names.isin(genes_to_block), 'highly_variable'] = False
+
+print(f"Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.")
+print(f"Final HVG count: {adata.var['highly_variable'].sum()}")
+
+# 4. Proceed to PCA
+sc.tl.pca(adata, svd_solver='arpack', use_highly_variable=True)
+
+
+# %% [markdown]
+# ### Dimensionality reduction
+
+# %%
+import scanpy.external as sce
+
+# 1. Run Harmony
+# This adjusts the PCA coordinates to mix donors together while preserving biology.
+# It creates a new entry in obsm: 'X_pca_harmony'
+try:
+    sce.pp.harmony_integrate(adata, key='donor_id', basis='X_pca', adjusted_basis='X_pca_harmony')
+    use_rep = 'X_pca_harmony'
+    print("Harmony integration successful. Using corrected PCA.")
+except ImportError:
+    print("Harmony not installed. Proceeding with standard PCA (Warning: Batch effects may persist).")
+    print("To install: pip install harmony-pytorch")
+    use_rep = 'X_pca'
+
+# %%
+# Reality check: Check if PC1 is just "Cell Size":
+
+sc.pl.pca(adata, color=['total_counts', 'cell_type'], components=['1,2'])
+
+# %% [markdown]
+# PC1 separates cell types and isn't driven only by the number of cells.
+
+# %%
+# 2. Compute Neighbors
+# n_neighbors: 15-30 is standard. Higher (30-50) is better for large datasets to preserve global structure.
+# n_pcs: 30-50 is standard.
+sc.pp.neighbors(adata, n_neighbors=30, n_pcs=40, use_rep=use_rep)
+
+# 3. Compute UMAP
+# This projects the graph into 2D for you to look at.
+sc.tl.umap(adata, init_pos='X_pca_harmony')
+
+# %%
+sc.pl.umap(adata, color="total_counts")
+
+
+# %% [markdown]
+# ### Clustering
+#
+
+# %%
+# 4. Run Clustering (Leiden algorithm)
+# We run multiple resolutions so you can choose the best one later.
+#sc.tl.leiden(adata, resolution=0.5, key_added='leiden_0.5')
+sc.tl.leiden(adata, resolution=1.0, key_added='leiden_1.0',
+    flavor="igraph", n_iterations=2)
+
+
+# %%
+# Plot UMAP colored by Donor (to check integration) and Clusters
+sc.pl.umap(adata, color=['cell_type', 'leiden_1.0'], wspace=0.3)
+
+# %%
+# compute overlap between clusters and cell types
+contingency_table = pd.crosstab(adata.obs['leiden_1.0'], adata.obs['cell_type'])
+print(contingency_table)
+
+# %% [markdown]
+# ### Pseudobulking
+
+# %%
+import pandas as pd
+import numpy as np
+import anndata as ad
+from scipy import sparse
+from sklearn.preprocessing import OneHotEncoder
+
+def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols=None):
+    """
+    Sum raw counts for each (Donor, CellType) pair.
+    
+    Parameters:
+    -----------
+    adata : AnnData
+        Input single-cell data
+    group_col : str
+        Column name for grouping (e.g., 'cell_type')
+    donor_col : str
+        Column name for donor ID
+    layer : str
+        Layer to use for aggregation (default: 'counts')
+    metadata_cols : list of str, optional
+        Additional metadata columns to preserve from obs (e.g., ['development_stage', 'sex'])
+        These should have consistent values within each donor
+    """
+    # 1. Create a combined key (e.g., "Bcell::Donor1")
+    groups = adata.obs[group_col].astype(str)
+    donors = adata.obs[donor_col].astype(str)
+    
+    # Create a DataFrame to manage the unique combinations
+    group_df = pd.DataFrame({'group': groups, 'donor': donors})
+    group_df['combined'] = group_df['group'] + "::" + group_df['donor']
+    
+    # 2. Build the Aggregation Matrix (One-Hot Encoding)
+    enc = OneHotEncoder(sparse_output=True, dtype=np.float32)
+    membership_matrix = enc.fit_transform(group_df[['combined']])
+    
+    # 3. Aggregation (Summing)
+    if layer is not None and layer in adata.layers:
+        X_source = adata.layers[layer]
+    else:
+        X_source = adata.X
+        
+    pseudobulk_X = membership_matrix.T @ X_source
+    
+    # 4. Create the Obs Metadata for the new object
+    unique_ids = enc.categories_[0]
+    
+    # Split back into Donor and Cell Type
+    obs_data = []
+    for uid in unique_ids:
+        ctype, donor = uid.split("::")
+        obs_data.append({'cell_type': ctype, 'donor_id': donor})
+    
+    pb_obs = pd.DataFrame(obs_data, index=unique_ids)
+    
+    # 5. Count how many cells went into each sum
+    cell_counts = np.array(membership_matrix.sum(axis=0)).flatten()
+    pb_obs['n_cells'] = cell_counts.astype(int)
+    
+    # 6. Add additional metadata columns
+    if metadata_cols is not None:
+        for col in metadata_cols:
+            if col in adata.obs.columns:
+                # For each pseudobulk sample, get the first (should be consistent) value
+                # from the original data for that donor
+                col_values = []
+                for uid in unique_ids:
+                    ctype, donor = uid.split("::")
+                    # Get value from any cell with this donor (should all be the same)
+                    donor_mask = adata.obs[donor_col] == donor
+                    if donor_mask.any():
+                        col_values.append(adata.obs.loc[donor_mask, col].iloc[0])
+                    else:
+                        col_values.append(None)
+                pb_obs[col] = col_values
+    
+    # 7. Assemble the AnnData
+    pb_adata = ad.AnnData(X=pseudobulk_X, obs=pb_obs, var=adata.var.copy())
+    
+    return pb_adata
+
+# --- Execute ---
+
+target_cluster_col = 'cell_type'
+
+print("Aggregating counts...")
+pb_adata = create_pseudobulk(
+    adata, 
+    group_col=target_cluster_col, 
+    donor_col='donor_id', 
+    layer='counts',
+    metadata_cols=['development_stage', 'sex']  # Add any other donor-level metadata here
+)
+
+print(f"Pseudobulk complete.")
+print(f"Original shape: {adata.shape}")
+print(f"Pseudobulk shape: {pb_adata.shape} (Samples x Genes)")
+print(pb_adata.obs.head())
+
+# %%
+min_cells = 10
+print(f"Dropping samples with < {min_cells} cells...")
+
+pb_adata = pb_adata[pb_adata.obs['n_cells'] >= min_cells].copy()
+
+print(f"Remaining samples: {pb_adata.n_obs}")
+
+# Optional: Visualize the 'depth' of your new pseudobulk samples
+import scanpy as sc
+pb_adata.obs['total_counts'] = np.array(pb_adata.X.sum(axis=1)).flatten()
+sc.pl.violin(pb_adata, ['n_cells', 'total_counts'], multi_panel=True)
+
+# %% [markdown]
+# ### Differential expression with age
+#
+# First need to z-score the age variable to put it on same scale as expression, to help with convergence
+
+# %%
+# first need to create 'age_scaled' variable from 'development_stage'
+# eg. from '19-year-old stage' to 19
+ages = pb_adata.obs['development_stage'].str.extract(r'(\d+)-year-old').astype(float)
+pb_adata.obs['age'] = ages
+
+
+
+# %%
+import pandas as pd
+from pydeseq2.dds import DeseqDataSet
+from pydeseq2.ds import DeseqStats
+from sklearn.preprocessing import StandardScaler
+
+# Assume pb_adata is your pseudobulk object from the previous step
+# 1. Extract counts and metadata
+counts_df = pd.DataFrame(
+    pb_adata.X.toarray(), 
+    index=pb_adata.obs_names, 
+    columns=[var_to_feature.get(var, var) for var in pb_adata.var_names]
+)
+# remove duplicate columns if any
+counts_df = counts_df.loc[:,~counts_df.columns.duplicated()]
+
+metadata = pb_adata.obs.copy()
+
+# 2. IMPORTANT: Scale the continuous variable
+# This prevents convergence errors.
+scaler = StandardScaler()
+metadata['age_scaled'] = scaler.fit_transform(metadata[['age']]).flatten()
+metadata['age_scaled'] = metadata['age_scaled'].astype(float)
+
+
+# Check the scaling (Mean should be ~0, Std ~1)
+print(metadata[['age', 'age_scaled']].head())
+
+# %%
+# Perform DE analysis separately for each cell type
+# For this example we just choose one of them
+
+cell_type = 'central memory CD4-positive, alpha-beta T cell'
+pb_adata_ct = pb_adata[pb_adata.obs['cell_type'] == cell_type].copy()
+counts_df_ct = counts_df.loc[pb_adata_ct.obs_names].copy()
+
+metadata_ct = metadata.loc[pb_adata_ct.obs_names].copy()
+
+assert 'age_scaled' in metadata_ct.columns, "age_scaled column missing in metadata"
+assert 'sex' in metadata_ct.columns, "sex column missing in metadata"
+
+# 3. Initialize DeseqDataSet
+dds = DeseqDataSet(
+    counts=counts_df_ct,
+    metadata=metadata_ct,
+    design_factors=["age_scaled", "sex"],  # Use the scaled column
+    refit_cooks=True,
+    n_cpus=8
+)
+
+# 4. Run the fitting (Dispersions & LFCs)
+dds.deseq2()
+
+
+# %% [markdown]
+# #### Compute statistics
+
+# %%
+model_vars = dds.varm["LFC"].columns
+contrast = np.array([0, 1, 0])
+print(f"contrast: {contrast}, model_vars: {model_vars}")
+
+# 5. Statistical Test (Wald Test)
+# Syntax for continuous: ["variable", "", ""]
+stat_res = DeseqStats(
+    dds, 
+    contrast=contrast
+)
+
+stat_res.summary()
+
+
+
+# %%
+stat_res.run_wald_test()
+
+# %% [markdown]
+# #### Find significant genes
+
+# %%
+# 1. Get the results dataframe
+res = stat_res.results_df
+
+# 2. Filter for significant genes (e.g., FDR < 0.05)
+# This automatically excludes NaNs (since NaN < 0.05 is False)
+sigs = res[res['padj'] < 0.05]
+
+# 3. Sort by effect size (Log2 Fold Change) to see top hits
+sigs = sigs.sort_values('log2FoldChange', ascending=False)
+
+print(f"Found {len(sigs)} significant genes.")
+print(sigs[['log2FoldChange', 'padj']].head())
+
+# %% [markdown]
+# ### Pathway enrichment: GSEA
+#
+# - what pathways are enriched in the differentially expressed genes?
+
+# %%
+import gseapy as gp
+import matplotlib.pyplot as plt
+import pandas as pd
+
+# 1. Prepare the Ranked List
+# We use the 'stat' column if available (best metric). 
+# If 'stat' isn't there, approximate it with -log10(pvalue) * sign(log2FoldChange)
+rank_df = res[['stat']].dropna().sort_values('stat', ascending=False)
+
+# 2. Run GSEA Preranked
+# We look at GO Biological Process and the "Hallmark" set (good for general states)
+# For immune specific, you can also add 'Reactome_2022' or 'KEGG_2021_Human'
+prerank_res = gp.prerank(
+    rnk=rank_df, 
+    gene_sets=['MSigDB_Hallmark_2020'],
+    threads=4,
+    min_size=10, # Min genes in pathway
+    max_size=1000, 
+    permutation_num=1000, # Reduce to 100 for speed if testing
+    seed=42
+)
+
+# 3. View Results
+# 'NES' = Normalized Enrichment Score (Positive = Upregulated in Age, Negative = Downregulated)
+# 'FDR q-val' = Significance
+terms = prerank_res.res2d.sort_values('NES', ascending=False)
+
+print("Top Upregulated Pathways:")
+print(terms[['Term', 'NES', 'FDR q-val']].head(10))
+
+print("\nTop Downregulated Pathways:")
+print(terms[['Term', 'NES', 'FDR q-val']].tail(10))
+
+
+
+# %% [markdown]
+# #### Create a plot for the results
+
+# %%
+
+# 1. Get the results table
+# (Assumes 'prerank_res' is your output from gp.prerank)
+gsea_df = prerank_res.res2d.copy()
+
+# 2. Sort by NES to separate Up vs Down
+gsea_df = gsea_df.sort_values('NES', ascending=False)
+
+# 3. Select Top 10 Up and Top 10 Down
+top_up = gsea_df.head(10).copy()
+top_down = gsea_df.tail(10).copy()
+
+# 4. Combine them
+combined_gsea = pd.concat([top_up, top_down])
+
+# 5. Create metrics for plotting
+# Direction based on NES sign
+combined_gsea['Direction'] = combined_gsea['NES'].apply(lambda x: 'Upregulated' if x > 0 else 'Downregulated')
+
+# Significance for X-axis (-log10 FDR)
+# We add a tiny epsilon (1e-10) to avoid log(0) errors if FDR is exactly 0
+combined_gsea['FDR q-val'] = pd.to_numeric(combined_gsea['FDR q-val'], errors='coerce')
+combined_gsea['log_FDR'] = -np.log10(combined_gsea['FDR q-val'] + 1e-10)
+
+# Gene Count for Dot Size
+# GSEApy stores the leading edge genes as a semi-colon separated string in 'Lead_genes'
+combined_gsea['Count'] = combined_gsea['Lead_genes'].apply(lambda x: len(str(x).split(';')))
+
+## remove MSigDB label from Term
+combined_gsea['Term'] = combined_gsea['Term'].str.replace('MSigDB_Hallmark_2020__', '', regex=False)
+
+print(f"Plotting {len(combined_gsea)} pathways.")
+print(combined_gsea[['Term', 'NES', 'FDR q-val', 'Count']].head())
+
+# %%
+plt.figure(figsize=(10, 8))
+
+# Create the scatter plot
+sns.scatterplot(
+    data=combined_gsea,
+    x='log_FDR',
+    y='Term',
+    hue='Direction',     # Color by NES Direction
+    size='Count',        # Size by number of Leading Edge genes
+    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue
+    sizes=(50, 400),     # Range of dot sizes
+    alpha=0.8
+)
+
+# Customization
+plt.title('Top GSEA Pathways (Up vs Down)', fontsize=14)
+plt.xlabel('-log10(FDR q-value)', fontsize=12)
+plt.ylabel('')
+
+# Add a vertical line for significance (FDR < 0.05 => -log10(0.05) ~= 1.3)
+plt.axvline(-np.log10(0.25), color='gray', linestyle=':', label='FDR=0.25 (GSEA standard)')
+plt.axvline(-np.log10(0.05), color='gray', linestyle='--', label='FDR=0.05')
+
+plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)
+plt.grid(axis='x', alpha=0.3)
+plt.tight_layout()
+
+plt.show()
+
+# %% [markdown]
+# ### Enrichr analysis for overrepresentation
+
+# %%
+# 1. Define your significant gene lists
+# Up in Age
+up_genes = res[
+    (res['padj'] < 0.05) & (res['log2FoldChange'] > 0)
+].index.tolist()
+
+# Down in Age
+down_genes = res[
+    (res['padj'] < 0.05) & (res['log2FoldChange'] < 0)
+].index.tolist()
+
+print(f"Analyzing {len(up_genes)} upregulated and {len(down_genes)} downregulated genes.")
+
+# 2. Run Enrichr (Over-Representation Analysis)
+if len(up_genes) > 0:
+    enr_up = gp.enrichr(
+        gene_list=up_genes,
+        gene_sets=['MSigDB_Hallmark_2020'],
+        organism='human', 
+        outdir=None
+    )
+    print("Upregulated Pathways:")
+    print(enr_up.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))
+    
+
+if len(down_genes) > 0:
+    enr_down = gp.enrichr(
+        gene_list=down_genes,
+        gene_sets=['MSigDB_Hallmark_2020'],
+        organism='human', 
+        outdir=None
+    )
+    print("Downregulated Pathways:")
+    print(enr_down.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))
+    
+
+
+# %%
+
+# 1. Add a "Direction" column to distinguish them
+up_res = enr_up.results.copy()
+up_res['Direction'] = 'Upregulated'
+up_res['Color'] = 'Red'  # For custom palette
+
+down_res = enr_down.results.copy()
+down_res['Direction'] = 'Downregulated'
+down_res['Color'] = 'Blue'
+
+# 2. Filter for top 10 pathways by Adjusted P-value
+# (You can also filter by 'Combined Score' if you prefer)
+top_up = up_res.sort_values('Adjusted P-value').head(10)
+top_down = down_res.sort_values('Adjusted P-value').head(10)
+
+# 3. Concatenate
+combined = pd.concat([top_up, top_down])
+
+# 4. Create a "-log10(P-value)" column for plotting
+combined['log_p'] = -np.log10(combined['Adjusted P-value'])
+
+# 5. Extract "Count" from the "Overlap" column (e.g., "5/200" -> 5)
+# This is used to size the dots
+combined['Gene_Count'] = combined['Overlap'].apply(lambda x: int(x.split('/')[0]))
+
+print(f"Plotting {len(combined)} pathways.")
+
+
+# %%
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+plt.figure(figsize=(10, 8))
+
+# Create the scatter plot
+sns.scatterplot(
+    data=combined,
+    x='log_p',
+    y='Term',
+    hue='Direction',    # Color by Up/Down
+    size='Gene_Count',  # Size by number of genes in pathway
+    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue
+    sizes=(50, 400),    # Range of dot sizes
+    alpha=0.8
+)
+
+# Customization
+plt.title('Top Enriched Pathways (Up vs Down)', fontsize=14)
+plt.xlabel('-log10(Adjusted P-value)', fontsize=12)
+plt.ylabel('')
+plt.axvline(-np.log10(0.05), color='gray', linestyle='--', alpha=0.5, label='p=0.05') # Significance threshold line
+plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)
+plt.grid(axis='x', alpha=0.3)
+plt.tight_layout()
+
+plt.show()
+
+# %% [markdown]
+# ### Age prediction from gene expression
+#
+# Here we will build a predictive model and assess our ability to predict age from held-out individuals.  We also test against a baseline model with only sex as a covariate.
+
+# %% [markdown]
+#
+
+# %%
+from sklearn.svm import LinearSVR
+from sklearn.model_selection import ShuffleSplit
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import r2_score, mean_absolute_error
+import pandas as pd
+import numpy as np
+
+# 1. Prepare features and target
+# Features: all genes from counts_df_ct + sex variable
+X_genes = counts_df_ct.copy()
+
+# Add sex as a binary feature (encode as 0/1)
+sex_encoded = pd.get_dummies(metadata_ct['sex'], drop_first=True)
+X = pd.concat([X_genes, sex_encoded], axis=1)
+
+# Target: age
+y = metadata_ct['age'].values
+
+print(f"Feature matrix shape: {X.shape}")
+print(f"Number of samples: {len(y)}")
+print(f"Age range: {y.min():.1f} - {y.max():.1f} years")
+
+# 2. Set up ShuffleSplit cross-validation
+# Using 5 splits with 20% test size
+cv = ShuffleSplit(n_splits=5, test_size=0.2, random_state=42)
+
+# 3. Store results
+r2_scores = []
+mae_scores = []
+predictions_list = []
+actual_list = []
+
+# 4. Train and evaluate model for each split
+for fold, (train_idx, test_idx) in enumerate(cv.split(X)):
+    print(f"\nFold {fold + 1}/5")
+    
+    # Split data
+    X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
+    y_train, y_test = y[train_idx], y[test_idx]
+    
+    # Scale features (important for SVR)
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+    
+    # Train Linear SVR
+    # C parameter controls regularization (smaller = more regularization)
+    model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')
+    model.fit(X_train_scaled, y_train)
+    
+    # Predict on test set
+    y_pred = model.predict(X_test_scaled)
+    
+    # Calculate metrics
+    r2 = r2_score(y_test, y_pred)
+    mae = mean_absolute_error(y_test, y_pred)
+    
+    r2_scores.append(r2)
+    mae_scores.append(mae)
+    predictions_list.extend(y_pred)
+    actual_list.extend(y_test)
+    
+    print(f"  R² Score: {r2:.3f}")
+    print(f"  MAE: {mae:.2f} years")
+
+# 5. Summary statistics
+print("\n" + "="*50)
+print("CROSS-VALIDATION RESULTS")
+print("="*50)
+print(f"R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}")
+print(f"MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years")
+print("="*50)
+
+# %%
+# Visualize predictions vs actual ages
+import matplotlib.pyplot as plt
+
+plt.figure(figsize=(8, 6))
+
+# Scatter plot of predictions vs actual
+plt.scatter(actual_list, predictions_list, alpha=0.6, s=80)
+
+# Add diagonal line (perfect predictions)
+min_age = min(min(actual_list), min(predictions_list))
+max_age = max(max(actual_list), max(predictions_list))
+plt.plot([min_age, max_age], [min_age, max_age], 'r--', linewidth=2, label='Perfect Prediction')
+
+plt.xlabel('Actual Age (years)', fontsize=12)
+plt.ylabel('Predicted Age (years)', fontsize=12)
+plt.title(f'Age Prediction Performance\nR² = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years', 
+          fontsize=14)
+plt.legend()
+plt.grid(alpha=0.3)
+plt.tight_layout()
+plt.show()
+
+# %% [markdown]
+# #### Baseline model: Sex only
+#
+# Compare against a baseline model that only uses sex as a predictor to assess the contribution of gene expression.
+
+# %%
+# Baseline model: Sex only
+X_baseline = sex_encoded.copy()
+
+# Store baseline results
+baseline_r2_scores = []
+baseline_mae_scores = []
+
+# Train and evaluate baseline model for each split
+for fold, (train_idx, test_idx) in enumerate(cv.split(X_baseline)):
+    # Split data
+    X_train, X_test = X_baseline.iloc[train_idx], X_baseline.iloc[test_idx]
+    y_train, y_test = y[train_idx], y[test_idx]
+    
+    # Scale features
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+    
+    # Train Linear SVR
+    model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')
+    model.fit(X_train_scaled, y_train)
+    
+    # Predict on test set
+    y_pred = model.predict(X_test_scaled)
+    
+    # Calculate metrics
+    r2 = r2_score(y_test, y_pred)
+    mae = mean_absolute_error(y_test, y_pred)
+    
+    baseline_r2_scores.append(r2)
+    baseline_mae_scores.append(mae)
+
+# Summary comparison
+print("="*60)
+print("MODEL COMPARISON")
+print("="*60)
+print(f"Full Model (Genes + Sex):")
+print(f"  R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}")
+print(f"  MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years")
+print(f"\nBaseline Model (Sex Only):")
+print(f"  R² Score: {np.mean(baseline_r2_scores):.3f} ± {np.std(baseline_r2_scores):.3f}")
+print(f"  MAE: {np.mean(baseline_mae_scores):.2f} ± {np.std(baseline_mae_scores):.2f} years")
+print(f"\nImprovement:")
+print(f"  ΔR²: {np.mean(r2_scores) - np.mean(baseline_r2_scores):.3f}")
+print(f"  ΔMAE: {np.mean(baseline_mae_scores) - np.mean(mae_scores):.2f} years")
+print("="*60)
+
+# %%

From 925f1f0656fb3d63d6b0e097d05ad9f10eb2af43 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sat, 20 Dec 2025 12:34:04 -0800
Subject: [PATCH 29/87] formatted and ruffed, about to remove plt.show commands
 which halt execution

---
 .../rnaseq/immune_scrnaseq_monolithic.py      | 533 ++++++++++--------
 1 file changed, 306 insertions(+), 227 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
index 7c8d32c..95c994d 100644
--- a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
+++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
@@ -15,7 +15,7 @@
 # %% [markdown]
 # ### Immune system gene expression and aging
 #
-# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total.  These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants.  
+# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total.  These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants.
 #
 # The flagship paper for this study is:
 #
@@ -24,16 +24,29 @@
 # We will use the data to ask a simple question: how does gene expression in PBMCs change with age?
 
 
-
 # %%
 import anndata as ad
-import dask.array as da
 import h5py
 import numpy as np
 import scanpy as sc
 from pathlib import Path
 import matplotlib.pyplot as plt
 import seaborn as sns
+from anndata.experimental import read_lazy
+import os
+import pandas as pd
+from scipy.stats import scoreatpercentile
+import re
+import scanpy.external as sce
+from sklearn.preprocessing import OneHotEncoder
+from pydeseq2.dds import DeseqDataSet
+from pydeseq2.ds import DeseqStats
+from sklearn.preprocessing import StandardScaler
+import gseapy as gp
+from sklearn.svm import LinearSVR
+from sklearn.model_selection import ShuffleSplit
+from sklearn.metrics import r2_score, mean_absolute_error
+
 
 datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')
 
@@ -41,26 +54,18 @@
 # %% [markdown]
 # ### Immune system gene expression and aging
 #
-# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total.  These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants.  
+# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total.  These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants.
 #
 # The flagship paper for this study is:
 #
 # Yazar S., Alquicira-Hernández J., Wing K., Senabouth A., Gordon G., Andersen S., Lu Q., Rowson A., Taylor T., Clarke L., Maccora L., Chen C., Cook A., Ye J., Fairfax K., Hewitt A., Powell J. Single cell eQTL mapping identified cell type specific control of autoimmune disease. Science, 376, 6589 (2022)
 #
 # We will use the data to ask a simple question: how does gene expression in PBMCs change with age?
-# 
+#
 # # Code in this notebook primarily generated using Gemini 3.0
 
 
 # %%
-import anndata as ad
-from anndata.experimental import read_lazy
-import dask.array as da
-import h5py
-import numpy as np
-import scanpy as sc
-from pathlib import Path
-import os
 
 datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')
 
@@ -75,8 +80,9 @@
     os.system(cmd)
 
 load_annotation_index = True
-adata = read_lazy(h5py.File(datafile, 'r'),
-    load_annotation_index=load_annotation_index)
+adata = read_lazy(
+    h5py.File(datafile, 'r'), load_annotation_index=load_annotation_index
+)
 
 # %%
 print(adata)
@@ -89,15 +95,13 @@
 # ### Filtering out bad donors
 
 # %%
-import matplotlib.pyplot as plt
-import pandas as pd
-from scipy.stats import scoreatpercentile
+
 
 # 1. Calculate how many cells each donor has
 donor_cell_counts = pd.Series(adata.obs['donor_id']).value_counts()
 
 # Print some basic statistics to read the exact numbers
-print("Donor Cell Count Statistics:")
+print('Donor Cell Count Statistics:')
 print(donor_cell_counts.describe())
 
 # 2. Plot the histogram
@@ -113,17 +117,33 @@
 # Optional: Draw a vertical line at the propsoed cutoff
 # This helps you visualize how many donors you would lose.
 cutoff_percentile = 10  # e.g., 10th percentile
-min_cells_per_donor = int(scoreatpercentile(donor_cell_counts.values, cutoff_percentile))
-print(f'cutoff of {min_cells_per_donor} would exclude {(donor_cell_counts < min_cells_per_donor).sum()} donors')
-plt.axvline(min_cells_per_donor, color='red', linestyle='dashed', linewidth=1, label=f'Cutoff ({min_cells_per_donor} cells)')
+min_cells_per_donor = int(
+    scoreatpercentile(donor_cell_counts.values, cutoff_percentile)
+)
+print(
+    f'cutoff of {min_cells_per_donor} would exclude {(donor_cell_counts < min_cells_per_donor).sum()} donors'
+)
+plt.axvline(
+    min_cells_per_donor,
+    color='red',
+    linestyle='dashed',
+    linewidth=1,
+    label=f'Cutoff ({min_cells_per_donor} cells)',
+)
 plt.legend()
 
 plt.show()
 
 # %%
-print(f"Filtering to keep only donors with at least {min_cells_per_donor} cells.")
-print(f"Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}")
-valid_donors = donor_cell_counts[donor_cell_counts >= min_cells_per_donor].index
+print(
+    f'Filtering to keep only donors with at least {min_cells_per_donor} cells.'
+)
+print(
+    f'Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}'
+)
+valid_donors = donor_cell_counts[
+    donor_cell_counts >= min_cells_per_donor
+].index
 adata = adata[adata.obs['donor_id'].isin(valid_donors)]
 
 # %%
@@ -135,7 +155,6 @@
 # Drop cell types that don't have at least 10 cells for at least 95% of people
 
 # %%
-import pandas as pd
 
 # 1. Calculate the count of cells for each 'cell_type' within each 'donor_id'
 # We use pandas crosstab on adata.obs, which is loaded in memory.
@@ -148,10 +167,14 @@
 percent_donors = 0.9
 donor_count = counts_per_donor.shape[0]
 cell_types_to_keep = counts_per_donor.columns[
-    (counts_per_donor >= min_cells).sum(axis=0) >= (donor_count * percent_donors)]
+    (counts_per_donor >= min_cells).sum(axis=0)
+    >= (donor_count * percent_donors)
+]
 
-print(f"Keeping {len(cell_types_to_keep)} cell types out of {len(counts_per_donor.columns)}")
-print(f"Cell types to keep: {cell_types_to_keep.tolist()}")
+print(
+    f'Keeping {len(cell_types_to_keep)} cell types out of {len(counts_per_donor.columns)}'
+)
+print(f'Cell types to keep: {cell_types_to_keep.tolist()}')
 
 # 3. Filter the AnnData object
 # We subset the AnnData to include only observations belonging to the valid cell types.
@@ -159,19 +182,24 @@
 
 # %%
 # now drop subjects who have any zeros in these cell types
-donor_celltype_counts = pd.crosstab(adata_filtered.obs['donor_id'], adata_filtered.obs['cell_type'])
+donor_celltype_counts = pd.crosstab(
+    adata_filtered.obs['donor_id'], adata_filtered.obs['cell_type']
+)
 valid_donors_final = donor_celltype_counts.index[
-    (donor_celltype_counts >= min_cells).all(axis=1)]
-adata_filtered = adata_filtered[adata_filtered.obs['donor_id'].isin(valid_donors_final)]
-print(f"Final number of donors after filtering: {len(valid_donors_final)}")
+    (donor_celltype_counts >= min_cells).all(axis=1)
+]
+adata_filtered = adata_filtered[
+    adata_filtered.obs['donor_id'].isin(valid_donors_final)
+]
+print(f'Final number of donors after filtering: {len(valid_donors_final)}')
 
 # %%
 
-print("Loading data into memory (this can take a few minutes)...")
+print('Loading data into memory (this can take a few minutes)...')
 adata_loaded = adata_filtered.to_memory()
 
 # filter out genes with zero counts across all selected cells
-print("Filtering genes with zero counts...")
+print('Filtering genes with zero counts...')
 sc.pp.filter_genes(adata_loaded, min_counts=1)
 
 
@@ -180,11 +208,15 @@
 
 
 # %%
-adata_loaded.write(datadir /  f'dataset-{dataset_name}_subset-immune_filtered.h5ad')
+adata_loaded.write(
+    datadir / f'dataset-{dataset_name}_subset-immune_filtered.h5ad'
+)
 del adata_loaded
 
 # %%
-adata = ad.read_h5ad(datadir / f'dataset-{dataset_name}_subset-immune_filtered.h5ad')
+adata = ad.read_h5ad(
+    datadir / f'dataset-{dataset_name}_subset-immune_filtered.h5ad'
+)
 print(adata)
 
 # %%
@@ -206,37 +238,46 @@
 
 # %%
 # mitochondrial genes
-adata.var["mt"] = adata.var['feature_name'].str.startswith("MT-")
+adata.var['mt'] = adata.var['feature_name'].str.startswith('MT-')
 print(f"Number of mitochondrial genes: {adata.var['mt'].sum()}")
 
 # ribosomal genes
-adata.var["ribo"] = adata.var['feature_name'].str.startswith(("RPS", "RPL"))
+adata.var['ribo'] = adata.var['feature_name'].str.startswith(('RPS', 'RPL'))
 print(f"Number of ribosomal genes: {adata.var['ribo'].sum()}")
 
 # hemoglobin genes.
-adata.var["hb"] = adata.var['feature_name'].str.contains("^HB[^(P)]")
+adata.var['hb'] = adata.var['feature_name'].str.contains('^HB[^(P)]')
 print(f"Number of hemoglobin genes: {adata.var['hb'].sum()}")
 
 sc.pp.calculate_qc_metrics(
-    adata, qc_vars=["mt", "ribo", "hb"], inplace=True, percent_top=[20], log1p=True
+    adata,
+    qc_vars=['mt', 'ribo', 'hb'],
+    inplace=True,
+    percent_top=[20],
+    log1p=True,
 )
 
 
-
 # %% [markdown]
-# #### Visualization of distributions 
+# #### Visualization of distributions
 
 # %%
 
 # 1. Violin plots to see the distribution of QC metrics
 # Note: I am using the exact column names from your adata output
-p1 = sc.pl.violin(adata, ['total_counts', 'n_genes_by_counts', 'pct_counts_mt'],
-             jitter=0.4, multi_panel=True)
+p1 = sc.pl.violin(
+    adata,
+    ['total_counts', 'n_genes_by_counts', 'pct_counts_mt'],
+    jitter=0.4,
+    multi_panel=True,
+)
 
 # 2. Scatter plot to spot doublets and dying cells
 # High mito + low genes = dying cell
 # High counts + high genes = potential doublet
-sc.pl.scatter(adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt')
+sc.pl.scatter(
+    adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt'
+)
 
 # %% [markdown]
 # ####  Check Hemoglobin (RBC contamination)
@@ -245,9 +286,11 @@
 # %%
 
 plt.figure(figsize=(6, 4))
-sns.histplot(adata.obs['pct_counts_hb'], bins=50, log_scale=(False, True)) # Log scale y to see small RBC populations
-plt.title("Hemoglobin Content Distribution")
-plt.xlabel("% Hemoglobin Counts")
+sns.histplot(
+    adata.obs['pct_counts_hb'], bins=50, log_scale=(False, True)
+)   # Log scale y to see small RBC populations
+plt.title('Hemoglobin Content Distribution')
+plt.xlabel('% Hemoglobin Counts')
 plt.axvline(5, color='red', linestyle='--', label='5% Cutoff')
 plt.legend()
 plt.show()
@@ -266,30 +309,30 @@
 min_counts = 500      # Minimum UMIs
 
 # Doublets (Two cells stuck together)
-# Adjust this based on the scatter plot above. 
+# Adjust this based on the scatter plot above.
 # 4000-6000 is common for 10x Genomics data.
-max_genes = 6000      
+max_genes = 6000
 max_counts = 30000    # Very high counts often indicate doublets
 
 # Contaminants
 max_hb_pct = 5.0      # Remove Red Blood Cells (> 5% hemoglobin)
 
 # --- Apply Filtering ---
-print(f"Before filtering: {adata_qc.n_obs} cells")
+print(f'Before filtering: {adata_qc.n_obs} cells')
 
 # 1. Filter Low Quality & Doublets
 adata_qc = adata_qc[
-    (adata_qc.obs['n_genes_by_counts'] > min_genes) &
-    (adata_qc.obs['n_genes_by_counts'] < max_genes) &
-    (adata_qc.obs['total_counts'] > min_counts) &
-    (adata_qc.obs['total_counts'] < max_counts)
+    (adata_qc.obs['n_genes_by_counts'] > min_genes)
+    & (adata_qc.obs['n_genes_by_counts'] < max_genes)
+    & (adata_qc.obs['total_counts'] > min_counts)
+    & (adata_qc.obs['total_counts'] < max_counts)
 ]
 
 # 2. Filter Red Blood Cells (Hemoglobin)
 # Only run this if you want to remove RBCs
 adata_qc = adata_qc[adata_qc.obs['pct_counts_hb'] < max_hb_pct]
 
-print(f"After filtering: {adata_qc.n_obs} cells")
+print(f'After filtering: {adata_qc.n_obs} cells')
 
 # %% [markdown]
 # ### Perform doublet detection
@@ -308,7 +351,7 @@
 # 1. Check preliminary requirements
 # Scrublet needs RAW counts. Ensure adata.X contains integers, not log-normalized data.
 # If your main layer is already normalized, use adata.raw or a specific layer.
-print(f"Data shape before doublet detection: {adata_qc.shape}")
+print(f'Data shape before doublet detection: {adata_qc.shape}')
 
 # 2. Run Scrublet per donor
 # We split the data, run detection, and then recombine.
@@ -318,15 +361,15 @@
 # Get list of unique donors
 donors = adata_qc.obs['donor_id'].unique()
 
-print(f"Running Scrublet on {len(donors)} donors...")
+print(f'Running Scrublet on {len(donors)} donors...')
 
 for donor in donors:
     # Subset to current donor
     curr_adata = adata_qc[adata_qc.obs['donor_id'] == donor].copy()
-    
+
     # Skip donors with too few cells (Scrublet needs statistical power)
     if curr_adata.n_obs < 100:
-        print(f"Skipping donor {donor}: too few cells ({curr_adata.n_obs})")
+        print(f'Skipping donor {donor}: too few cells ({curr_adata.n_obs})')
         # We still add it back to keep the data, but mark as singlet (or filter later)
         curr_adata.obs['doublet_score'] = 0
         curr_adata.obs['predicted_doublet'] = False
@@ -337,14 +380,16 @@
     # expected_doublet_rate=0.06 is standard for 10x (approx ~0.8% per 1000 cells recovered)
     # If you loaded very heavily (20k cells/well), increase this to 0.10
     sc.pp.scrublet(curr_adata, expected_doublet_rate=0.06)
-    
+
     adatas_list.append(curr_adata)
 
 # 3. Merge back into one object
 adata_qc = sc.concat(adatas_list)
 
 # 4. Check results
-print(f"Detected {adata_qc.obs['predicted_doublet'].sum()} doublets across all donors.")
+print(
+    f"Detected {adata_qc.obs['predicted_doublet'].sum()} doublets across all donors."
+)
 print(adata_qc.obs['predicted_doublet'].value_counts())
 
 # %% [markdown]
@@ -365,8 +410,8 @@
 
 # Filter the data to keep only singlets (False)
 # write back to adata for simplicity
-adata = adata_qc[adata_qc.obs['predicted_doublet'] == False, :]
-print(f"Remaining cells: {adata.n_obs}")
+adata = adata_qc[not adata_qc.obs['predicted_doublet'], :]
+print(f'Remaining cells: {adata.n_obs}')
 
 # %% [markdown]
 # #### Save raw counts for later use
@@ -422,9 +467,6 @@
 
 # %%
 
-import scanpy as sc
-import pandas as pd
-
 
 # 2. Run Highly Variable Gene Selection
 # batch_key is critical here to find genes variable WITHIN donors, not BETWEEN them.
@@ -435,7 +477,7 @@
     batch_key='donor_id',
     span=0.8,  # helps avoid numerical issues with LOESS
     layer='counts',  # Change this to None if adata.X is raw counts
-    subset=False     # Keep False so we can manually filter the list below
+    subset=False,  # Keep False so we can manually filter the list below
 )
 
 # 3. Filter out "Nuisance" Genes from the HVG list
@@ -444,9 +486,10 @@
 
 # A. Identify TCR/BCR genes (starts with IG or TR)
 # Regex: IG or TR followed by a V, D, J, or C gene part
-import re
+
 immune_receptor_genes = [
-    name for name in adata.var_names 
+    name
+    for name in adata.var_names
     if re.match(r'^(IG[HKL]|TR[ABDG])[VDJC]', name)
 ]
 
@@ -460,7 +503,9 @@
 # Using set operations for speed
 adata.var.loc[adata.var_names.isin(genes_to_block), 'highly_variable'] = False
 
-print(f"Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.")
+print(
+    f'Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.'
+)
 print(f"Final HVG count: {adata.var['highly_variable'].sum()}")
 
 # 4. Proceed to PCA
@@ -471,18 +516,21 @@
 # ### Dimensionality reduction
 
 # %%
-import scanpy.external as sce
 
 # 1. Run Harmony
 # This adjusts the PCA coordinates to mix donors together while preserving biology.
 # It creates a new entry in obsm: 'X_pca_harmony'
 try:
-    sce.pp.harmony_integrate(adata, key='donor_id', basis='X_pca', adjusted_basis='X_pca_harmony')
+    sce.pp.harmony_integrate(
+        adata, key='donor_id', basis='X_pca', adjusted_basis='X_pca_harmony'
+    )
     use_rep = 'X_pca_harmony'
-    print("Harmony integration successful. Using corrected PCA.")
+    print('Harmony integration successful. Using corrected PCA.')
 except ImportError:
-    print("Harmony not installed. Proceeding with standard PCA (Warning: Batch effects may persist).")
-    print("To install: pip install harmony-pytorch")
+    print(
+        'Harmony not installed. Proceeding with standard PCA (Warning: Batch effects may persist).'
+    )
+    print('To install: pip install harmony-pytorch')
     use_rep = 'X_pca'
 
 # %%
@@ -504,7 +552,7 @@
 sc.tl.umap(adata, init_pos='X_pca_harmony')
 
 # %%
-sc.pl.umap(adata, color="total_counts")
+sc.pl.umap(adata, color='total_counts')
 
 
 # %% [markdown]
@@ -514,9 +562,14 @@
 # %%
 # 4. Run Clustering (Leiden algorithm)
 # We run multiple resolutions so you can choose the best one later.
-#sc.tl.leiden(adata, resolution=0.5, key_added='leiden_0.5')
-sc.tl.leiden(adata, resolution=1.0, key_added='leiden_1.0',
-    flavor="igraph", n_iterations=2)
+# sc.tl.leiden(adata, resolution=0.5, key_added='leiden_0.5')
+sc.tl.leiden(
+    adata,
+    resolution=1.0,
+    key_added='leiden_1.0',
+    flavor='igraph',
+    n_iterations=2,
+)
 
 
 # %%
@@ -525,23 +578,23 @@
 
 # %%
 # compute overlap between clusters and cell types
-contingency_table = pd.crosstab(adata.obs['leiden_1.0'], adata.obs['cell_type'])
+contingency_table = pd.crosstab(
+    adata.obs['leiden_1.0'], adata.obs['cell_type']
+)
 print(contingency_table)
 
 # %% [markdown]
 # ### Pseudobulking
 
 # %%
-import pandas as pd
-import numpy as np
-import anndata as ad
-from scipy import sparse
-from sklearn.preprocessing import OneHotEncoder
 
-def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols=None):
+
+def create_pseudobulk(
+    adata, group_col, donor_col, layer='counts', metadata_cols=None
+):
     """
     Sum raw counts for each (Donor, CellType) pair.
-    
+
     Parameters:
     -----------
     adata : AnnData
@@ -559,38 +612,38 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
     # 1. Create a combined key (e.g., "Bcell::Donor1")
     groups = adata.obs[group_col].astype(str)
     donors = adata.obs[donor_col].astype(str)
-    
+
     # Create a DataFrame to manage the unique combinations
     group_df = pd.DataFrame({'group': groups, 'donor': donors})
-    group_df['combined'] = group_df['group'] + "::" + group_df['donor']
-    
+    group_df['combined'] = group_df['group'] + '::' + group_df['donor']
+
     # 2. Build the Aggregation Matrix (One-Hot Encoding)
     enc = OneHotEncoder(sparse_output=True, dtype=np.float32)
     membership_matrix = enc.fit_transform(group_df[['combined']])
-    
+
     # 3. Aggregation (Summing)
     if layer is not None and layer in adata.layers:
         X_source = adata.layers[layer]
     else:
         X_source = adata.X
-        
+
     pseudobulk_X = membership_matrix.T @ X_source
-    
+
     # 4. Create the Obs Metadata for the new object
     unique_ids = enc.categories_[0]
-    
+
     # Split back into Donor and Cell Type
     obs_data = []
     for uid in unique_ids:
-        ctype, donor = uid.split("::")
+        ctype, donor = uid.split('::')
         obs_data.append({'cell_type': ctype, 'donor_id': donor})
-    
+
     pb_obs = pd.DataFrame(obs_data, index=unique_ids)
-    
+
     # 5. Count how many cells went into each sum
     cell_counts = np.array(membership_matrix.sum(axis=0)).flatten()
     pb_obs['n_cells'] = cell_counts.astype(int)
-    
+
     # 6. Add additional metadata columns
     if metadata_cols is not None:
         for col in metadata_cols:
@@ -599,48 +652,54 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
                 # from the original data for that donor
                 col_values = []
                 for uid in unique_ids:
-                    ctype, donor = uid.split("::")
+                    ctype, donor = uid.split('::')
                     # Get value from any cell with this donor (should all be the same)
                     donor_mask = adata.obs[donor_col] == donor
                     if donor_mask.any():
-                        col_values.append(adata.obs.loc[donor_mask, col].iloc[0])
+                        col_values.append(
+                            adata.obs.loc[donor_mask, col].iloc[0]
+                        )
                     else:
                         col_values.append(None)
                 pb_obs[col] = col_values
-    
+
     # 7. Assemble the AnnData
     pb_adata = ad.AnnData(X=pseudobulk_X, obs=pb_obs, var=adata.var.copy())
-    
+
     return pb_adata
 
+
 # --- Execute ---
 
 target_cluster_col = 'cell_type'
 
-print("Aggregating counts...")
+print('Aggregating counts...')
 pb_adata = create_pseudobulk(
-    adata, 
-    group_col=target_cluster_col, 
-    donor_col='donor_id', 
+    adata,
+    group_col=target_cluster_col,
+    donor_col='donor_id',
     layer='counts',
-    metadata_cols=['development_stage', 'sex']  # Add any other donor-level metadata here
+    metadata_cols=[
+        'development_stage',
+        'sex',
+    ],  # Add any other donor-level metadata here
 )
 
-print(f"Pseudobulk complete.")
-print(f"Original shape: {adata.shape}")
-print(f"Pseudobulk shape: {pb_adata.shape} (Samples x Genes)")
+print('Pseudobulk complete.')
+print(f'Original shape: {adata.shape}')
+print(f'Pseudobulk shape: {pb_adata.shape} (Samples x Genes)')
 print(pb_adata.obs.head())
 
 # %%
 min_cells = 10
-print(f"Dropping samples with < {min_cells} cells...")
+print(f'Dropping samples with < {min_cells} cells...')
 
 pb_adata = pb_adata[pb_adata.obs['n_cells'] >= min_cells].copy()
 
-print(f"Remaining samples: {pb_adata.n_obs}")
+print(f'Remaining samples: {pb_adata.n_obs}')
 
 # Optional: Visualize the 'depth' of your new pseudobulk samples
-import scanpy as sc
+
 pb_adata.obs['total_counts'] = np.array(pb_adata.X.sum(axis=1)).flatten()
 sc.pl.violin(pb_adata, ['n_cells', 'total_counts'], multi_panel=True)
 
@@ -652,26 +711,26 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # %%
 # first need to create 'age_scaled' variable from 'development_stage'
 # eg. from '19-year-old stage' to 19
-ages = pb_adata.obs['development_stage'].str.extract(r'(\d+)-year-old').astype(float)
+ages = (
+    pb_adata.obs['development_stage']
+    .str.extract(r'(\d+)-year-old')
+    .astype(float)
+)
 pb_adata.obs['age'] = ages
 
 
-
 # %%
-import pandas as pd
-from pydeseq2.dds import DeseqDataSet
-from pydeseq2.ds import DeseqStats
-from sklearn.preprocessing import StandardScaler
+
 
 # Assume pb_adata is your pseudobulk object from the previous step
 # 1. Extract counts and metadata
 counts_df = pd.DataFrame(
-    pb_adata.X.toarray(), 
-    index=pb_adata.obs_names, 
-    columns=[var_to_feature.get(var, var) for var in pb_adata.var_names]
+    pb_adata.X.toarray(),
+    index=pb_adata.obs_names,
+    columns=[var_to_feature.get(var, var) for var in pb_adata.var_names],
 )
 # remove duplicate columns if any
-counts_df = counts_df.loc[:,~counts_df.columns.duplicated()]
+counts_df = counts_df.loc[:, ~counts_df.columns.duplicated()]
 
 metadata = pb_adata.obs.copy()
 
@@ -695,16 +754,18 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 
 metadata_ct = metadata.loc[pb_adata_ct.obs_names].copy()
 
-assert 'age_scaled' in metadata_ct.columns, "age_scaled column missing in metadata"
-assert 'sex' in metadata_ct.columns, "sex column missing in metadata"
+assert (
+    'age_scaled' in metadata_ct.columns
+), 'age_scaled column missing in metadata'
+assert 'sex' in metadata_ct.columns, 'sex column missing in metadata'
 
 # 3. Initialize DeseqDataSet
 dds = DeseqDataSet(
     counts=counts_df_ct,
     metadata=metadata_ct,
-    design_factors=["age_scaled", "sex"],  # Use the scaled column
+    design_factors=['age_scaled', 'sex'],  # Use the scaled column
     refit_cooks=True,
-    n_cpus=8
+    n_cpus=8,
 )
 
 # 4. Run the fitting (Dispersions & LFCs)
@@ -715,21 +776,17 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # #### Compute statistics
 
 # %%
-model_vars = dds.varm["LFC"].columns
+model_vars = dds.varm['LFC'].columns
 contrast = np.array([0, 1, 0])
-print(f"contrast: {contrast}, model_vars: {model_vars}")
+print(f'contrast: {contrast}, model_vars: {model_vars}')
 
 # 5. Statistical Test (Wald Test)
 # Syntax for continuous: ["variable", "", ""]
-stat_res = DeseqStats(
-    dds, 
-    contrast=contrast
-)
+stat_res = DeseqStats(dds, contrast=contrast)
 
 stat_res.summary()
 
 
-
 # %%
 stat_res.run_wald_test()
 
@@ -747,7 +804,7 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # 3. Sort by effect size (Log2 Fold Change) to see top hits
 sigs = sigs.sort_values('log2FoldChange', ascending=False)
 
-print(f"Found {len(sigs)} significant genes.")
+print(f'Found {len(sigs)} significant genes.')
 print(sigs[['log2FoldChange', 'padj']].head())
 
 # %% [markdown]
@@ -756,12 +813,10 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # - what pathways are enriched in the differentially expressed genes?
 
 # %%
-import gseapy as gp
-import matplotlib.pyplot as plt
-import pandas as pd
+
 
 # 1. Prepare the Ranked List
-# We use the 'stat' column if available (best metric). 
+# We use the 'stat' column if available (best metric).
 # If 'stat' isn't there, approximate it with -log10(pvalue) * sign(log2FoldChange)
 rank_df = res[['stat']].dropna().sort_values('stat', ascending=False)
 
@@ -769,13 +824,13 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # We look at GO Biological Process and the "Hallmark" set (good for general states)
 # For immune specific, you can also add 'Reactome_2022' or 'KEGG_2021_Human'
 prerank_res = gp.prerank(
-    rnk=rank_df, 
+    rnk=rank_df,
     gene_sets=['MSigDB_Hallmark_2020'],
     threads=4,
-    min_size=10, # Min genes in pathway
-    max_size=1000, 
-    permutation_num=1000, # Reduce to 100 for speed if testing
-    seed=42
+    min_size=10,  # Min genes in pathway
+    max_size=1000,
+    permutation_num=1000,  # Reduce to 100 for speed if testing
+    seed=42,
 )
 
 # 3. View Results
@@ -783,14 +838,13 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # 'FDR q-val' = Significance
 terms = prerank_res.res2d.sort_values('NES', ascending=False)
 
-print("Top Upregulated Pathways:")
+print('Top Upregulated Pathways:')
 print(terms[['Term', 'NES', 'FDR q-val']].head(10))
 
-print("\nTop Downregulated Pathways:")
+print('\nTop Downregulated Pathways:')
 print(terms[['Term', 'NES', 'FDR q-val']].tail(10))
 
 
-
 # %% [markdown]
 # #### Create a plot for the results
 
@@ -812,21 +866,29 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 
 # 5. Create metrics for plotting
 # Direction based on NES sign
-combined_gsea['Direction'] = combined_gsea['NES'].apply(lambda x: 'Upregulated' if x > 0 else 'Downregulated')
+combined_gsea['Direction'] = combined_gsea['NES'].apply(
+    lambda x: 'Upregulated' if x > 0 else 'Downregulated'
+)
 
 # Significance for X-axis (-log10 FDR)
 # We add a tiny epsilon (1e-10) to avoid log(0) errors if FDR is exactly 0
-combined_gsea['FDR q-val'] = pd.to_numeric(combined_gsea['FDR q-val'], errors='coerce')
+combined_gsea['FDR q-val'] = pd.to_numeric(
+    combined_gsea['FDR q-val'], errors='coerce'
+)
 combined_gsea['log_FDR'] = -np.log10(combined_gsea['FDR q-val'] + 1e-10)
 
 # Gene Count for Dot Size
 # GSEApy stores the leading edge genes as a semi-colon separated string in 'Lead_genes'
-combined_gsea['Count'] = combined_gsea['Lead_genes'].apply(lambda x: len(str(x).split(';')))
+combined_gsea['Count'] = combined_gsea['Lead_genes'].apply(
+    lambda x: len(str(x).split(';'))
+)
 
 ## remove MSigDB label from Term
-combined_gsea['Term'] = combined_gsea['Term'].str.replace('MSigDB_Hallmark_2020__', '', regex=False)
+combined_gsea['Term'] = combined_gsea['Term'].str.replace(
+    'MSigDB_Hallmark_2020__', '', regex=False
+)
 
-print(f"Plotting {len(combined_gsea)} pathways.")
+print(f'Plotting {len(combined_gsea)} pathways.')
 print(combined_gsea[['Term', 'NES', 'FDR q-val', 'Count']].head())
 
 # %%
@@ -837,11 +899,11 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
     data=combined_gsea,
     x='log_FDR',
     y='Term',
-    hue='Direction',     # Color by NES Direction
-    size='Count',        # Size by number of Leading Edge genes
-    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue
-    sizes=(50, 400),     # Range of dot sizes
-    alpha=0.8
+    hue='Direction',  # Color by NES Direction
+    size='Count',  # Size by number of Leading Edge genes
+    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'},  # Red/Blue
+    sizes=(50, 400),  # Range of dot sizes
+    alpha=0.8,
 )
 
 # Customization
@@ -850,10 +912,15 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 plt.ylabel('')
 
 # Add a vertical line for significance (FDR < 0.05 => -log10(0.05) ~= 1.3)
-plt.axvline(-np.log10(0.25), color='gray', linestyle=':', label='FDR=0.25 (GSEA standard)')
+plt.axvline(
+    -np.log10(0.25),
+    color='gray',
+    linestyle=':',
+    label='FDR=0.25 (GSEA standard)',
+)
 plt.axvline(-np.log10(0.05), color='gray', linestyle='--', label='FDR=0.05')
 
-plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)
+plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.0)
 plt.grid(axis='x', alpha=0.3)
 plt.tight_layout()
 
@@ -874,30 +941,31 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
     (res['padj'] < 0.05) & (res['log2FoldChange'] < 0)
 ].index.tolist()
 
-print(f"Analyzing {len(up_genes)} upregulated and {len(down_genes)} downregulated genes.")
+print(
+    f'Analyzing {len(up_genes)} upregulated and {len(down_genes)} downregulated genes.'
+)
 
 # 2. Run Enrichr (Over-Representation Analysis)
 if len(up_genes) > 0:
     enr_up = gp.enrichr(
         gene_list=up_genes,
         gene_sets=['MSigDB_Hallmark_2020'],
-        organism='human', 
-        outdir=None
+        organism='human',
+        outdir=None,
     )
-    print("Upregulated Pathways:")
+    print('Upregulated Pathways:')
     print(enr_up.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))
-    
+
 
 if len(down_genes) > 0:
     enr_down = gp.enrichr(
         gene_list=down_genes,
         gene_sets=['MSigDB_Hallmark_2020'],
-        organism='human', 
-        outdir=None
+        organism='human',
+        outdir=None,
     )
-    print("Downregulated Pathways:")
+    print('Downregulated Pathways:')
     print(enr_down.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))
-    
 
 
 # %%
@@ -924,14 +992,15 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 
 # 5. Extract "Count" from the "Overlap" column (e.g., "5/200" -> 5)
 # This is used to size the dots
-combined['Gene_Count'] = combined['Overlap'].apply(lambda x: int(x.split('/')[0]))
+combined['Gene_Count'] = combined['Overlap'].apply(
+    lambda x: int(x.split('/')[0])
+)
 
-print(f"Plotting {len(combined)} pathways.")
+print(f'Plotting {len(combined)} pathways.')
 
 
 # %%
-import seaborn as sns
-import matplotlib.pyplot as plt
+
 
 plt.figure(figsize=(10, 8))
 
@@ -940,19 +1009,21 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
     data=combined,
     x='log_p',
     y='Term',
-    hue='Direction',    # Color by Up/Down
+    hue='Direction',  # Color by Up/Down
     size='Gene_Count',  # Size by number of genes in pathway
-    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue
-    sizes=(50, 400),    # Range of dot sizes
-    alpha=0.8
+    palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'},  # Red/Blue
+    sizes=(50, 400),  # Range of dot sizes
+    alpha=0.8,
 )
 
 # Customization
 plt.title('Top Enriched Pathways (Up vs Down)', fontsize=14)
 plt.xlabel('-log10(Adjusted P-value)', fontsize=12)
 plt.ylabel('')
-plt.axvline(-np.log10(0.05), color='gray', linestyle='--', alpha=0.5, label='p=0.05') # Significance threshold line
-plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)
+plt.axvline(
+    -np.log10(0.05), color='gray', linestyle='--', alpha=0.5, label='p=0.05'
+)   # Significance threshold line
+plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.0)
 plt.grid(axis='x', alpha=0.3)
 plt.tight_layout()
 
@@ -967,12 +1038,7 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 #
 
 # %%
-from sklearn.svm import LinearSVR
-from sklearn.model_selection import ShuffleSplit
-from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import r2_score, mean_absolute_error
-import pandas as pd
-import numpy as np
+
 
 # 1. Prepare features and target
 # Features: all genes from counts_df_ct + sex variable
@@ -985,9 +1051,9 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # Target: age
 y = metadata_ct['age'].values
 
-print(f"Feature matrix shape: {X.shape}")
-print(f"Number of samples: {len(y)}")
-print(f"Age range: {y.min():.1f} - {y.max():.1f} years")
+print(f'Feature matrix shape: {X.shape}')
+print(f'Number of samples: {len(y)}')
+print(f'Age range: {y.min():.1f} - {y.max():.1f} years')
 
 # 2. Set up ShuffleSplit cross-validation
 # Using 5 splits with 20% test size
@@ -1001,48 +1067,47 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 
 # 4. Train and evaluate model for each split
 for fold, (train_idx, test_idx) in enumerate(cv.split(X)):
-    print(f"\nFold {fold + 1}/5")
-    
+    print(f'\nFold {fold + 1}/5')
+
     # Split data
     X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
     y_train, y_test = y[train_idx], y[test_idx]
-    
+
     # Scale features (important for SVR)
     scaler = StandardScaler()
     X_train_scaled = scaler.fit_transform(X_train)
     X_test_scaled = scaler.transform(X_test)
-    
+
     # Train Linear SVR
     # C parameter controls regularization (smaller = more regularization)
     model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')
     model.fit(X_train_scaled, y_train)
-    
+
     # Predict on test set
     y_pred = model.predict(X_test_scaled)
-    
+
     # Calculate metrics
     r2 = r2_score(y_test, y_pred)
     mae = mean_absolute_error(y_test, y_pred)
-    
+
     r2_scores.append(r2)
     mae_scores.append(mae)
     predictions_list.extend(y_pred)
     actual_list.extend(y_test)
-    
-    print(f"  R² Score: {r2:.3f}")
-    print(f"  MAE: {mae:.2f} years")
+
+    print(f'  R² Score: {r2:.3f}')
+    print(f'  MAE: {mae:.2f} years')
 
 # 5. Summary statistics
-print("\n" + "="*50)
-print("CROSS-VALIDATION RESULTS")
-print("="*50)
-print(f"R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}")
-print(f"MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years")
-print("="*50)
+print('\n' + '=' * 50)
+print('CROSS-VALIDATION RESULTS')
+print('=' * 50)
+print(f'R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}')
+print(f'MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years')
+print('=' * 50)
 
 # %%
 # Visualize predictions vs actual ages
-import matplotlib.pyplot as plt
 
 plt.figure(figsize=(8, 6))
 
@@ -1052,12 +1117,20 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
 # Add diagonal line (perfect predictions)
 min_age = min(min(actual_list), min(predictions_list))
 max_age = max(max(actual_list), max(predictions_list))
-plt.plot([min_age, max_age], [min_age, max_age], 'r--', linewidth=2, label='Perfect Prediction')
+plt.plot(
+    [min_age, max_age],
+    [min_age, max_age],
+    'r--',
+    linewidth=2,
+    label='Perfect Prediction',
+)
 
 plt.xlabel('Actual Age (years)', fontsize=12)
 plt.ylabel('Predicted Age (years)', fontsize=12)
-plt.title(f'Age Prediction Performance\nR² = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years', 
-          fontsize=14)
+plt.title(
+    f'Age Prediction Performance\nR² = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years',
+    fontsize=14,
+)
 plt.legend()
 plt.grid(alpha=0.3)
 plt.tight_layout()
@@ -1081,39 +1154,45 @@ def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols
     # Split data
     X_train, X_test = X_baseline.iloc[train_idx], X_baseline.iloc[test_idx]
     y_train, y_test = y[train_idx], y[test_idx]
-    
+
     # Scale features
     scaler = StandardScaler()
     X_train_scaled = scaler.fit_transform(X_train)
     X_test_scaled = scaler.transform(X_test)
-    
+
     # Train Linear SVR
     model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')
     model.fit(X_train_scaled, y_train)
-    
+
     # Predict on test set
     y_pred = model.predict(X_test_scaled)
-    
+
     # Calculate metrics
     r2 = r2_score(y_test, y_pred)
     mae = mean_absolute_error(y_test, y_pred)
-    
+
     baseline_r2_scores.append(r2)
     baseline_mae_scores.append(mae)
 
 # Summary comparison
-print("="*60)
-print("MODEL COMPARISON")
-print("="*60)
-print(f"Full Model (Genes + Sex):")
-print(f"  R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}")
-print(f"  MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years")
-print(f"\nBaseline Model (Sex Only):")
-print(f"  R² Score: {np.mean(baseline_r2_scores):.3f} ± {np.std(baseline_r2_scores):.3f}")
-print(f"  MAE: {np.mean(baseline_mae_scores):.2f} ± {np.std(baseline_mae_scores):.2f} years")
-print(f"\nImprovement:")
-print(f"  ΔR²: {np.mean(r2_scores) - np.mean(baseline_r2_scores):.3f}")
-print(f"  ΔMAE: {np.mean(baseline_mae_scores) - np.mean(mae_scores):.2f} years")
-print("="*60)
+print('=' * 60)
+print('MODEL COMPARISON')
+print('=' * 60)
+print('Full Model (Genes + Sex):')
+print(f'  R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}')
+print(f'  MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years')
+print('\nBaseline Model (Sex Only):')
+print(
+    f'  R² Score: {np.mean(baseline_r2_scores):.3f} ± {np.std(baseline_r2_scores):.3f}'
+)
+print(
+    f'  MAE: {np.mean(baseline_mae_scores):.2f} ± {np.std(baseline_mae_scores):.2f} years'
+)
+print('\nImprovement:')
+print(f'  ΔR²: {np.mean(r2_scores) - np.mean(baseline_r2_scores):.3f}')
+print(
+    f'  ΔMAE: {np.mean(baseline_mae_scores) - np.mean(mae_scores):.2f} years'
+)
+print('=' * 60)
 
 # %%

From 1267abab1814be47cd200f4059af3d2492f095fb Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 08:54:51 -0800
Subject: [PATCH 30/87] add coding prefernces

---
 CLAUDE.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/CLAUDE.md b/CLAUDE.md
index 7512e7a..5e0589a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -80,3 +80,14 @@ pre-commit run --all-files
 - Code examples should follow PEP8
 - Avoid introducing new dependencies when possible
 - Custom words for codespell are in `project-words.txt`
+
+## Coding guidelines
+
+## Notes for Development
+
+- Think about the problem before generating code.
+- Write code that is clean and modular. Prefer shorter functions/methods over longer ones.
+- Prefer reliance on widely used packages (such as numpy, pandas, and scikit-learn); avoid unknown packages from Github.
+- Do not include *any* code in `__init__.py` files.
+- Use pytest for testing.
+- Use functions rather than classes for tests. Use pytest fixtures to share resources between tests.

From 55bfa7f8a685ad9a83f26f6897a440a5ada6f8ac Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 08:55:53 -0800
Subject: [PATCH 31/87] intermediate progress

---
 book/workflows.md | 127 ++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 118 insertions(+), 9 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index 79c77ef..edae351 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -1,6 +1,6 @@
 # Workflow Management
 
-In most parts of science today, data processing and analysis comprises many different steps.  We will refer to such a set of steps as a computational *workflow* (or, interchangeably, *pipeline*). If you have been doing science for very long, you have very likely encountered a *mega-script* that implements such a workflow. Usually written in a scripting language like *Bash*, this is a script that may be hundreds or even thousands of lines long that runs a single workflow from start to end.  Often these scripts are handed down to new trainees over generations, such that users become afraid to make any changes lest the entire house of cards comes crashing down.  I think that most of us can agree that this is not an optimal workflow, and in this chapter I will discuss in detail how to move from a mega-script to a workflow that will meet all of the requirements that are required to provide robust and reliable answers to our scientific questions.
+In most parts of science today, data processing and analysis comprises many different steps.  We will refer to such a set of steps as a computational *workflow*. If you have been doing science for very long, you have very likely encountered a *mega-script* that implements such a workflow. Usually written in a scripting language like *Bash*, this is a script that may be hundreds or even thousands of lines long that runs a single workflow from start to end.  Often these scripts are handed down to new trainees over generations, such that users become afraid to make any changes lest the entire house of cards comes crashing down.  I think that most of us can agree that this is not an optimal workflow, and in this chapter I will discuss in detail how to move from a mega-script to a workflow that will meet all of the requirements that are required to provide robust and reliable answers to our scientific questions.
 
 ## What do we want from a scientific workflow?
 
@@ -30,19 +30,128 @@ Finally, we care about the *efficiency* of the workflow implementation. This inc
 
 It's worth noting that these different desiderata will sometimes conflict with one another (such as configurability versus maintainability), and that no workflow will be perfect.  
 
-## An example workflow
+### Pipelines versus workflows
 
-In this chapter I will use a running example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features outlined above.  
+The terms *workflow* and *pipeline* are sometimes used interchangeable, but in this chapter I will use them to refer to different kinds of applications. I will use *workflow* as the more general term to refer to any set of analysis procedures that are implemented as separate modules.  I will use the term *pipeline* to refer more specifically to a data analysis workflow where the several operations are combined into a single command through the use of *pipes*, which are a syntactic construct that feed the output of one process directly into the next process as input.  Some readers may be familiar with pipes from the UNIX filesystem, where they are represented by the vertical bar "|".  For example, let's say that we had a log file that contains the follow entries:
 
+```bash
+2024-01-15 10:23:45 ERROR: Database connection failed
+2024-01-15 10:24:12 ERROR: Invalid user input
+2024-01-15 10:25:33 ERROR: Database connection failed
+2024-01-15 10:26:01 INFO: Request processed
+2024-01-15 10:27:15 ERROR: Database connection failed
+```
+
+and that we wanted to generate a summary of errors. We could use the following pipeline:
+
+```bash
+grep "ERROR" app.log | sed 's/.*ERROR: //' | sort | uniq -c | sort -rn > error_summary.txt
+
+```
+
+where:
+
+- `grep "ERROR" app.log` extracts line containing the word "ERROR"
+- `sed 's/.*ERROR: //'` replaces everything up to the actual message with an empty string
+- `sort` sorts the rows alphabetically
+- `uniq -c` counts the number of appearances of each unique error message
+- `sort -rn`  sorts the rows in numerical order
+- `> error_summary.txt` redirects the output into a file called `error_summary.txt`
+
+#### Method chaining
+
+One way that simple pipelines can be built in Python is using *method chaining*, where the output of one class method is redirected into the next class method.  This is commonly used to perform data transformations in `pandas`, as it allows composing multiple transformations into a single command.  As an example, we will work with the Eisenberg et al. dataset that we used in a previous chapter, to compute the probability of having ever been arrested separately for males and females in the sample. To do this we need to perform a number of operations:
+
+- drop any observations that have missing values for the `Sex` or `ArrestedChargedLifeCount` variables
+- replace the numeric values in the `Sex` variable with text labels
+- create a new variable called `EverArrested` that binarizes the counts in the ArrestedChargedLifeCount variable
+- group the data by the `Sex` variable
+- select the column that we want to compute the mean of (`EverArrested`)
+- compute the mean
+
+We can do this in a single command using method chaining in `pandas`.  It's useful to format the code in a way that makes the pipeline steps explicit, by putting parentheses around the operation; in Python, any commands within parentheses are combined into a single command, which can be useful for making complex code more readable:
+
+```python
+arrest_stats_by_sex = (df
+    .dropna(subset=['Sex', 'ArrestedChargedLifeCount'])
+    .replace({'Sex': {0: 'Male', 1: 'Female'}})
+    .assign(EverArrested=lambda x: (x['ArrestedChargedLifeCount'] > 0).astype(int))
+    .groupby('Sex')
+    ['EverArrested']
+    .mean()
+)
+print(arrest_stats_by_sex)
+```
+```bash
+Sex
+Female    0.156489
+Male      0.274131
+Name: EverArrested, dtype: float64
+```
+
+Note that `pandas` data frames also include an explicit `.pipe` method that allows using arbitrary functions within a pipeline.  While these kinds of pipelines can be useful for simple data processing operations, they can become very difficult to debug, so I would generally avoid using complex functions within a method chain.
+
+
+## An example of a complex workflow
+
+In this chapter we will focus primarily on complex workflows that have many stages. I will use a running example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features outlined above.  For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from about 1.3 million immune system cells for about 35K transcripts.  I chose this particular example for several reasons:
+
+- It is a realistic example of a workflow that a researcher might actually perform.
+- The data are large enough to call for a real workflow management scheme, but small enough to be processed on a single laptop (assuming it has decent memory). 
+- The workflow has many different steps, some of which can take a significant amount of time (over 30 minutes)
+- There is an established Python library ([scanpy](https://scanpy.readthedocs.io/en/stable/)) that implements the necessary workflow components.
+- It's an example outside of my own research domain, to help demonstrate the applicability of the book's ideas across a broader set of data types.
+
+### Starting point: One huge notebook
+
+I developed the initial version of this workflow in a way that many researchers would do so: By creating a Jupyter notebook that implements the entire workflow, which can be found [here]().  Although I don't usually prefer to do code generation using a chatbot, I did most of the coding for this example using the Google Gemini 3.0 chatbot, for a couple of reasons.  First, this model seemed particularly knowledgeable about this kind of analysis and the relevant packages.  Second, I found it useful to read the commentary about why particular analysis steps were being selected.  For debugging I used a mixture of the Gemini 3.0 chatbot and the VSCode Copilot agent, depending on the nature of the problem; for problems specific to the RNA-seq analysis tools I used Gemini, while for standard Python/Pandas issues I used Copilot. The total execution time for this notebook is about two hours on an M3 Max Macbook Pro.  
+
+#### The problem of in-place operations
+
+What I found as I developed the workflow is that I increasingly ran into problems that arose because the state of particular objects had changed.  This occurred for two reasons at different points.  In some cases it occurred because I saved a new version of the object to the same name, resulting in an object with different structure than before.  
+
+#### Converting from Jupyter notebook to a runnable python script
+
+- had to prevent plots from being displayed because this blocked execution
+- used copilot to find and fix all plotting commands to save them to file rather than showing
+
+## Decomposing a complex workflow
+
+The first thing we need to do with a large monolithic workflow is to determine how to decompose it into coherent modules.  There are various reasons that one might choose a particular breakpoint between modules.  First and foremost, there are usually different stages that do conceptually different things.  In our example, we can break the workflow into several high-level processes:
+
+- Data (down)loading
+- Data filtering (removing subjects or cell types with insufficient observations)
+- Quality control
+    - identifying bad cells on the basis of mitochondrial, ribosomal, or hemoglobin genes or hemoglobin contamination
+    - identifying "doublets" (multiple cells identified as one)
+- Preprocessing
+    - Count normalization
+    - Log transformation
+    - Identification of high-variance features
+    - Filtering of nuisance genes
+- Dimensionality reduction
+- UMAP generation
+- Clustering
+- Pseudobulking
+- Differential expression analysis
+- Pathway enrichment analysis (GSEA)
+- Overrepresentation analysis (Enrichr)
+- Predictive modeling
+
+In addition to a conceptual breakdown, there are also other reasons that one might to further decompose the workflow:
+
+- There may be points where one might need to restart the computation (e.g. due to computational cost)
+- There may be sections where one might wish to swap in a new method or different parameterization
+- There may be points where the output could be reusable elsewhere
+
+
+
+## Stateless workflows
+
+I asked Claude Code to help modularize the monolithic workflow, using a prompt that provided the conceptual breakdown described above.  The resulting code (found at XXX) ran correctly, but crashed about two hours into the process due to a resource issue that appeared to be due to asking for too many CPU cores in the differential expression analysis.  This left me in the situation of having to rerun the entire two hours of preliminary workflow simply to get to a point where I could test my fix for the differential expression component, which is not a particularly efficient way of coding.  The problem here is that the workflow execution is *stateful*, in the sense that the previous steps need to be rerun prior to performing the current step in order to establish the required objects in memory.  The solution to this problem is to implement the workflow in a *stateless* way, which doesn't require that earlier steps be rerun if they have already been completed.  One way to do this is by implementing a process called *checkpointing*, in which intermediate results are stored for each step.  These can then be used to start the workflow at any point without having to rerun all of the previous steps.  
 
-## Breaking a workflow into stages
 
-good breakpoints between workflow modules include:
 
-- conceptual logic - different stages do different things 
-- points where one might need to restart the computation (e.g. due to computational cost)
-- sections where one might wish to swap in a new method or different parameterization
-- points where the output could be reusable elsewhere
 
 the workflow should be stateless when possible
 

From 10b4c998fd1688ae2f88c7d93df2a7dd0a45d392 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 08:56:41 -0800
Subject: [PATCH 32/87] add deps

---
 pyproject.toml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 49d70ca..50c0f88 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -35,7 +35,6 @@ dependencies = [
     "pre-commit>=4.2.0",
     "mdnewline>=0.1.3",
     "anthropic>=0.61.0",
-    "rpy2>=3.6.4",
     "nibabel>=5.3.2",
     "fastparquet>=2024.11.0",
     "templateflow>=25.1.1",
@@ -47,7 +46,6 @@ dependencies = [
     "datalad-osf>=0.3.0",
     "pymongo[srv]>=4.15.4",
     "mysql-connector-python>=9.5.0",
-    "mariadb>=1.1.14",
     "biopython>=1.86",
     "neo4j>=6.0.3",
     "tqdm>=4.66.5",
@@ -76,6 +74,11 @@ dependencies = [
     "fastcluster>=1.3.0",
     "scikit-misc>=0.5.2",
     "harmony-pytorch>=0.1.8",
+    "pydeseq2>=0.5.3",
+    "gseapy>=1.1.11",
+    "ipython>=9.8.0",
+    "harmonypy>=0.0.10",
+    "rpy2>=3.6.4",
 ]
 
 [build-system]

From 84138d344a45b47ef6232983af16bf7729e81e7b Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 08:56:50 -0800
Subject: [PATCH 33/87] add deps

---
 uv.lock | 281 ++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 182 insertions(+), 99 deletions(-)

diff --git a/uv.lock b/uv.lock
index 51b298c..996c206 100644
--- a/uv.lock
+++ b/uv.lock
@@ -394,17 +394,19 @@ dependencies = [
     { name = "fastparquet" },
     { name = "fmriprep-docker" },
     { name = "gprofiler-official" },
+    { name = "gseapy" },
     { name = "h5py" },
     { name = "harmony-pytorch" },
+    { name = "harmonypy" },
     { name = "hypothesis" },
     { name = "icecream" },
     { name = "igraph" },
+    { name = "ipython" },
     { name = "jupyter" },
     { name = "jupyter-book" },
     { name = "jupytext" },
     { name = "leidenalg" },
     { name = "linkcheckmd" },
-    { name = "mariadb" },
     { name = "matplotlib" },
     { name = "mdnewline" },
     { name = "mne" },
@@ -424,6 +426,7 @@ dependencies = [
     { name = "pickleshare" },
     { name = "pre-commit" },
     { name = "pyarrow" },
+    { name = "pydeseq2" },
     { name = "pygithub" },
     { name = "pymongo" },
     { name = "pyppeteer" },
@@ -469,17 +472,19 @@ requires-dist = [
     { name = "fastparquet", specifier = ">=2024.11.0" },
     { name = "fmriprep-docker", specifier = ">=25.2.3" },
     { name = "gprofiler-official", specifier = ">=1.0.0" },
+    { name = "gseapy", specifier = ">=1.1.11" },
     { name = "h5py", specifier = ">=3.15.1" },
     { name = "harmony-pytorch", specifier = ">=0.1.8" },
+    { name = "harmonypy", specifier = ">=0.0.10" },
     { name = "hypothesis", specifier = ">=6.115.3" },
     { name = "icecream", specifier = ">=2.1.4" },
     { name = "igraph", specifier = ">=1.0.0" },
+    { name = "ipython", specifier = ">=9.8.0" },
     { name = "jupyter", specifier = ">=1.1.1" },
     { name = "jupyter-book", specifier = ">=1.0.2" },
     { name = "jupytext", specifier = ">=1.16.4" },
     { name = "leidenalg", specifier = ">=0.11.0" },
     { name = "linkcheckmd", specifier = ">=1.4.0" },
-    { name = "mariadb", specifier = ">=1.1.14" },
     { name = "matplotlib", specifier = ">=3.9.2" },
     { name = "mdnewline", specifier = ">=0.1.3" },
     { name = "mne", specifier = ">=1.11.0" },
@@ -499,6 +504,7 @@ requires-dist = [
     { name = "pickleshare", specifier = ">=0.7.5" },
     { name = "pre-commit", specifier = ">=4.2.0" },
     { name = "pyarrow", specifier = ">=22.0.0" },
+    { name = "pydeseq2", specifier = ">=0.5.3" },
     { name = "pygithub", specifier = ">=2.4.0" },
     { name = "pymongo", extras = ["srv"], specifier = ">=4.15.4" },
     { name = "pyppeteer", specifier = ">=2.0.0" },
@@ -539,16 +545,16 @@ wheels = [
 
 [[package]]
 name = "bidsschematools"
-version = "1.1.3"
+version = "1.1.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "acres" },
     { name = "click" },
     { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f6/e4/98ecf10fb56d0967619c7d03e78a895adce7546f24d6af6008297f07ba74/bidsschematools-1.1.3.tar.gz", hash = "sha256:a3df5a4dfa085cd3acd00be2f0770019eaa5c4e6827763dad522d3ebef735b3a", size = 1754718, upload-time = "2025-11-18T12:50:59.759Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/1c/c9464d519150e88c1a5fdd298384313fff067405f58f08dcd9372561b933/bidsschematools-1.1.4.tar.gz", hash = "sha256:843b611050a2d294dde64e7774e0fb998f57cf96fe44127ac7e44b2bdaa3f750", size = 1757344, upload-time = "2025-12-19T01:06:54.75Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/40/e91d484e66e24c684baac044ff703c9a4cec833be00cad4b21e8cb9d8f8d/bidsschematools-1.1.3-py3-none-any.whl", hash = "sha256:01334729cb84bb7c0f7a4ee026debfd562fbabc52e5dce3029a1e08fa9b8cce4", size = 180659, upload-time = "2025-11-18T12:50:57.27Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/ab/9f28c6637450c03ff0a950b92853262d65cc95fe9b595310483ec172a512/bidsschematools-1.1.4-py3-none-any.whl", hash = "sha256:8aa97c035ebff3d25b85a3e7554211e094333ff0887defeda4845d5477bd0394", size = 182396, upload-time = "2025-12-19T01:06:51.355Z" },
 ]
 
 [[package]]
@@ -666,30 +672,30 @@ wheels = [
 
 [[package]]
 name = "boto3"
-version = "1.42.12"
+version = "1.42.14"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore" },
     { name = "jmespath" },
     { name = "s3transfer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/98/66/ffe9623d64e97800ff6bac26953cd9ef99410fb864a0b26a0ea2e09b97f0/boto3-1.42.12.tar.gz", hash = "sha256:649b134d25b278c24fcc8b3f94519de3884283b7848dc32f42b0ffdd9d19ce99", size = 112868, upload-time = "2025-12-17T20:30:42.394Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/72/e236ca627bc0461710685f5b7438f759ef3b4106e0e08dda08513a6539ab/boto3-1.42.14.tar.gz", hash = "sha256:a5d005667b480c844ed3f814a59f199ce249d0f5669532a17d06200c0a93119c", size = 112825, upload-time = "2025-12-19T20:27:15.325Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3e/8b/20a90c75499e3c3a8e3eb5607d930c723577ef8c64968b9be6b743f18158/boto3-1.42.12-py3-none-any.whl", hash = "sha256:8112e1beb5978bb455ea4b41a9ef26fc408f6340d8ff69ef93dded4f80fd53e9", size = 140573, upload-time = "2025-12-17T20:30:40.063Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ba/c657ea6f6d63563cc46748202fccd097b51755d17add00ebe4ea27580d06/boto3-1.42.14-py3-none-any.whl", hash = "sha256:bfcc665227bb4432a235cb4adb47719438d6472e5ccbf7f09512046c3f749670", size = 140571, upload-time = "2025-12-19T20:27:13.316Z" },
 ]
 
 [[package]]
 name = "botocore"
-version = "1.42.12"
+version = "1.42.14"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jmespath" },
     { name = "python-dateutil" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a0/b6/9b7988a8476712cdbfeeb68c733933005465c85ebf0ee469a6ea5ca3415c/botocore-1.42.12.tar.gz", hash = "sha256:1f9f63c3d6bb1f768519da30d6018706443c5d8af5472274d183a4945f3d81f8", size = 14879004, upload-time = "2025-12-17T20:30:29.542Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/3f/50c56f093c2c6ce6de1f579726598db1cf9a9cccd3bf8693f73b1cf5e319/botocore-1.42.14.tar.gz", hash = "sha256:cf5bebb580803c6cfd9886902ca24834b42ecaa808da14fb8cd35ad523c9f621", size = 14910547, upload-time = "2025-12-19T20:27:04.431Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8f/73/22764d0a17130b7d95b2a4104607e6db5487a0e5afb68f5691260ae9c3dc/botocore-1.42.12-py3-none-any.whl", hash = "sha256:4f163880350f6d831857ce5d023875b7c6534be862e5affd9fcf82b8d1ab3537", size = 14552878, upload-time = "2025-12-17T20:30:24.671Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/94/67a78a8d08359e779894d4b1672658a3c7fcce216b48f06dfbe1de45521d/botocore-1.42.14-py3-none-any.whl", hash = "sha256:efe89adfafa00101390ec2c371d453b3359d5f9690261bc3bd70131e0d453e8e", size = 14583247, upload-time = "2025-12-19T20:27:00.54Z" },
 ]
 
 [[package]]
@@ -1376,7 +1382,7 @@ wheels = [
 
 [[package]]
 name = "fastapi"
-version = "0.125.0"
+version = "0.127.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-doc" },
@@ -1384,9 +1390,9 @@ dependencies = [
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/17/71/2df15009fb4bdd522a069d2fbca6007c6c5487fce5cb965be00fc335f1d1/fastapi-0.125.0.tar.gz", hash = "sha256:16b532691a33e2c5dee1dac32feb31dc6eb41a3dd4ff29a95f9487cb21c054c0", size = 370550, upload-time = "2025-12-17T21:41:44.15Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0c/02/2cbbecf6551e0c1a06f9b9765eb8f7ae126362fbba43babbb11b0e3b7db3/fastapi-0.127.0.tar.gz", hash = "sha256:5a9246e03dcd1fdb19f1396db30894867c1d630f5107dc167dcbc5ed1ea7d259", size = 369269, upload-time = "2025-12-21T16:47:16.393Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/34/2f/ff2fcc98f500713368d8b650e1bbc4a0b3ebcdd3e050dcdaad5f5a13fd7e/fastapi-0.125.0-py3-none-any.whl", hash = "sha256:2570ec4f3aecf5cca8f0428aed2398b774fcdfee6c2116f86e80513f2f86a7a1", size = 112888, upload-time = "2025-12-17T21:41:41.286Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/fa/6a27e2ef789eb03060abb43b952a7f0bd39e6feaa3805362b48785bcedc5/fastapi-0.127.0-py3-none-any.whl", hash = "sha256:725aa2bb904e2eff8031557cf4b9b77459bfedd63cae8427634744fd199f6a49", size = 112055, upload-time = "2025-12-21T16:47:14.757Z" },
 ]
 
 [[package]]
@@ -1460,7 +1466,7 @@ wheels = [
 
 [[package]]
 name = "fastparquet"
-version = "2024.11.0"
+version = "2025.12.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cramjam" },
@@ -1469,16 +1475,15 @@ dependencies = [
     { name = "packaging" },
     { name = "pandas" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b4/66/862da14f5fde4eff2cedc0f51a8dc34ba145088e5041b45b2d57ac54f922/fastparquet-2024.11.0.tar.gz", hash = "sha256:e3b1fc73fd3e1b70b0de254bae7feb890436cb67e99458b88cb9bd3cc44db419", size = 467192, upload-time = "2024-11-15T19:30:10.413Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1e/ad/87f7f5750685e8e0a359d732c85332481ba9b5723af579f8755f81154d0b/fastparquet-2025.12.0.tar.gz", hash = "sha256:85f807d3846c7691855a68ed7ff6ee40654b72b997f5b1199e6310a1e19d1cd5", size = 480045, upload-time = "2025-12-18T16:22:22.016Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/76/068ac7ec9b4fc783be21a75a6a90b8c0654da4d46934d969e524ce287787/fastparquet-2024.11.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:dbad4b014782bd38b58b8e9f514fe958cfa7a6c4e187859232d29fd5c5ddd849", size = 915968, upload-time = "2024-11-12T20:37:52.861Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/9e/6d3b4188ad64ed51173263c07109a5f18f9c84a44fa39ab524fca7420cda/fastparquet-2024.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:403d31109d398b6be7ce84fa3483fc277c6a23f0b321348c0a505eb098a041cb", size = 685399, upload-time = "2024-11-12T20:37:54.899Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/6c/809220bc9fbe83d107df2d664c3fb62fb81867be8f5218ac66c2e6b6a358/fastparquet-2024.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cbbb9057a26acf0abad7adf58781ee357258b7708ee44a289e3bee97e2f55d42", size = 1758557, upload-time = "2024-11-12T20:37:56.553Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/2c/b3b3e6ca2e531484289024138cd4709c22512b3fe68066d7f9849da4a76c/fastparquet-2024.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63e0e416e25c15daa174aad8ba991c2e9e5b0dc347e5aed5562124261400f87b", size = 1781052, upload-time = "2024-11-12T20:37:58.339Z" },
-    { url = "https://files.pythonhosted.org/packages/21/fe/97ed45092d0311c013996dae633122b7a51c5d9fe8dcbc2c840dc491201e/fastparquet-2024.11.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e2d7f02f57231e6c86d26e9ea71953737202f20e948790e5d4db6d6a1a150dc", size = 1715797, upload-time = "2024-11-12T20:38:00.694Z" },
-    { url = "https://files.pythonhosted.org/packages/24/df/02fa6aee6c0d53d1563b5bc22097076c609c4c5baa47056b0b4bed456fcf/fastparquet-2024.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:fbe4468146b633d8f09d7b196fea0547f213cb5ce5f76e9d1beb29eaa9593a93", size = 1795682, upload-time = "2024-11-12T20:38:02.38Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/25/f4f87557589e1923ee0e3bebbc84f08b7c56962bf90f51b116ddc54f2c9f/fastparquet-2024.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:29d5c718817bcd765fc519b17f759cad4945974421ecc1931d3bdc3e05e57fa9", size = 1857842, upload-time = "2024-11-12T20:38:04.196Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/f9/98cd0c39115879be1044d59c9b76e8292776e99bb93565bf990078fd11c4/fastparquet-2024.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:74a0b3c40ab373442c0fda96b75a36e88745d8b138fcc3a6143e04682cbbb8ca", size = 673269, upload-time = "2024-12-11T21:22:48.073Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/b2/229a4482d80a737d0fe6706c4f93adb631f42ec5b0a2b154247d63bb48fe/fastparquet-2025.12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:27b1cf0557ddddbf0e28db64d4d3bea1384be1d245b2cef280d001811e3600fe", size = 896986, upload-time = "2025-12-18T21:53:52.611Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c2/953117c43bf617379eff79ce8a2318ef49f7f41908faade051fa12281ac8/fastparquet-2025.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9356c59e48825d61719960ccb9ce799ad5cd1b04f2f13368f03fab1f3c645d1e", size = 687642, upload-time = "2025-12-18T21:54:13.594Z" },
+    { url = "https://files.pythonhosted.org/packages/92/35/41deaa9a4fc9ab6c00f3b49afe56cbafee13a111032aa41f23d077b69ad6/fastparquet-2025.12.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c4c92e299a314d4b542dc881eeb4d587dc075c0a5a86c07ccf171d8852e9736d", size = 1764260, upload-time = "2025-12-18T21:58:11.197Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/0f/a229b3f699aaccc7b5ec3f5e21cff8aa99bc199499bff08cf38bc6ab52c6/fastparquet-2025.12.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4881dc91c7e6d1d08cda9968ed1816b0c66a74b1826014c26713cad923aaca71", size = 1810920, upload-time = "2025-12-18T21:57:31.514Z" },
+    { url = "https://files.pythonhosted.org/packages/90/c2/ca76afca0c2debef368a42a701d501e696490e0a7138f0337709a724b189/fastparquet-2025.12.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d8d70d90614f19752919037c4a88aaaeda3cd7667aeb54857c48054e2a9e3588", size = 1819692, upload-time = "2025-12-18T21:58:43.095Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/41/f235c0d8171f6676b9d4fb8468c781fbe7bf90fed2c4383f2d8d82e574db/fastparquet-2025.12.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e2ccf387f629cb11b72fec6f15a55e0f40759b47713124764a9867097bcd377", size = 1784357, upload-time = "2025-12-18T21:58:13.258Z" },
+    { url = "https://files.pythonhosted.org/packages/29/7e/c86bf33b363cf5a1ad71d3ebd4a352131ba99566c78aa58d9e56c98526ba/fastparquet-2025.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1978e7f3c32044f2f7a0b35784240dfc3eaeb8065a879fa3011c832fea4e7037", size = 1815777, upload-time = "2025-12-18T21:58:44.432Z" },
 ]
 
 [[package]]
@@ -1506,11 +1511,10 @@ wheels = [
 
 [[package]]
 name = "flatbuffers"
-version = "25.9.23"
+version = "25.12.19"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/1f/3ee70b0a55137442038f2a33469cc5fddd7e0ad2abf83d7497c18a2b6923/flatbuffers-25.9.23.tar.gz", hash = "sha256:676f9fa62750bb50cf531b42a0a2a118ad8f7f797a511eda12881c016f093b12", size = 22067, upload-time = "2025-09-24T05:25:30.106Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/1b/00a78aa2e8fbd63f9af08c9c19e6deb3d5d66b4dda677a0f61654680ee89/flatbuffers-25.9.23-py2.py3-none-any.whl", hash = "sha256:255538574d6cb6d0a79a17ec8bc0d30985913b87513a01cce8bcdb6b4c44d0e2", size = 30869, upload-time = "2025-09-24T05:25:28.912Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" },
 ]
 
 [[package]]
@@ -1557,6 +1561,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1a/9d/c2c8b51b32f829a16fe042db30ad1dcef7947bf1dcf77c2cfd7b6f37b83a/formulaic-1.2.1-py3-none-any.whl", hash = "sha256:661d6d2467aa961b9afb3a1e2a187494239793c63eb729e422d1307afa98b43b", size = 117290, upload-time = "2025-09-21T05:27:30.025Z" },
 ]
 
+[[package]]
+name = "formulaic-contrasts"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "formulaic" },
+    { name = "pandas" },
+    { name = "session-info" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/e6/4850976c248746062cfaa08628b3ec5ba3dfcab3d6ecd0d3886c36c04681/formulaic_contrasts-1.0.0.tar.gz", hash = "sha256:0a575a810bf1fba28938259d86a3ae2ae90cb9826fca84b9409085170862f701", size = 123794, upload-time = "2024-12-15T13:44:06.844Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/7b/639411281256c84e8111bf6cb9676c44dbf5d8ad4cb042f4359b7e7b9e74/formulaic_contrasts-1.0.0-py3-none-any.whl", hash = "sha256:e1220d315cf446bdec9385375ca4da43896e4ba68114ebea1b2a37efa5d097f5", size = 10054, upload-time = "2024-12-15T13:44:05.454Z" },
+]
+
 [[package]]
 name = "fqdn"
 version = "1.5.1"
@@ -1723,6 +1741,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/00/7bd478cbb851c04a48baccaa49b75abaa8e4122f7d86da797500cccdd771/grpcio-1.76.0-cp312-cp312-win_amd64.whl", hash = "sha256:c088e7a90b6017307f423efbb9d1ba97a22aa2170876223f9709e9d1de0b5347", size = 4704003, upload-time = "2025-10-21T16:21:46.244Z" },
 ]
 
+[[package]]
+name = "gseapy"
+version = "1.1.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "requests" },
+    { name = "scipy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1c/78/7c0fbec6019db95dadb560049cc503e950438488b3b0822a2270e1f62d2a/gseapy-1.1.11.tar.gz", hash = "sha256:d36a164ee466f7ea6deadfe82ea041f3328ee937ff4c9de862b3e6e2825df0dd", size = 116084, upload-time = "2025-11-16T22:55:26.486Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/71/8034311bc4a7a41414cd188da9b411b4cd0c357574b01d8609d6e9a1d336/gseapy-1.1.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4d22c2ec30dc863b86292a0e967f8c7216ef03028b41f1ece6c59d277a870bdc", size = 533921, upload-time = "2025-11-16T23:02:53.061Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/3e/c3c23ff829d6a88c403cda12ed856ff93c7f07c510e3bf5c114a4d2f575e/gseapy-1.1.11-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:48453a402feae0412f6330a3c39f95ab02e82693f33bc4a1c6c02c867e7e6d1c", size = 605338, upload-time = "2025-11-16T22:58:48.471Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/9f/592125b3eabb64ecaf3275e4f0cff7dc59d438f8ffde360d686802787bc5/gseapy-1.1.11-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:6c64e60a8f61047c7d4053b791c7dea1c375bd28b955f0c50ae3cd607013c47f", size = 585366, upload-time = "2025-11-16T23:41:36.192Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a6/2b86532b665a3dd50d5bf5390e3b751487a6b6f64eddff1c21ea9d302fef/gseapy-1.1.11-cp312-cp312-win32.whl", hash = "sha256:18ba31a03b043b7a78397c0589f04d0f4d7a3ff76af09e219f0240085708c4c6", size = 391320, upload-time = "2025-11-16T23:05:48.509Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ab/6374ddf4cd4637b0cab1e9cd2dd8b1bf007bdf1e9fe1bf8bff2d83482a9b/gseapy-1.1.11-cp312-cp312-win_amd64.whl", hash = "sha256:5645f8f8c88a9218225a7c207d6d1de9eed9955f108ad2a06c46f42885ba4fa8", size = 423182, upload-time = "2025-11-16T23:03:12.868Z" },
+]
+
 [[package]]
 name = "gunicorn"
 version = "23.0.0"
@@ -1780,6 +1818,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/75/da/42486f1c79b6f2db9140ee23161791e5b25d9369f30c1d9f67b67f3eb4bf/harmony_pytorch-0.1.8-py3-none-any.whl", hash = "sha256:1f92f6145ea93225b0226fda9da5bdd442e411d14ff402052afae0fde7fd1452", size = 8474, upload-time = "2024-01-07T21:36:54.488Z" },
 ]
 
+[[package]]
+name = "harmonypy"
+version = "0.0.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1a/69/9af6183745618057797b940a76320c52a38ad2a69e688e6345e2a0219655/harmonypy-0.0.10.tar.gz", hash = "sha256:27bd39a6f9ada1708ffa577e46c9b7363d1e2fd62740e477ce11fd61819a54df", size = 20339, upload-time = "2024-07-04T20:55:06.385Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/cd/9479dd66e503af191edc016a302d2125c4f02ea777ebea1e48f6b944b073/harmonypy-0.0.10-py3-none-any.whl", hash = "sha256:dab528052f909204e521c9c2bd980221c64003538b0c0fe25be2e43c1199282b", size = 20885, upload-time = "2024-07-04T20:55:00.329Z" },
+]
+
 [[package]]
 name = "hbreader"
 version = "0.9.1"
@@ -1880,11 +1933,11 @@ wheels = [
 
 [[package]]
 name = "humanize"
-version = "4.14.0"
+version = "4.15.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b6/43/50033d25ad96a7f3845f40999b4778f753c3901a11808a584fed7c00d9f5/humanize-4.14.0.tar.gz", hash = "sha256:2fa092705ea640d605c435b1ca82b2866a1b601cdf96f076d70b79a855eba90d", size = 82939, upload-time = "2025-10-15T13:04:51.214Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/66/a3921783d54be8a6870ac4ccffcd15c4dc0dd7fcce51c6d63b8c63935276/humanize-4.15.0.tar.gz", hash = "sha256:1dd098483eb1c7ee8e32eb2e99ad1910baefa4b75c3aff3a82f4d78688993b10", size = 83599, upload-time = "2025-12-20T20:16:13.19Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c3/5b/9512c5fb6c8218332b530f13500c6ff5f3ce3342f35e0dd7be9ac3856fd3/humanize-4.14.0-py3-none-any.whl", hash = "sha256:d57701248d040ad456092820e6fde56c930f17749956ac47f4f655c0c547bfff", size = 132092, upload-time = "2025-10-15T13:04:49.404Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/7b/bca5613a0c3b542420cf92bd5e5fb8ebd5435ce1011a091f66bb7693285e/humanize-4.15.0-py3-none-any.whl", hash = "sha256:b1186eb9f5a9749cd9cb8565aee77919dd7c8d076161cf44d70e59e3301e1769", size = 132203, upload-time = "2025-12-20T20:16:11.67Z" },
 ]
 
 [[package]]
@@ -1995,14 +2048,14 @@ wheels = [
 
 [[package]]
 name = "importlib-metadata"
-version = "8.7.0"
+version = "8.7.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "zipp" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },
 ]
 
 [[package]]
@@ -2158,14 +2211,14 @@ wheels = [
 
 [[package]]
 name = "jaraco-functools"
-version = "4.3.0"
+version = "4.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "more-itertools" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/ed/1aa2d585304ec07262e1a83a9889880701079dde796ac7b1d1826f40c63d/jaraco_functools-4.3.0.tar.gz", hash = "sha256:cfd13ad0dd2c47a3600b439ef72d8615d482cedcff1632930d6f28924d92f294", size = 19755, upload-time = "2025-08-18T20:05:09.91Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/27/056e0638a86749374d6f57d0b0db39f29509cce9313cf91bdc0ac4d91084/jaraco_functools-4.4.0.tar.gz", hash = "sha256:da21933b0417b89515562656547a77b4931f98176eb173644c0d35032a33d6bb", size = 19943, upload-time = "2025-12-21T09:29:43.6Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b4/09/726f168acad366b11e420df31bf1c702a54d373a83f968d94141a8c3fde0/jaraco_functools-4.3.0-py3-none-any.whl", hash = "sha256:227ff8ed6f7b8f62c56deff101545fa7543cf2c8e7b82a7c2116e672f29c26e8", size = 10408, upload-time = "2025-08-18T20:05:08.69Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/c4/813bb09f0985cb21e959f21f2464169eca882656849adf727ac7bb7e1767/jaraco_functools-4.4.0-py3-none-any.whl", hash = "sha256:9eec1e36f45c818d9bf307c8948eb03b2b56cd44087b3cdc989abca1f20b9176", size = 10481, upload-time = "2025-12-21T09:29:42.27Z" },
 ]
 
 [[package]]
@@ -2890,19 +2943,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ea/7b/93c73c67db235931527301ed3785f849c78991e2e34f3fd9a6663ffda4c5/lxml-6.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:61cb10eeb95570153e0c0e554f58df92ecf5109f75eacad4a95baa709e26c3d6", size = 3672836, upload-time = "2025-09-22T04:01:52.145Z" },
 ]
 
-[[package]]
-name = "mariadb"
-version = "1.1.14"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "packaging" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/ba/cedef19833be88e07bfff11964441cda8a998f1628dd3b2fa3e7751d36e0/mariadb-1.1.14.tar.gz", hash = "sha256:e6d702a53eccf20922e47f2f45cfb5c7a0c2c6c0a46e4ee2d8a80d0ff4a52f34", size = 111715, upload-time = "2025-10-07T06:45:48.017Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/04/659a8d30513700b5921ec96bddc07f550016c045fcbeb199d8cd18476ecc/mariadb-1.1.14-cp312-cp312-win32.whl", hash = "sha256:98d552a8bb599eceaa88f65002ad00bd88aeed160592c273a7e5c1d79ab733dd", size = 185266, upload-time = "2025-10-07T06:45:34.164Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/a9/8f210291bc5fc044e20497454f40d35b3bab326e2cab6fccdc38121cb2c1/mariadb-1.1.14-cp312-cp312-win_amd64.whl", hash = "sha256:685a1ad2a24fd0aae1c4416fe0ac794adc84ab9209c8d0c57078f770d39731db", size = 202112, upload-time = "2025-10-07T06:45:35.824Z" },
-]
-
 [[package]]
 name = "markdown-it-py"
 version = "4.0.0"
@@ -3254,7 +3294,7 @@ wheels = [
 
 [[package]]
 name = "nbclient"
-version = "0.10.2"
+version = "0.10.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jupyter-client" },
@@ -3262,9 +3302,9 @@ dependencies = [
     { name = "nbformat" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8d/f3/1f6cf2ede4b026bc5f0b424cb41adf22f9c804e90a4dbd4fdb42291a35d5/nbclient-0.10.3.tar.gz", hash = "sha256:0baf171ee246e3bb2391da0635e719f27dc77d99aef59e0b04dcb935ee04c575", size = 62564, upload-time = "2025-12-19T15:50:09.331Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434, upload-time = "2024-12-19T10:32:24.139Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/77/0c73678f5260501a271fd7342bee5d639440f2e9e07d590f1100a056d87c/nbclient-0.10.3-py3-none-any.whl", hash = "sha256:39e9bd403504dd2484dd0fd25235bb6a683ce8cd9873356e40d880696adc9e35", size = 25473, upload-time = "2025-12-19T15:50:07.671Z" },
 ]
 
 [[package]]
@@ -3728,7 +3768,7 @@ wheels = [
 
 [[package]]
 name = "openai"
-version = "2.13.0"
+version = "2.14.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -3740,9 +3780,9 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0f/39/8e347e9fda125324d253084bb1b82407e5e3c7777a03dc398f79b2d95626/openai-2.13.0.tar.gz", hash = "sha256:9ff633b07a19469ec476b1e2b5b26c5ef700886524a7a72f65e6f0b5203142d5", size = 626583, upload-time = "2025-12-16T18:19:44.387Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/b1/12fe1c196bea326261718eb037307c1c1fe1dedc2d2d4de777df822e6238/openai-2.14.0.tar.gz", hash = "sha256:419357bedde9402d23bf8f2ee372fca1985a73348debba94bddff06f19459952", size = 626938, upload-time = "2025-12-19T03:28:45.742Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bb/d5/eb52edff49d3d5ea116e225538c118699ddeb7c29fa17ec28af14bc10033/openai-2.13.0-py3-none-any.whl", hash = "sha256:746521065fed68df2f9c2d85613bb50844343ea81f60009b60e6a600c9352c79", size = 1066837, upload-time = "2025-12-16T18:19:43.124Z" },
+    { url = "https://files.pythonhosted.org/packages/27/4b/7c1a00c2c3fbd004253937f7520f692a9650767aa73894d7a34f0d65d3f4/openai-2.14.0-py3-none-any.whl", hash = "sha256:7ea40aca4ffc4c4a776e77679021b47eec1160e341f42ae086ba949c9dcc9183", size = 1067558, upload-time = "2025-12-19T03:28:43.727Z" },
 ]
 
 [[package]]
@@ -4423,6 +4463,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
 ]
 
+[[package]]
+name = "pydeseq2"
+version = "0.5.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anndata" },
+    { name = "formulaic" },
+    { name = "formulaic-contrasts" },
+    { name = "matplotlib" },
+    { name = "numpy" },
+    { name = "pandas" },
+    { name = "scikit-learn" },
+    { name = "scipy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/e2/92bab7a299821396baca1a8c600c273ee13c5a081bcd788adc8e4a000ccc/pydeseq2-0.5.3.tar.gz", hash = "sha256:7dcbb34f80ce8147f566e9080d259b88df193174138983c4a77c1fe18ff3fe76", size = 790037, upload-time = "2025-10-28T15:43:41.284Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/68/c969b97f7147090273f147a01cf48d87b26296775f02b3caacd4c061ce34/pydeseq2-0.5.3-py3-none-any.whl", hash = "sha256:113842dedaeffdeac0873ed498af2408c58b99fb646a89013f0c7710ae796608", size = 48420, upload-time = "2025-10-28T15:35:51.995Z" },
+]
+
 [[package]]
 name = "pyee"
 version = "11.1.1"
@@ -5112,28 +5171,28 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.14.9"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/1b/ab712a9d5044435be8e9a2beb17cbfa4c241aa9b5e4413febac2a8b79ef2/ruff-0.14.9.tar.gz", hash = "sha256:35f85b25dd586381c0cc053f48826109384c81c00ad7ef1bd977bfcc28119d5b", size = 5809165, upload-time = "2025-12-11T21:39:47.381Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/1c/d1b1bba22cffec02351c78ab9ed4f7d7391876e12720298448b29b7229c1/ruff-0.14.9-py3-none-linux_armv6l.whl", hash = "sha256:f1ec5de1ce150ca6e43691f4a9ef5c04574ad9ca35c8b3b0e18877314aba7e75", size = 13576541, upload-time = "2025-12-11T21:39:14.806Z" },
-    { url = "https://files.pythonhosted.org/packages/94/ab/ffe580e6ea1fca67f6337b0af59fc7e683344a43642d2d55d251ff83ceae/ruff-0.14.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ed9d7417a299fc6030b4f26333bf1117ed82a61ea91238558c0268c14e00d0c2", size = 13779363, upload-time = "2025-12-11T21:39:20.29Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/f8/2be49047f929d6965401855461e697ab185e1a6a683d914c5c19c7962d9e/ruff-0.14.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d5dc3473c3f0e4a1008d0ef1d75cee24a48e254c8bed3a7afdd2b4392657ed2c", size = 12925292, upload-time = "2025-12-11T21:39:38.757Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/e9/08840ff5127916bb989c86f18924fd568938b06f58b60e206176f327c0fe/ruff-0.14.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84bf7c698fc8f3cb8278830fb6b5a47f9bcc1ed8cb4f689b9dd02698fa840697", size = 13362894, upload-time = "2025-12-11T21:39:02.524Z" },
-    { url = "https://files.pythonhosted.org/packages/31/1c/5b4e8e7750613ef43390bb58658eaf1d862c0cc3352d139cd718a2cea164/ruff-0.14.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aa733093d1f9d88a5d98988d8834ef5d6f9828d03743bf5e338bf980a19fce27", size = 13311482, upload-time = "2025-12-11T21:39:17.51Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/3a/459dce7a8cb35ba1ea3e9c88f19077667a7977234f3b5ab197fad240b404/ruff-0.14.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a1cfb04eda979b20c8c19550c8b5f498df64ff8da151283311ce3199e8b3648", size = 14016100, upload-time = "2025-12-11T21:39:41.948Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/31/f064f4ec32524f9956a0890fc6a944e5cf06c63c554e39957d208c0ffc45/ruff-0.14.9-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1e5cb521e5ccf0008bd74d5595a4580313844a42b9103b7388eca5a12c970743", size = 15477729, upload-time = "2025-12-11T21:39:23.279Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/6d/f364252aad36ccd443494bc5f02e41bf677f964b58902a17c0b16c53d890/ruff-0.14.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd429a8926be6bba4befa8cdcf3f4dd2591c413ea5066b1e99155ed245ae42bb", size = 15122386, upload-time = "2025-12-11T21:39:33.125Z" },
-    { url = "https://files.pythonhosted.org/packages/20/02/e848787912d16209aba2799a4d5a1775660b6a3d0ab3944a4ccc13e64a02/ruff-0.14.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab208c1b7a492e37caeaf290b1378148f75e13c2225af5d44628b95fd7834273", size = 14497124, upload-time = "2025-12-11T21:38:59.33Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/51/0489a6a5595b7760b5dbac0dd82852b510326e7d88d51dbffcd2e07e3ff3/ruff-0.14.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72034534e5b11e8a593f517b2f2f2b273eb68a30978c6a2d40473ad0aaa4cb4a", size = 14195343, upload-time = "2025-12-11T21:39:44.866Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/53/3bb8d2fa73e4c2f80acc65213ee0830fa0c49c6479313f7a68a00f39e208/ruff-0.14.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:712ff04f44663f1b90a1195f51525836e3413c8a773574a7b7775554269c30ed", size = 14346425, upload-time = "2025-12-11T21:39:05.927Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/04/bdb1d0ab876372da3e983896481760867fc84f969c5c09d428e8f01b557f/ruff-0.14.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a111fee1db6f1d5d5810245295527cda1d367c5aa8f42e0fca9a78ede9b4498b", size = 13258768, upload-time = "2025-12-11T21:39:08.691Z" },
-    { url = "https://files.pythonhosted.org/packages/40/d9/8bf8e1e41a311afd2abc8ad12be1b6c6c8b925506d9069b67bb5e9a04af3/ruff-0.14.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8769efc71558fecc25eb295ddec7d1030d41a51e9dcf127cbd63ec517f22d567", size = 13326939, upload-time = "2025-12-11T21:39:53.842Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/56/a213fa9edb6dd849f1cfbc236206ead10913693c72a67fb7ddc1833bf95d/ruff-0.14.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:347e3bf16197e8a2de17940cd75fd6491e25c0aa7edf7d61aa03f146a1aa885a", size = 13578888, upload-time = "2025-12-11T21:39:35.988Z" },
-    { url = "https://files.pythonhosted.org/packages/33/09/6a4a67ffa4abae6bf44c972a4521337ffce9cbc7808faadede754ef7a79c/ruff-0.14.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7715d14e5bccf5b660f54516558aa94781d3eb0838f8e706fb60e3ff6eff03a8", size = 14314473, upload-time = "2025-12-11T21:39:50.78Z" },
-    { url = "https://files.pythonhosted.org/packages/12/0d/15cc82da5d83f27a3c6b04f3a232d61bc8c50d38a6cd8da79228e5f8b8d6/ruff-0.14.9-py3-none-win32.whl", hash = "sha256:df0937f30aaabe83da172adaf8937003ff28172f59ca9f17883b4213783df197", size = 13202651, upload-time = "2025-12-11T21:39:26.628Z" },
-    { url = "https://files.pythonhosted.org/packages/32/f7/c78b060388eefe0304d9d42e68fab8cffd049128ec466456cef9b8d4f06f/ruff-0.14.9-py3-none-win_amd64.whl", hash = "sha256:c0b53a10e61df15a42ed711ec0bda0c582039cf6c754c49c020084c55b5b0bc2", size = 14702079, upload-time = "2025-12-11T21:39:11.954Z" },
-    { url = "https://files.pythonhosted.org/packages/26/09/7a9520315decd2334afa65ed258fed438f070e31f05a2e43dd480a5e5911/ruff-0.14.9-py3-none-win_arm64.whl", hash = "sha256:8e821c366517a074046d92f0e9213ed1c13dbc5b37a7fc20b07f79b64d62cc84", size = 13744730, upload-time = "2025-12-11T21:39:29.659Z" },
+version = "0.14.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/08/52232a877978dd8f9cf2aeddce3e611b40a63287dfca29b6b8da791f5e8d/ruff-0.14.10.tar.gz", hash = "sha256:9a2e830f075d1a42cd28420d7809ace390832a490ed0966fe373ba288e77aaf4", size = 5859763, upload-time = "2025-12-18T19:28:57.98Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/01/933704d69f3f05ee16ef11406b78881733c186fe14b6a46b05cfcaf6d3b2/ruff-0.14.10-py3-none-linux_armv6l.whl", hash = "sha256:7a3ce585f2ade3e1f29ec1b92df13e3da262178df8c8bdf876f48fa0e8316c49", size = 13527080, upload-time = "2025-12-18T19:29:25.642Z" },
+    { url = "https://files.pythonhosted.org/packages/df/58/a0349197a7dfa603ffb7f5b0470391efa79ddc327c1e29c4851e85b09cc5/ruff-0.14.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:674f9be9372907f7257c51f1d4fc902cb7cf014b9980152b802794317941f08f", size = 13797320, upload-time = "2025-12-18T19:29:02.571Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/82/36be59f00a6082e38c23536df4e71cdbc6af8d7c707eade97fcad5c98235/ruff-0.14.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d85713d522348837ef9df8efca33ccb8bd6fcfc86a2cde3ccb4bc9d28a18003d", size = 12918434, upload-time = "2025-12-18T19:28:51.202Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/00/45c62a7f7e34da92a25804f813ebe05c88aa9e0c25e5cb5a7d23dd7450e3/ruff-0.14.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6987ebe0501ae4f4308d7d24e2d0fe3d7a98430f5adfd0f1fead050a740a3a77", size = 13371961, upload-time = "2025-12-18T19:29:04.991Z" },
+    { url = "https://files.pythonhosted.org/packages/40/31/a5906d60f0405f7e57045a70f2d57084a93ca7425f22e1d66904769d1628/ruff-0.14.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:16a01dfb7b9e4eee556fbfd5392806b1b8550c9b4a9f6acd3dbe6812b193c70a", size = 13275629, upload-time = "2025-12-18T19:29:21.381Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/60/61c0087df21894cf9d928dc04bcd4fb10e8b2e8dca7b1a276ba2155b2002/ruff-0.14.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7165d31a925b7a294465fa81be8c12a0e9b60fb02bf177e79067c867e71f8b1f", size = 14029234, upload-time = "2025-12-18T19:29:00.132Z" },
+    { url = "https://files.pythonhosted.org/packages/44/84/77d911bee3b92348b6e5dab5a0c898d87084ea03ac5dc708f46d88407def/ruff-0.14.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:c561695675b972effb0c0a45db233f2c816ff3da8dcfbe7dfc7eed625f218935", size = 15449890, upload-time = "2025-12-18T19:28:53.573Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/36/480206eaefa24a7ec321582dda580443a8f0671fdbf6b1c80e9c3e93a16a/ruff-0.14.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bb98fcbbc61725968893682fd4df8966a34611239c9fd07a1f6a07e7103d08e", size = 15123172, upload-time = "2025-12-18T19:29:23.453Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/38/68e414156015ba80cef5473d57919d27dfb62ec804b96180bafdeaf0e090/ruff-0.14.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f24b47993a9d8cb858429e97bdf8544c78029f09b520af615c1d261bf827001d", size = 14460260, upload-time = "2025-12-18T19:29:27.808Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/19/9e050c0dca8aba824d67cc0db69fb459c28d8cd3f6855b1405b3f29cc91d/ruff-0.14.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59aabd2e2c4fd614d2862e7939c34a532c04f1084476d6833dddef4afab87e9f", size = 14229978, upload-time = "2025-12-18T19:29:11.32Z" },
+    { url = "https://files.pythonhosted.org/packages/51/eb/e8dd1dd6e05b9e695aa9dd420f4577debdd0f87a5ff2fedda33c09e9be8c/ruff-0.14.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:213db2b2e44be8625002dbea33bb9c60c66ea2c07c084a00d55732689d697a7f", size = 14338036, upload-time = "2025-12-18T19:29:09.184Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/12/f3e3a505db7c19303b70af370d137795fcfec136d670d5de5391e295c134/ruff-0.14.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b914c40ab64865a17a9a5b67911d14df72346a634527240039eb3bd650e5979d", size = 13264051, upload-time = "2025-12-18T19:29:13.431Z" },
+    { url = "https://files.pythonhosted.org/packages/08/64/8c3a47eaccfef8ac20e0484e68e0772013eb85802f8a9f7603ca751eb166/ruff-0.14.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:1484983559f026788e3a5c07c81ef7d1e97c1c78ed03041a18f75df104c45405", size = 13283998, upload-time = "2025-12-18T19:29:06.994Z" },
+    { url = "https://files.pythonhosted.org/packages/12/84/534a5506f4074e5cc0529e5cd96cfc01bb480e460c7edf5af70d2bcae55e/ruff-0.14.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c70427132db492d25f982fffc8d6c7535cc2fd2c83fc8888f05caaa248521e60", size = 13601891, upload-time = "2025-12-18T19:28:55.811Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/1e/14c916087d8598917dbad9b2921d340f7884824ad6e9c55de948a93b106d/ruff-0.14.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5bcf45b681e9f1ee6445d317ce1fa9d6cba9a6049542d1c3d5b5958986be8830", size = 14336660, upload-time = "2025-12-18T19:29:16.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/1c/d7b67ab43f30013b47c12b42d1acd354c195351a3f7a1d67f59e54227ede/ruff-0.14.10-py3-none-win32.whl", hash = "sha256:104c49fc7ab73f3f3a758039adea978869a918f31b73280db175b43a2d9b51d6", size = 13196187, upload-time = "2025-12-18T19:29:19.006Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/9c/896c862e13886fae2af961bef3e6312db9ebc6adc2b156fe95e615dee8c1/ruff-0.14.10-py3-none-win_amd64.whl", hash = "sha256:466297bd73638c6bdf06485683e812db1c00c7ac96d4ddd0294a338c62fdc154", size = 14661283, upload-time = "2025-12-18T19:29:30.16Z" },
+    { url = "https://files.pythonhosted.org/packages/74/31/b0e29d572670dca3674eeee78e418f20bdf97fa8aa9ea71380885e175ca0/ruff-0.14.10-py3-none-win_arm64.whl", hash = "sha256:e51d046cf6dda98a4633b8a8a771451107413b0f07183b2bef03f075599e44e6", size = 13729839, upload-time = "2025-12-18T19:28:48.636Z" },
 ]
 
 [[package]]
@@ -5204,7 +5263,7 @@ wheels = [
 
 [[package]]
 name = "scikit-image"
-version = "0.25.2"
+version = "0.26.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "imageio" },
@@ -5216,13 +5275,16 @@ dependencies = [
     { name = "scipy" },
     { name = "tifffile" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c7/a8/3c0f256012b93dd2cb6fda9245e9f4bff7dc0486880b248005f15ea2255e/scikit_image-0.25.2.tar.gz", hash = "sha256:e5a37e6cd4d0c018a7a55b9d601357e3382826d3888c10d0213fc63bff977dde", size = 22693594, upload-time = "2025-02-18T18:05:24.538Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/b4/2528bb43c67d48053a7a649a9666432dc307d66ba02e3a6d5c40f46655df/scikit_image-0.26.0.tar.gz", hash = "sha256:f5f970ab04efad85c24714321fcc91613fcb64ef2a892a13167df2f3e59199fa", size = 22729739, upload-time = "2025-12-20T17:12:21.824Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/35/8c/5df82881284459f6eec796a5ac2a0a304bb3384eec2e73f35cfdfcfbf20c/scikit_image-0.25.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8db8dd03663112783221bf01ccfc9512d1cc50ac9b5b0fe8f4023967564719fb", size = 13986000, upload-time = "2025-02-18T18:04:47.156Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/e6/93bebe1abcdce9513ffec01d8af02528b4c41fb3c1e46336d70b9ed4ef0d/scikit_image-0.25.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:483bd8cc10c3d8a7a37fae36dfa5b21e239bd4ee121d91cad1f81bba10cfb0ed", size = 13235893, upload-time = "2025-02-18T18:04:51.049Z" },
-    { url = "https://files.pythonhosted.org/packages/53/4b/eda616e33f67129e5979a9eb33c710013caa3aa8a921991e6cc0b22cea33/scikit_image-0.25.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d1e80107bcf2bf1291acfc0bf0425dceb8890abe9f38d8e94e23497cbf7ee0d", size = 14178389, upload-time = "2025-02-18T18:04:54.245Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/b5/b75527c0f9532dd8a93e8e7cd8e62e547b9f207d4c11e24f0006e8646b36/scikit_image-0.25.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a17e17eb8562660cc0d31bb55643a4da996a81944b82c54805c91b3fe66f4824", size = 15003435, upload-time = "2025-02-18T18:04:57.586Z" },
-    { url = "https://files.pythonhosted.org/packages/34/e3/49beb08ebccda3c21e871b607c1cb2f258c3fa0d2f609fed0a5ba741b92d/scikit_image-0.25.2-cp312-cp312-win_amd64.whl", hash = "sha256:bdd2b8c1de0849964dbc54037f36b4e9420157e67e45a8709a80d727f52c7da2", size = 12899474, upload-time = "2025-02-18T18:05:01.166Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e8/e13757982264b33a1621628f86b587e9a73a13f5256dad49b19ba7dc9083/scikit_image-0.26.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d454b93a6fa770ac5ae2d33570f8e7a321bb80d29511ce4b6b78058ebe176e8c", size = 12376452, upload-time = "2025-12-20T17:10:52.796Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/be/f8dd17d0510f9911f9f17ba301f7455328bf13dae416560126d428de9568/scikit_image-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3409e89d66eff5734cd2b672d1c48d2759360057e714e1d92a11df82c87cba37", size = 12061567, upload-time = "2025-12-20T17:10:55.207Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/2b/c70120a6880579fb42b91567ad79feb4772f7be72e8d52fec403a3dde0c6/scikit_image-0.26.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c717490cec9e276afb0438dd165b7c3072d6c416709cc0f9f5a4c1070d23a44", size = 13084214, upload-time = "2025-12-20T17:10:57.468Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a2/70401a107d6d7466d64b466927e6b96fcefa99d57494b972608e2f8be50f/scikit_image-0.26.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7df650e79031634ac90b11e64a9eedaf5a5e06fcd09bcd03a34be01745744466", size = 13561683, upload-time = "2025-12-20T17:10:59.49Z" },
+    { url = "https://files.pythonhosted.org/packages/13/a5/48bdfd92794c5002d664e0910a349d0a1504671ef5ad358150f21643c79a/scikit_image-0.26.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cefd85033e66d4ea35b525bb0937d7f42d4cdcfed2d1888e1570d5ce450d3932", size = 14112147, upload-time = "2025-12-20T17:11:02.083Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/b5/ac71694da92f5def5953ca99f18a10fe98eac2dd0a34079389b70b4d0394/scikit_image-0.26.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3f5bf622d7c0435884e1e141ebbe4b2804e16b2dd23ae4c6183e2ea99233be70", size = 14661625, upload-time = "2025-12-20T17:11:04.528Z" },
+    { url = "https://files.pythonhosted.org/packages/23/4d/a3cc1e96f080e253dad2251bfae7587cf2b7912bcd76fd43fd366ff35a87/scikit_image-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:abed017474593cd3056ae0fe948d07d0747b27a085e92df5474f4955dd65aec0", size = 11911059, upload-time = "2025-12-20T17:11:06.61Z" },
+    { url = "https://files.pythonhosted.org/packages/35/8a/d1b8055f584acc937478abf4550d122936f420352422a1a625eef2c605d8/scikit_image-0.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:4d57e39ef67a95d26860c8caf9b14b8fb130f83b34c6656a77f191fa6d1d04d8", size = 11348740, upload-time = "2025-12-20T17:11:09.118Z" },
 ]
 
 [[package]]
@@ -5361,6 +5423,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/49/65/dea992c6a97074f6d8ff9eab34741298cac2ce23e2b6c74fb7d08afdf85c/sentinels-1.1.1-py3-none-any.whl", hash = "sha256:835d3b28f3b47f5284afa4bf2db6e00f2dc5f80f9923d4b7e7aeeeccf6146a11", size = 3744, upload-time = "2025-08-12T07:57:48.858Z" },
 ]
 
+[[package]]
+name = "session-info"
+version = "1.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "stdlib-list" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f5/dc/4a0c85aee2034be368d3ca293a563128122dde6db6e1bc9ca9ef3472c731/session_info-1.0.1.tar.gz", hash = "sha256:d71950d5a8ce7f7f7d5e86aa208c148c4e50b5440b77d5544d422b48e4f3ed41", size = 24663, upload-time = "2025-04-11T16:08:43.504Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/c4/f6b7c0ec5241a2bde90c7ba1eca6ba44f8488bcedafe9072c79593015ec0/session_info-1.0.1-py3-none-any.whl", hash = "sha256:451d191e51816070b9f21a6ff3f6eb5d6015ae2738e8db63ac4e6398260a5838", size = 9119, upload-time = "2025-04-11T16:08:42.612Z" },
+]
+
 [[package]]
 name = "session-info2"
 version = "0.2.3"
@@ -5450,11 +5524,11 @@ wheels = [
 
 [[package]]
 name = "soupsieve"
-version = "2.8"
+version = "2.8.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/89/23/adf3796d740536d63a6fbda113d07e60c734b6ed5d3058d1e47fc0495e47/soupsieve-2.8.1.tar.gz", hash = "sha256:4cf733bc50fa805f5df4b8ef4740fc0e0fa6218cf3006269afd3f9d6d80fd350", size = 117856, upload-time = "2025-12-18T13:50:34.655Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f3/b67d6ea49ca9154453b6d70b34ea22f3996b9fa55da105a79d8732227adc/soupsieve-2.8.1-py3-none-any.whl", hash = "sha256:a11fe2a6f3d76ab3cf2de04eb339c1be5b506a8a47f2ceb6d139803177f85434", size = 36710, upload-time = "2025-12-18T13:50:33.267Z" },
 ]
 
 [[package]]
@@ -5763,6 +5837,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/60/15/3daba2df40be8b8a9a027d7f54c8dedf24f0d81b96e54b52293f5f7e3418/statsmodels-0.14.6-cp312-cp312-win_amd64.whl", hash = "sha256:b5eb07acd115aa6208b4058211138393a7e6c2cf12b6f213ede10f658f6a714f", size = 9543991, upload-time = "2025-12-05T23:10:58.536Z" },
 ]
 
+[[package]]
+name = "stdlib-list"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/25/f1540879c8815387980e56f973e54605bd924612399ace31487f7444171c/stdlib_list-0.12.0.tar.gz", hash = "sha256:517824f27ee89e591d8ae7c1dd9ff34f672eae50ee886ea31bb8816d77535675", size = 60923, upload-time = "2025-10-24T19:21:22.849Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/3d/2970b27a11ae17fb2d353e7a179763a2fe6f37d6d2a9f4d40104a2f132e9/stdlib_list-0.12.0-py3-none-any.whl", hash = "sha256:df2d11e97f53812a1756fb5510393a11e3b389ebd9239dc831c7f349957f62f2", size = 87615, upload-time = "2025-10-24T19:21:20.619Z" },
+]
+
 [[package]]
 name = "sympy"
 version = "1.14.0"
@@ -5864,14 +5947,14 @@ wheels = [
 
 [[package]]
 name = "tifffile"
-version = "2025.12.12"
+version = "2025.12.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/31/b9/4253513a66f0a836ec3a5104266cf73f7812bfbbcda9d87d8c0e93b28293/tifffile-2025.12.12.tar.gz", hash = "sha256:97e11fd6b1d8dc971896a098c841d9cd4e6eb958ac040dd6fb8b332c3f7288b6", size = 373597, upload-time = "2025-12-13T03:42:53.765Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/a6/85e8ecfd7cb4167f8bd17136b2d42cba296fbc08a247bba70d5747e2046a/tifffile-2025.12.20.tar.gz", hash = "sha256:cb8a4fee327d15b3e3eeac80bbdd8a53b323c80473330bcfb99418ee4c1c827f", size = 373364, upload-time = "2025-12-21T06:23:54.241Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/5c/e444e1b024a519e488326525f0c154396c6b16baff17e00623f2c21dfc42/tifffile-2025.12.12-py3-none-any.whl", hash = "sha256:e3e3f1290ec6741ca248a5b5a997125209b5c2962f6bd9aef01ea9352c25d0ee", size = 232132, upload-time = "2025-12-13T03:42:52.072Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/fe/e59859aa1134fac065d36864752daf13215c98b379cb5d93f954dc0ec830/tifffile-2025.12.20-py3-none-any.whl", hash = "sha256:bc0345a20675149353cfcb3f1c48d0a3654231ee26bd46beebaab4d2168feeb6", size = 232031, upload-time = "2025-12-21T06:23:53.003Z" },
 ]
 
 [[package]]
@@ -6044,7 +6127,7 @@ wheels = [
 
 [[package]]
 name = "typer"
-version = "0.20.0"
+version = "0.20.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
@@ -6052,22 +6135,22 @@ dependencies = [
     { name = "shellingham" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8f/28/7c85c8032b91dbe79725b6f17d2fffc595dff06a35c7a30a37bef73a1ab4/typer-0.20.0.tar.gz", hash = "sha256:1aaf6494031793e4876fb0bacfa6a912b551cf43c1e63c800df8b1a866720c37", size = 106492, upload-time = "2025-10-20T17:03:49.445Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/c1/933d30fd7a123ed981e2a1eedafceab63cb379db0402e438a13bc51bbb15/typer-0.20.1.tar.gz", hash = "sha256:68585eb1b01203689c4199bc440d6be616f0851e9f0eb41e4a778845c5a0fd5b", size = 105968, upload-time = "2025-12-19T16:48:56.302Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/64/7713ffe4b5983314e9d436a90d5bd4f63b6054e2aca783a3cfc44cb95bbf/typer-0.20.0-py3-none-any.whl", hash = "sha256:5b463df6793ec1dca6213a3cf4c0f03bc6e322ac5e16e13ddd622a889489784a", size = 47028, upload-time = "2025-10-20T17:03:47.617Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/52/1f2df7e7d1be3d65ddc2936d820d4a3d9777a54f4204f5ca46b8513eff77/typer-0.20.1-py3-none-any.whl", hash = "sha256:4b3bde918a67c8e03d861aa02deca90a95bbac572e71b1b9be56ff49affdb5a8", size = 47381, upload-time = "2025-12-19T16:48:53.679Z" },
 ]
 
 [[package]]
 name = "typer-slim"
-version = "0.20.0"
+version = "0.20.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8e/45/81b94a52caed434b94da65729c03ad0fb7665fab0f7db9ee54c94e541403/typer_slim-0.20.0.tar.gz", hash = "sha256:9fc6607b3c6c20f5c33ea9590cbeb17848667c51feee27d9e314a579ab07d1a3", size = 106561, upload-time = "2025-10-20T17:03:46.642Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3f/3d/6a4ec47010e8de34dade20c8e7bce90502b173f62a6b41619523a3fcf562/typer_slim-0.20.1.tar.gz", hash = "sha256:bb9e4f7e6dc31551c8a201383df322b81b0ce37239a5ead302598a2ebb6f7c9c", size = 106113, upload-time = "2025-12-19T16:48:54.206Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/dd/5cbf31f402f1cc0ab087c94d4669cfa55bd1e818688b910631e131d74e75/typer_slim-0.20.0-py3-none-any.whl", hash = "sha256:f42a9b7571a12b97dddf364745d29f12221865acef7a2680065f9bb29c7dc89d", size = 47087, upload-time = "2025-10-20T17:03:44.546Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/f9/a273c8b57c69ac1b90509ebda204972265fdc978fbbecc25980786f8c038/typer_slim-0.20.1-py3-none-any.whl", hash = "sha256:8e89c5dbaffe87a4f86f4c7a9e2f7059b5b68c66f558f298969d42ce34f10122", size = 47440, upload-time = "2025-12-19T16:48:52.678Z" },
 ]
 
 [[package]]
@@ -6174,15 +6257,15 @@ wheels = [
 
 [[package]]
 name = "uvicorn"
-version = "0.38.0"
+version = "0.40.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/d8/2083a1daa7439a66f3a48589a57d576aa117726762618f6bb09fe3798796/uvicorn-0.40.0-py3-none-any.whl", hash = "sha256:c6c8f55bc8bf13eb6fa9ff87ad62308bbbc33d0b67f84293151efe87e0d5f2ee", size = 68502, upload-time = "2025-12-21T14:16:21.041Z" },
 ]
 
 [package.optional-dependencies]

From 943e3c17c6d4c6078242e853a0edfa7f1dc892fc Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 08:57:10 -0800
Subject: [PATCH 34/87] final version of monolithic workflow

---
 .../rnaseq/immune_scrnaseq_monolithic.py      | 55 +++++++++++++------
 1 file changed, 38 insertions(+), 17 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
index 95c994d..cac638e 100644
--- a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
+++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
@@ -68,11 +68,13 @@
 # %%
 
 datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')
+figure_dir = datadir / 'workflow/figures'
+figure_dir.mkdir(parents=True, exist_ok=True)
 
 # %%
-datafile = datadir / 'a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'
-url = 'https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'
 dataset_name = 'OneK1K'
+datafile = datadir / f'dataset-{dataset_name}_subset-immune_raw.h5ad'
+url = 'https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'
 
 if not datafile.exists():
     cmd = f'wget -O {datafile.as_posix()} {url}'
@@ -116,7 +118,7 @@
 
 # Optional: Draw a vertical line at the propsoed cutoff
 # This helps you visualize how many donors you would lose.
-cutoff_percentile = 10  # e.g., 10th percentile
+cutoff_percentile = 1  # e.g., 1st percentile
 min_cells_per_donor = int(
     scoreatpercentile(donor_cell_counts.values, cutoff_percentile)
 )
@@ -132,7 +134,8 @@
 )
 plt.legend()
 
-plt.show()
+plt.savefig(figure_dir / 'donor_cell_counts_distribution.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %%
 print(
@@ -164,7 +167,7 @@
 # Keep if >= 10 cells in at least 90% of donors
 
 min_cells = 10
-percent_donors = 0.9
+percent_donors = 0.95
 donor_count = counts_per_donor.shape[0]
 cell_types_to_keep = counts_per_donor.columns[
     (counts_per_donor >= min_cells).sum(axis=0)
@@ -270,14 +273,19 @@
     ['total_counts', 'n_genes_by_counts', 'pct_counts_mt'],
     jitter=0.4,
     multi_panel=True,
+    show=False,
 )
+plt.savefig(figure_dir / 'qc_violin_plots.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # 2. Scatter plot to spot doublets and dying cells
 # High mito + low genes = dying cell
 # High counts + high genes = potential doublet
 sc.pl.scatter(
-    adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt'
+    adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt', show=False
 )
+plt.savefig(figure_dir / 'qc_scatter_doublets.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # ####  Check Hemoglobin (RBC contamination)
@@ -293,7 +301,8 @@
 plt.xlabel('% Hemoglobin Counts')
 plt.axvline(5, color='red', linestyle='--', label='5% Cutoff')
 plt.legend()
-plt.show()
+plt.savefig(figure_dir / 'hemoglobin_distribution.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # #### Create a copy of the data and apply QC cutoffs
@@ -398,7 +407,9 @@
 #
 
 # %%
-sc.pl.umap(adata_qc, color=['doublet_score', 'predicted_doublet'], size=20)
+sc.pl.umap(adata_qc, color=['doublet_score', 'predicted_doublet'], size=20, show=False)
+plt.savefig(figure_dir / 'doublet_detection_umap.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # #### Filter doublets
@@ -410,7 +421,7 @@
 
 # Filter the data to keep only singlets (False)
 # write back to adata for simplicity
-adata = adata_qc[not adata_qc.obs['predicted_doublet'], :]
+adata = adata_qc[adata_qc.obs['predicted_doublet'] == False, :] #noqa: E712
 print(f'Remaining cells: {adata.n_obs}')
 
 # %% [markdown]
@@ -536,7 +547,9 @@
 # %%
 # Reality check: Check if PC1 is just "Cell Size":
 
-sc.pl.pca(adata, color=['total_counts', 'cell_type'], components=['1,2'])
+sc.pl.pca(adata, color=['total_counts', 'cell_type'], components=['1,2'], show=False)
+plt.savefig(figure_dir / 'pca_cell_type.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # PC1 separates cell types and isn't driven only by the number of cells.
@@ -552,7 +565,9 @@
 sc.tl.umap(adata, init_pos='X_pca_harmony')
 
 # %%
-sc.pl.umap(adata, color='total_counts')
+sc.pl.umap(adata, color='total_counts', show=False)
+plt.savefig(figure_dir / 'umap_total_counts.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 
 # %% [markdown]
@@ -574,7 +589,9 @@
 
 # %%
 # Plot UMAP colored by Donor (to check integration) and Clusters
-sc.pl.umap(adata, color=['cell_type', 'leiden_1.0'], wspace=0.3)
+sc.pl.umap(adata, color=['cell_type', 'leiden_1.0'], wspace=0.3, show=False)
+plt.savefig(figure_dir / 'umap_cell_type_leiden.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %%
 # compute overlap between clusters and cell types
@@ -701,7 +718,9 @@ def create_pseudobulk(
 # Optional: Visualize the 'depth' of your new pseudobulk samples
 
 pb_adata.obs['total_counts'] = np.array(pb_adata.X.sum(axis=1)).flatten()
-sc.pl.violin(pb_adata, ['n_cells', 'total_counts'], multi_panel=True)
+sc.pl.violin(pb_adata, ['n_cells', 'total_counts'], multi_panel=True, show=False)
+plt.savefig(figure_dir / 'pseudobulk_violin.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # ### Differential expression with age
@@ -721,7 +740,6 @@ def create_pseudobulk(
 
 # %%
 
-
 # Assume pb_adata is your pseudobulk object from the previous step
 # 1. Extract counts and metadata
 counts_df = pd.DataFrame(
@@ -924,7 +942,8 @@ def create_pseudobulk(
 plt.grid(axis='x', alpha=0.3)
 plt.tight_layout()
 
-plt.show()
+plt.savefig(figure_dir / 'gsea_pathways.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # ### Enrichr analysis for overrepresentation
@@ -1027,7 +1046,8 @@ def create_pseudobulk(
 plt.grid(axis='x', alpha=0.3)
 plt.tight_layout()
 
-plt.show()
+plt.savefig(figure_dir / 'enrichr_pathways.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # ### Age prediction from gene expression
@@ -1134,7 +1154,8 @@ def create_pseudobulk(
 plt.legend()
 plt.grid(alpha=0.3)
 plt.tight_layout()
-plt.show()
+plt.savefig(figure_dir / 'age_prediction_performance.png', dpi=300, bbox_inches='tight')
+plt.close()
 
 # %% [markdown]
 # #### Baseline model: Sex only

From 678983e1c337b6a23b0f35cfb974a87587cfd13e Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 08:57:51 -0800
Subject: [PATCH 35/87] initial add

---
 refactor_monolithic_to_modular.md             |  27 ++
 .../rnaseq/modular_workflow/__init__.py       |   0
 .../rnaseq/modular_workflow/clustering.py     | 137 +++++++
 .../rnaseq/modular_workflow/data_filtering.py | 246 +++++++++++++
 .../rnaseq/modular_workflow/data_loading.py   |  77 ++++
 .../differential_expression.py                | 268 ++++++++++++++
 .../dimensionality_reduction.py               | 182 ++++++++++
 .../overrepresentation_analysis.py            | 262 ++++++++++++++
 .../modular_workflow/pathway_analysis.py      | 249 +++++++++++++
 .../modular_workflow/predictive_modeling.py   | 337 ++++++++++++++++++
 .../rnaseq/modular_workflow/preprocessing.py  | 210 +++++++++++
 .../rnaseq/modular_workflow/pseudobulk.py     | 207 +++++++++++
 .../modular_workflow/quality_control.py       | 322 +++++++++++++++++
 .../rnaseq/modular_workflow/run_workflow.py   | 314 ++++++++++++++++
 14 files changed, 2838 insertions(+)
 create mode 100644 refactor_monolithic_to_modular.md
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/clustering.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/data_filtering.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/data_loading.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/differential_expression.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/dimensionality_reduction.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/overrepresentation_analysis.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/pathway_analysis.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/predictive_modeling.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/preprocessing.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py

diff --git a/refactor_monolithic_to_modular.md b/refactor_monolithic_to_modular.md
new file mode 100644
index 0000000..a6ea614
--- /dev/null
+++ b/refactor_monolithic_to_modular.md
@@ -0,0 +1,27 @@
+Prompt: please read CLAUDE.md for guidelines, and then read refactor_monolithic_to_modular.md for a description of your task.
+
+# Goal
+
+src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py is currently a single monolithic script for a data analysis workflow.  I would like to refactor it into a modular script based on the following decomposition of the workflow:
+
+- Data (down)loading
+- Data filtering (removing subjects or cell types with insufficient observations)
+- Quality control
+    - identifying bad cells on the basis of mitochondrial, ribosomal, or hemoglobin genes or hemoglobin contamination
+    - identifying "doublets" (multiple cells identified as one)
+- Preprocessing
+    - Count normalization
+    - Log transformation
+    - Identification of high-variance features
+    - Filtering of nuisance genes
+- Dimensionality reduction
+- UMAP generation
+- Clustering
+- Pseudobulking
+- Differential expression analysis
+- Pathway enrichment analysis (GSEA)
+- Overrepresentation analysis (Enrichr)
+- Predictive modeling
+
+Please generate a new set of scripts within a new directory called `src/BetterCodeBetterScience/rnaseq/modular_workflow` that implements the same workflow in a modular way.
+
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/clustering.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/clustering.py
new file mode 100644
index 0000000..d707a7e
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/clustering.py
@@ -0,0 +1,137 @@
+"""Clustering module for scRNA-seq analysis workflow.
+
+Functions for cell clustering using Leiden algorithm.
+"""
+
+from pathlib import Path
+
+import anndata as ad
+import matplotlib.pyplot as plt
+import pandas as pd
+import scanpy as sc
+
+
+def run_leiden_clustering(
+    adata: ad.AnnData,
+    resolution: float = 1.0,
+    key_added: str = "leiden_1.0",
+    flavor: str = "igraph",
+    n_iterations: int = 2,
+) -> ad.AnnData:
+    """Run Leiden clustering algorithm.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with neighbor graph
+    resolution : float
+        Resolution parameter for clustering
+    key_added : str
+        Key to store cluster assignments
+    flavor : str
+        Implementation flavor
+    n_iterations : int
+        Number of iterations
+
+    Returns
+    -------
+    AnnData
+        AnnData with cluster assignments
+    """
+    sc.tl.leiden(
+        adata,
+        resolution=resolution,
+        key_added=key_added,
+        flavor=flavor,
+        n_iterations=n_iterations,
+    )
+    return adata
+
+
+def plot_clusters(
+    adata: ad.AnnData,
+    cluster_key: str = "leiden_1.0",
+    cell_type_key: str = "cell_type",
+    figure_dir: Path | None = None,
+) -> None:
+    """Plot UMAP colored by clusters and cell types.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with UMAP and clusters
+    cluster_key : str
+        Key for cluster assignments
+    cell_type_key : str
+        Key for cell type annotations
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    sc.pl.umap(adata, color=[cell_type_key, cluster_key], wspace=0.3, show=False)
+    if figure_dir is not None:
+        plt.savefig(
+            figure_dir / "umap_cell_type_leiden.png", dpi=300, bbox_inches="tight"
+        )
+    plt.close()
+
+
+def compute_cluster_celltype_overlap(
+    adata: ad.AnnData,
+    cluster_key: str = "leiden_1.0",
+    cell_type_key: str = "cell_type",
+) -> pd.DataFrame:
+    """Compute contingency table between clusters and cell types.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with clusters and cell types
+    cluster_key : str
+        Key for cluster assignments
+    cell_type_key : str
+        Key for cell type annotations
+
+    Returns
+    -------
+    pd.DataFrame
+        Contingency table
+    """
+    contingency_table = pd.crosstab(adata.obs[cluster_key], adata.obs[cell_type_key])
+    return contingency_table
+
+
+def run_clustering_pipeline(
+    adata: ad.AnnData,
+    resolution: float = 1.0,
+    figure_dir: Path | None = None,
+) -> ad.AnnData:
+    """Run complete clustering pipeline.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Input AnnData object with UMAP computed
+    resolution : float
+        Leiden resolution parameter
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    AnnData
+        AnnData with cluster assignments
+    """
+    cluster_key = f"leiden_{resolution}"
+
+    # Run Leiden clustering
+    adata = run_leiden_clustering(adata, resolution, cluster_key)
+
+    # Plot clusters
+    plot_clusters(adata, cluster_key, figure_dir=figure_dir)
+
+    # Compute and print overlap
+    contingency = compute_cluster_celltype_overlap(adata, cluster_key)
+    print("Cluster-Cell Type Contingency Table:")
+    print(contingency)
+
+    return adata
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_filtering.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_filtering.py
new file mode 100644
index 0000000..2bc75d6
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_filtering.py
@@ -0,0 +1,246 @@
+"""Data filtering module for scRNA-seq analysis workflow.
+
+Functions for filtering donors and cell types with insufficient observations.
+"""
+
+from pathlib import Path
+
+import anndata as ad
+import matplotlib.pyplot as plt
+import pandas as pd
+import scanpy as sc
+from scipy.stats import scoreatpercentile
+
+
+def compute_donor_cell_counts(adata: ad.AnnData) -> pd.Series:
+    """Calculate how many cells each donor has.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with 'donor_id' in obs
+
+    Returns
+    -------
+    pd.Series
+        Cell counts per donor
+    """
+    return pd.Series(adata.obs["donor_id"]).value_counts()
+
+
+def plot_donor_cell_distribution(
+    donor_cell_counts: pd.Series,
+    cutoff_percentile: float = 1.0,
+    figure_dir: Path | None = None,
+) -> int:
+    """Plot distribution of cells per donor and determine cutoff.
+
+    Parameters
+    ----------
+    donor_cell_counts : pd.Series
+        Cell counts per donor
+    cutoff_percentile : float
+        Percentile to use as cutoff (default: 1.0)
+    figure_dir : Path, optional
+        Directory to save figure
+
+    Returns
+    -------
+    int
+        Minimum cells per donor cutoff
+    """
+    min_cells_per_donor = int(
+        scoreatpercentile(donor_cell_counts.values, cutoff_percentile)
+    )
+
+    plt.figure(figsize=(10, 6))
+    plt.hist(donor_cell_counts.values, bins=50, color="skyblue", edgecolor="black")
+    plt.title("Distribution of Total Cells per Donor")
+    plt.xlabel("Number of Cells Captured")
+    plt.ylabel("Number of Donors")
+    plt.grid(axis="y", alpha=0.5)
+
+    print(
+        f"cutoff of {min_cells_per_donor} would exclude "
+        f"{(donor_cell_counts < min_cells_per_donor).sum()} donors"
+    )
+    plt.axvline(
+        min_cells_per_donor,
+        color="red",
+        linestyle="dashed",
+        linewidth=1,
+        label=f"Cutoff ({min_cells_per_donor} cells)",
+    )
+    plt.legend()
+
+    if figure_dir is not None:
+        plt.savefig(
+            figure_dir / "donor_cell_counts_distribution.png",
+            dpi=300,
+            bbox_inches="tight",
+        )
+    plt.close()
+
+    return min_cells_per_donor
+
+
+def filter_donors_by_cell_count(
+    adata: ad.AnnData, min_cells_per_donor: int
+) -> ad.AnnData:
+    """Filter to keep only donors with sufficient cells.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+    min_cells_per_donor : int
+        Minimum cells required per donor
+
+    Returns
+    -------
+    AnnData
+        Filtered AnnData object
+    """
+    donor_cell_counts = compute_donor_cell_counts(adata)
+    print(f"Filtering to keep only donors with at least {min_cells_per_donor} cells.")
+    print(
+        f"Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}"
+    )
+    valid_donors = donor_cell_counts[donor_cell_counts >= min_cells_per_donor].index
+    filtered = adata[adata.obs["donor_id"].isin(valid_donors)]
+    print(f"Number of donors after filtering: {len(valid_donors)}")
+    return filtered
+
+
+def filter_cell_types_by_frequency(
+    adata: ad.AnnData, min_cells: int = 10, percent_donors: float = 0.95
+) -> ad.AnnData:
+    """Filter cell types that don't have sufficient observations.
+
+    Keep cell types with at least min_cells in at least percent_donors of donors.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+    min_cells : int
+        Minimum cells per cell type per donor
+    percent_donors : float
+        Fraction of donors that must meet the min_cells threshold
+
+    Returns
+    -------
+    AnnData
+        Filtered AnnData object
+    """
+    counts_per_donor = pd.crosstab(adata.obs["donor_id"], adata.obs["cell_type"])
+    donor_count = counts_per_donor.shape[0]
+
+    cell_types_to_keep = counts_per_donor.columns[
+        (counts_per_donor >= min_cells).sum(axis=0) >= (donor_count * percent_donors)
+    ]
+
+    print(
+        f"Keeping {len(cell_types_to_keep)} cell types out of "
+        f"{len(counts_per_donor.columns)}"
+    )
+    print(f"Cell types to keep: {cell_types_to_keep.tolist()}")
+
+    return adata[adata.obs["cell_type"].isin(cell_types_to_keep)]
+
+
+def filter_donors_with_missing_cell_types(
+    adata: ad.AnnData, min_cells: int = 10
+) -> ad.AnnData:
+    """Filter donors who have zeros in any remaining cell types.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+    min_cells : int
+        Minimum cells per cell type per donor
+
+    Returns
+    -------
+    AnnData
+        Filtered AnnData object
+    """
+    donor_celltype_counts = pd.crosstab(adata.obs["donor_id"], adata.obs["cell_type"])
+    valid_donors = donor_celltype_counts.index[
+        (donor_celltype_counts >= min_cells).all(axis=1)
+    ]
+    filtered = adata[adata.obs["donor_id"].isin(valid_donors)]
+    print(f"Final number of donors after filtering: {len(valid_donors)}")
+    return filtered
+
+
+def load_to_memory_and_filter_genes(adata: ad.AnnData) -> ad.AnnData:
+    """Load lazy AnnData to memory and filter zero-count genes.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Lazy AnnData object
+
+    Returns
+    -------
+    AnnData
+        In-memory AnnData with filtered genes
+    """
+    print("Loading data into memory (this can take a few minutes)...")
+    adata_loaded = adata.to_memory()
+
+    print("Filtering genes with zero counts...")
+    sc.pp.filter_genes(adata_loaded, min_counts=1)
+
+    return adata_loaded
+
+
+def run_filtering_pipeline(
+    adata: ad.AnnData,
+    cutoff_percentile: float = 1.0,
+    min_cells_per_celltype: int = 10,
+    percent_donors: float = 0.95,
+    figure_dir: Path | None = None,
+) -> ad.AnnData:
+    """Run complete filtering pipeline.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Input AnnData object (can be lazy)
+    cutoff_percentile : float
+        Percentile for donor cell count cutoff
+    min_cells_per_celltype : int
+        Minimum cells per cell type per donor
+    percent_donors : float
+        Fraction of donors that must meet cell count threshold
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    AnnData
+        Filtered and loaded AnnData object
+    """
+    # Step 1: Filter donors by total cell count
+    donor_counts = compute_donor_cell_counts(adata)
+    min_cells = plot_donor_cell_distribution(
+        donor_counts, cutoff_percentile, figure_dir
+    )
+    adata = filter_donors_by_cell_count(adata, min_cells)
+
+    # Step 2: Filter cell types by frequency
+    adata = filter_cell_types_by_frequency(
+        adata, min_cells_per_celltype, percent_donors
+    )
+
+    # Step 3: Filter donors with missing cell types
+    adata = filter_donors_with_missing_cell_types(adata, min_cells_per_celltype)
+
+    # Step 4: Load to memory and filter genes
+    adata = load_to_memory_and_filter_genes(adata)
+
+    print(f"Final dataset shape: {adata.shape}")
+    return adata
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_loading.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_loading.py
new file mode 100644
index 0000000..491784c
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_loading.py
@@ -0,0 +1,77 @@
+"""Data loading module for scRNA-seq analysis workflow.
+
+Functions for downloading and loading single-cell RNA-seq data.
+"""
+
+import os
+from pathlib import Path
+
+import anndata as ad
+import h5py
+from anndata.experimental import read_lazy
+
+
+def download_data(datafile: Path, url: str) -> None:
+    """Download data file if it doesn't exist.
+
+    Parameters
+    ----------
+    datafile : Path
+        Path to save the downloaded file
+    url : str
+        URL to download from
+    """
+    if not datafile.exists():
+        cmd = f"wget -O {datafile.as_posix()} {url}"
+        print(f"Downloading data from {url} to {datafile.as_posix()}")
+        os.system(cmd)
+
+
+def load_lazy_anndata(datafile: Path, load_annotation_index: bool = True) -> ad.AnnData:
+    """Load AnnData object lazily from h5ad file.
+
+    Parameters
+    ----------
+    datafile : Path
+        Path to h5ad file
+    load_annotation_index : bool
+        Whether to load annotation index
+
+    Returns
+    -------
+    AnnData
+        Lazily loaded AnnData object
+    """
+    adata = read_lazy(
+        h5py.File(datafile, "r"), load_annotation_index=load_annotation_index
+    )
+    return adata
+
+
+def load_anndata(datafile: Path) -> ad.AnnData:
+    """Load AnnData object from h5ad file.
+
+    Parameters
+    ----------
+    datafile : Path
+        Path to h5ad file
+
+    Returns
+    -------
+    AnnData
+        AnnData object
+    """
+    return ad.read_h5ad(datafile)
+
+
+def save_anndata(adata: ad.AnnData, filepath: Path) -> None:
+    """Save AnnData object to h5ad file.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object to save
+    filepath : Path
+        Path to save the file
+    """
+    adata.write(filepath)
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/differential_expression.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/differential_expression.py
new file mode 100644
index 0000000..ec257a7
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/differential_expression.py
@@ -0,0 +1,268 @@
+"""Differential expression module for scRNA-seq analysis workflow.
+
+Functions for running DESeq2-based differential expression analysis.
+"""
+
+import anndata as ad
+import numpy as np
+import pandas as pd
+from pydeseq2.dds import DeseqDataSet
+from pydeseq2.ds import DeseqStats
+from sklearn.preprocessing import StandardScaler
+
+
+def extract_age_from_development_stage(pb_adata: ad.AnnData) -> ad.AnnData:
+    """Extract numeric age from development_stage column.
+
+    Parameters
+    ----------
+    pb_adata : AnnData
+        Pseudobulk AnnData with 'development_stage' in obs
+
+    Returns
+    -------
+    AnnData
+        AnnData with 'age' column added to obs
+    """
+    ages = (
+        pb_adata.obs["development_stage"].str.extract(r"(\d+)-year-old").astype(float)
+    )
+    pb_adata.obs["age"] = ages
+    return pb_adata
+
+
+def prepare_deseq_inputs(
+    pb_adata: ad.AnnData,
+    var_to_feature: dict | None = None,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Prepare counts and metadata for DESeq2.
+
+    Parameters
+    ----------
+    pb_adata : AnnData
+        Pseudobulk AnnData object
+    var_to_feature : dict, optional
+        Mapping from var_names to feature names
+
+    Returns
+    -------
+    tuple[pd.DataFrame, pd.DataFrame]
+        Counts dataframe and metadata dataframe
+    """
+    # Extract counts
+    if var_to_feature is not None:
+        columns = [var_to_feature.get(var, var) for var in pb_adata.var_names]
+    else:
+        columns = pb_adata.var_names.tolist()
+
+    counts_df = pd.DataFrame(
+        pb_adata.X.toarray(),
+        index=pb_adata.obs_names,
+        columns=columns,
+    )
+    # Remove duplicate columns
+    counts_df = counts_df.loc[:, ~counts_df.columns.duplicated()]
+
+    # Extract metadata
+    metadata = pb_adata.obs.copy()
+
+    # Scale continuous variables
+    if "age" in metadata.columns:
+        scaler = StandardScaler()
+        metadata["age_scaled"] = scaler.fit_transform(metadata[["age"]]).flatten()
+        metadata["age_scaled"] = metadata["age_scaled"].astype(float)
+        print("Age scaling applied:")
+        print(metadata[["age", "age_scaled"]].head())
+
+    return counts_df, metadata
+
+
+def subset_by_cell_type(
+    pb_adata: ad.AnnData,
+    counts_df: pd.DataFrame,
+    metadata: pd.DataFrame,
+    cell_type: str,
+) -> tuple[ad.AnnData, pd.DataFrame, pd.DataFrame]:
+    """Subset data to a specific cell type.
+
+    Parameters
+    ----------
+    pb_adata : AnnData
+        Pseudobulk AnnData object
+    counts_df : pd.DataFrame
+        Counts dataframe
+    metadata : pd.DataFrame
+        Metadata dataframe
+    cell_type : str
+        Cell type to subset to
+
+    Returns
+    -------
+    tuple[AnnData, pd.DataFrame, pd.DataFrame]
+        Subsetted AnnData, counts, and metadata
+    """
+    pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
+    counts_df_ct = counts_df.loc[pb_adata_ct.obs_names].copy()
+    metadata_ct = metadata.loc[pb_adata_ct.obs_names].copy()
+
+    return pb_adata_ct, counts_df_ct, metadata_ct
+
+
+def run_deseq2(
+    counts_df: pd.DataFrame,
+    metadata: pd.DataFrame,
+    design_factors: list[str],
+    n_cpus: int = 2,
+) -> DeseqDataSet:
+    """Initialize and fit DESeq2 model.
+
+    Parameters
+    ----------
+    counts_df : pd.DataFrame
+        Counts dataframe
+    metadata : pd.DataFrame
+        Metadata dataframe
+    design_factors : list[str]
+        Design factors for the model
+    n_cpus : int
+        Number of CPUs for parallel processing
+
+    Returns
+    -------
+    DeseqDataSet
+        Fitted DESeq2 dataset
+    """
+    # Validate required columns
+    for factor in design_factors:
+        assert factor in metadata.columns, f"{factor} column missing in metadata"
+
+    # Initialize and fit
+    dds = DeseqDataSet(
+        counts=counts_df,
+        metadata=metadata,
+        design_factors=design_factors,
+        refit_cooks=True,
+        n_cpus=n_cpus,
+    )
+    dds.deseq2()
+
+    return dds
+
+
+def run_wald_test(
+    dds: DeseqDataSet,
+    contrast: np.ndarray | None = None,
+) -> DeseqStats:
+    """Run Wald test for differential expression.
+
+    Parameters
+    ----------
+    dds : DeseqDataSet
+        Fitted DESeq2 dataset
+    contrast : np.ndarray, optional
+        Contrast vector for the test
+
+    Returns
+    -------
+    DeseqStats
+        Statistics results object
+    """
+    model_vars = dds.varm["LFC"].columns
+    print(f"Model variables: {model_vars.tolist()}")
+
+    if contrast is None:
+        # Default: test second variable (typically age_scaled)
+        contrast = np.zeros(len(model_vars))
+        contrast[1] = 1
+
+    print(f"Contrast: {contrast}")
+
+    stat_res = DeseqStats(dds, contrast=contrast)
+    stat_res.summary()
+    stat_res.run_wald_test()
+
+    return stat_res
+
+
+def get_significant_genes(
+    stat_res: DeseqStats,
+    padj_threshold: float = 0.05,
+) -> pd.DataFrame:
+    """Extract significant genes from DESeq2 results.
+
+    Parameters
+    ----------
+    stat_res : DeseqStats
+        DESeq2 statistics results
+    padj_threshold : float
+        Adjusted p-value threshold
+
+    Returns
+    -------
+    pd.DataFrame
+        Significant genes sorted by log2 fold change
+    """
+    res = stat_res.results_df
+    sigs = res[res["padj"] < padj_threshold]
+    sigs = sigs.sort_values("log2FoldChange", ascending=False)
+
+    print(f"Found {len(sigs)} significant genes.")
+    print(sigs[["log2FoldChange", "padj"]].head())
+
+    return sigs
+
+
+def run_differential_expression_pipeline(
+    pb_adata: ad.AnnData,
+    cell_type: str,
+    design_factors: list[str] | None = None,
+    var_to_feature: dict | None = None,
+    n_cpus: int = 8,
+) -> tuple[DeseqStats, pd.DataFrame, pd.DataFrame]:
+    """Run complete differential expression pipeline for a cell type.
+
+    Parameters
+    ----------
+    pb_adata : AnnData
+        Pseudobulk AnnData object
+    cell_type : str
+        Cell type to analyze
+    design_factors : list[str], optional
+        Design factors (default: ['age_scaled', 'sex'])
+    var_to_feature : dict, optional
+        Mapping from var_names to feature names
+    n_cpus : int
+        Number of CPUs
+
+    Returns
+    -------
+    tuple[DeseqStats, pd.DataFrame, pd.DataFrame]
+        Statistics results, full results dataframe, and counts dataframe
+    """
+    if design_factors is None:
+        design_factors = ["age_scaled", "sex"]
+
+    # Extract age
+    pb_adata = extract_age_from_development_stage(pb_adata)
+
+    # Prepare inputs
+    counts_df, metadata = prepare_deseq_inputs(pb_adata, var_to_feature)
+
+    # Subset to cell type
+    _, counts_df_ct, metadata_ct = subset_by_cell_type(
+        pb_adata, counts_df, metadata, cell_type
+    )
+
+    print(f"Running DE analysis for cell type: {cell_type}")
+    print(f"Number of samples: {len(counts_df_ct)}")
+
+    # Run DESeq2
+    dds = run_deseq2(counts_df_ct, metadata_ct, design_factors, n_cpus)
+
+    # Run Wald test
+    stat_res = run_wald_test(dds)
+
+    # Get significant genes
+    _ = get_significant_genes(stat_res)
+
+    return stat_res, stat_res.results_df, counts_df_ct
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/dimensionality_reduction.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/dimensionality_reduction.py
new file mode 100644
index 0000000..ddd7146
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/dimensionality_reduction.py
@@ -0,0 +1,182 @@
+"""Dimensionality reduction module for scRNA-seq analysis workflow.
+
+Functions for batch correction, neighbor computation, and UMAP generation.
+"""
+
+from pathlib import Path
+
+import anndata as ad
+import matplotlib.pyplot as plt
+import scanpy as sc
+import scanpy.external as sce
+
+
+def run_harmony_integration(
+    adata: ad.AnnData,
+    batch_key: str = "donor_id",
+    basis: str = "X_pca",
+    adjusted_basis: str = "X_pca_harmony",
+) -> tuple[ad.AnnData, str]:
+    """Run Harmony batch correction on PCA coordinates.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with PCA computed
+    batch_key : str
+        Column name for batch variable
+    basis : str
+        Name of PCA coordinates
+    adjusted_basis : str
+        Name for corrected coordinates
+
+    Returns
+    -------
+    tuple[AnnData, str]
+        AnnData with Harmony results and the representation to use
+    """
+    try:
+        sce.pp.harmony_integrate(
+            adata, key=batch_key, basis=basis, adjusted_basis=adjusted_basis
+        )
+        use_rep = adjusted_basis
+        print("Harmony integration successful. Using corrected PCA.")
+    except ImportError:
+        print(
+            "Harmony not installed. Proceeding with standard PCA "
+            "(Warning: Batch effects may persist)."
+        )
+        print("To install: pip install harmony-pytorch")
+        use_rep = basis
+
+    return adata, use_rep
+
+
+def plot_pca_qc(adata: ad.AnnData, figure_dir: Path | None = None) -> None:
+    """Plot PCA colored by total counts and cell type.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with PCA computed
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    sc.pl.pca(
+        adata, color=["total_counts", "cell_type"], components=["1,2"], show=False
+    )
+    if figure_dir is not None:
+        plt.savefig(figure_dir / "pca_cell_type.png", dpi=300, bbox_inches="tight")
+    plt.close()
+
+
+def compute_neighbors(
+    adata: ad.AnnData,
+    n_neighbors: int = 30,
+    n_pcs: int = 40,
+    use_rep: str = "X_pca_harmony",
+) -> ad.AnnData:
+    """Compute neighborhood graph.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+    n_neighbors : int
+        Number of neighbors
+    n_pcs : int
+        Number of PCs to use
+    use_rep : str
+        Representation to use
+
+    Returns
+    -------
+    AnnData
+        AnnData with neighbor graph
+    """
+    sc.pp.neighbors(adata, n_neighbors=n_neighbors, n_pcs=n_pcs, use_rep=use_rep)
+    return adata
+
+
+def compute_umap(
+    adata: ad.AnnData,
+    init_pos: str = "X_pca_harmony",
+) -> ad.AnnData:
+    """Compute UMAP embedding.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with neighbor graph
+    init_pos : str
+        Initial position for UMAP
+
+    Returns
+    -------
+    AnnData
+        AnnData with UMAP coordinates
+    """
+    sc.tl.umap(adata, init_pos=init_pos)
+    return adata
+
+
+def plot_umap_qc(adata: ad.AnnData, figure_dir: Path | None = None) -> None:
+    """Plot UMAP colored by total counts.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with UMAP
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    sc.pl.umap(adata, color="total_counts", show=False)
+    if figure_dir is not None:
+        plt.savefig(figure_dir / "umap_total_counts.png", dpi=300, bbox_inches="tight")
+    plt.close()
+
+
+def run_dimensionality_reduction_pipeline(
+    adata: ad.AnnData,
+    batch_key: str = "donor_id",
+    n_neighbors: int = 30,
+    n_pcs: int = 40,
+    figure_dir: Path | None = None,
+) -> ad.AnnData:
+    """Run complete dimensionality reduction pipeline.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Input AnnData object with PCA computed
+    batch_key : str
+        Column for batch correction
+    n_neighbors : int
+        Number of neighbors for graph
+    n_pcs : int
+        Number of PCs to use
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    AnnData
+        AnnData with UMAP coordinates
+    """
+    # Run Harmony integration
+    adata, use_rep = run_harmony_integration(adata, batch_key)
+
+    # Plot PCA QC
+    plot_pca_qc(adata, figure_dir)
+
+    # Compute neighbors
+    adata = compute_neighbors(adata, n_neighbors, n_pcs, use_rep)
+
+    # Compute UMAP
+    init_pos = use_rep if use_rep == "X_pca_harmony" else "spectral"
+    adata = compute_umap(adata, init_pos)
+
+    # Plot UMAP QC
+    plot_umap_qc(adata, figure_dir)
+
+    return adata
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/overrepresentation_analysis.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/overrepresentation_analysis.py
new file mode 100644
index 0000000..9aa6dd2
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/overrepresentation_analysis.py
@@ -0,0 +1,262 @@
+"""Overrepresentation analysis module for scRNA-seq analysis workflow.
+
+Functions for Enrichr-based overrepresentation analysis.
+"""
+
+from pathlib import Path
+
+import gseapy as gp
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+
+
+def get_significant_gene_lists(
+    results_df: pd.DataFrame,
+    padj_threshold: float = 0.05,
+) -> tuple[list[str], list[str]]:
+    """Extract lists of up and down regulated genes.
+
+    Parameters
+    ----------
+    results_df : pd.DataFrame
+        DESeq2 results dataframe
+    padj_threshold : float
+        Adjusted p-value threshold
+
+    Returns
+    -------
+    tuple[list[str], list[str]]
+        Lists of upregulated and downregulated genes
+    """
+    up_genes = results_df[
+        (results_df["padj"] < padj_threshold) & (results_df["log2FoldChange"] > 0)
+    ].index.tolist()
+
+    down_genes = results_df[
+        (results_df["padj"] < padj_threshold) & (results_df["log2FoldChange"] < 0)
+    ].index.tolist()
+
+    print(
+        f"Analyzing {len(up_genes)} upregulated and "
+        f"{len(down_genes)} downregulated genes."
+    )
+
+    return up_genes, down_genes
+
+
+def run_enrichr(
+    gene_list: list[str],
+    gene_sets: list[str] | None = None,
+    organism: str = "human",
+) -> gp.Enrichr | None:
+    """Run Enrichr overrepresentation analysis.
+
+    Parameters
+    ----------
+    gene_list : list[str]
+        List of gene names
+    gene_sets : list[str], optional
+        Gene set databases to use
+    organism : str
+        Organism name
+
+    Returns
+    -------
+    gp.Enrichr or None
+        Enrichr results object or None if no genes
+    """
+    if len(gene_list) == 0:
+        print("No genes to analyze.")
+        return None
+
+    if gene_sets is None:
+        gene_sets = ["MSigDB_Hallmark_2020"]
+
+    enr = gp.enrichr(
+        gene_list=gene_list,
+        gene_sets=gene_sets,
+        organism=organism,
+        outdir=None,
+    )
+
+    return enr
+
+
+def run_enrichr_both_directions(
+    results_df: pd.DataFrame,
+    gene_sets: list[str] | None = None,
+    padj_threshold: float = 0.05,
+) -> tuple[gp.Enrichr | None, gp.Enrichr | None]:
+    """Run Enrichr for both up and down regulated genes.
+
+    Parameters
+    ----------
+    results_df : pd.DataFrame
+        DESeq2 results dataframe
+    gene_sets : list[str], optional
+        Gene set databases
+    padj_threshold : float
+        Adjusted p-value threshold
+
+    Returns
+    -------
+    tuple[gp.Enrichr, gp.Enrichr]
+        Enrichr results for up and down genes
+    """
+    up_genes, down_genes = get_significant_gene_lists(results_df, padj_threshold)
+
+    enr_up = None
+    enr_down = None
+
+    if len(up_genes) > 0:
+        enr_up = run_enrichr(up_genes, gene_sets)
+        if enr_up is not None:
+            print("Upregulated Pathways:")
+            print(enr_up.results[["Term", "Adjusted P-value", "Overlap"]].head(10))
+
+    if len(down_genes) > 0:
+        enr_down = run_enrichr(down_genes, gene_sets)
+        if enr_down is not None:
+            print("Downregulated Pathways:")
+            print(enr_down.results[["Term", "Adjusted P-value", "Overlap"]].head(10))
+
+    return enr_up, enr_down
+
+
+def prepare_enrichr_plot_data(
+    enr_up: gp.Enrichr | None,
+    enr_down: gp.Enrichr | None,
+    n_top: int = 10,
+) -> pd.DataFrame | None:
+    """Prepare Enrichr results for plotting.
+
+    Parameters
+    ----------
+    enr_up : gp.Enrichr
+        Enrichr results for upregulated genes
+    enr_down : gp.Enrichr
+        Enrichr results for downregulated genes
+    n_top : int
+        Number of top pathways per direction
+
+    Returns
+    -------
+    pd.DataFrame or None
+        Combined dataframe for plotting
+    """
+    dfs = []
+
+    if enr_up is not None:
+        up_res = enr_up.results.copy()
+        up_res["Direction"] = "Upregulated"
+        up_res["Color"] = "Red"
+        top_up = up_res.sort_values("Adjusted P-value").head(n_top)
+        dfs.append(top_up)
+
+    if enr_down is not None:
+        down_res = enr_down.results.copy()
+        down_res["Direction"] = "Downregulated"
+        down_res["Color"] = "Blue"
+        top_down = down_res.sort_values("Adjusted P-value").head(n_top)
+        dfs.append(top_down)
+
+    if not dfs:
+        return None
+
+    combined = pd.concat(dfs)
+
+    # Compute -log10(P-value)
+    combined["log_p"] = -np.log10(combined["Adjusted P-value"])
+
+    # Extract gene count from Overlap (e.g., "5/200" -> 5)
+    combined["Gene_Count"] = combined["Overlap"].apply(lambda x: int(x.split("/")[0]))
+
+    return combined
+
+
+def plot_enrichr_results(
+    combined: pd.DataFrame,
+    figure_dir: Path | None = None,
+    title: str = "Top Enriched Pathways (Up vs Down)",
+) -> None:
+    """Plot Enrichr results as dot plot.
+
+    Parameters
+    ----------
+    combined : pd.DataFrame
+        Prepared Enrichr dataframe
+    figure_dir : Path, optional
+        Directory to save figures
+    title : str
+        Plot title
+    """
+    print(f"Plotting {len(combined)} pathways.")
+
+    plt.figure(figsize=(10, 8))
+
+    sns.scatterplot(
+        data=combined,
+        x="log_p",
+        y="Term",
+        hue="Direction",
+        size="Gene_Count",
+        palette={"Upregulated": "#E41A1C", "Downregulated": "#377EB8"},
+        sizes=(50, 400),
+        alpha=0.8,
+    )
+
+    plt.title(title, fontsize=14)
+    plt.xlabel("-log10(Adjusted P-value)", fontsize=12)
+    plt.ylabel("")
+    plt.axvline(
+        -np.log10(0.05), color="gray", linestyle="--", alpha=0.5, label="p=0.05"
+    )
+    plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
+    plt.grid(axis="x", alpha=0.3)
+    plt.tight_layout()
+
+    if figure_dir is not None:
+        plt.savefig(figure_dir / "enrichr_pathways.png", dpi=300, bbox_inches="tight")
+    plt.close()
+
+
+def run_overrepresentation_pipeline(
+    results_df: pd.DataFrame,
+    gene_sets: list[str] | None = None,
+    padj_threshold: float = 0.05,
+    n_top: int = 10,
+    figure_dir: Path | None = None,
+) -> tuple[gp.Enrichr | None, gp.Enrichr | None]:
+    """Run complete overrepresentation analysis pipeline.
+
+    Parameters
+    ----------
+    results_df : pd.DataFrame
+        DESeq2 results dataframe
+    gene_sets : list[str], optional
+        Gene set databases
+    padj_threshold : float
+        Adjusted p-value threshold
+    n_top : int
+        Number of top pathways to show
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    tuple[gp.Enrichr, gp.Enrichr]
+        Enrichr results for up and down genes
+    """
+    # Run Enrichr
+    enr_up, enr_down = run_enrichr_both_directions(
+        results_df, gene_sets, padj_threshold
+    )
+
+    # Prepare and plot
+    combined = prepare_enrichr_plot_data(enr_up, enr_down, n_top)
+    if combined is not None:
+        plot_enrichr_results(combined, figure_dir)
+
+    return enr_up, enr_down
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/pathway_analysis.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pathway_analysis.py
new file mode 100644
index 0000000..bdba7a5
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pathway_analysis.py
@@ -0,0 +1,249 @@
+"""Pathway analysis module for scRNA-seq analysis workflow.
+
+Functions for Gene Set Enrichment Analysis (GSEA).
+"""
+
+from pathlib import Path
+
+import gseapy as gp
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+
+
+def prepare_ranked_list(results_df: pd.DataFrame) -> pd.DataFrame:
+    """Prepare ranked gene list for GSEA from DE results.
+
+    Parameters
+    ----------
+    results_df : pd.DataFrame
+        DESeq2 results dataframe with 'stat' column
+
+    Returns
+    -------
+    pd.DataFrame
+        Ranked gene list sorted by statistic
+    """
+    rank_df = results_df[["stat"]].dropna().sort_values("stat", ascending=False)
+    return rank_df
+
+
+def run_gsea_prerank(
+    rank_df: pd.DataFrame,
+    gene_sets: list[str] | None = None,
+    min_size: int = 10,
+    max_size: int = 1000,
+    permutation_num: int = 1000,
+    threads: int = 4,
+    seed: int = 42,
+) -> gp.GSEA:
+    """Run GSEA preranked analysis.
+
+    Parameters
+    ----------
+    rank_df : pd.DataFrame
+        Ranked gene list
+    gene_sets : list[str], optional
+        Gene set databases to use
+    min_size : int
+        Minimum genes in pathway
+    max_size : int
+        Maximum genes in pathway
+    permutation_num : int
+        Number of permutations
+    threads : int
+        Number of threads
+    seed : int
+        Random seed
+
+    Returns
+    -------
+    gp.GSEA
+        GSEA results object
+    """
+    if gene_sets is None:
+        gene_sets = ["MSigDB_Hallmark_2020"]
+
+    prerank_res = gp.prerank(
+        rnk=rank_df,
+        gene_sets=gene_sets,
+        threads=threads,
+        min_size=min_size,
+        max_size=max_size,
+        permutation_num=permutation_num,
+        seed=seed,
+    )
+
+    return prerank_res
+
+
+def get_gsea_top_terms(
+    prerank_res: gp.GSEA,
+    n_top: int = 10,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Get top upregulated and downregulated pathways.
+
+    Parameters
+    ----------
+    prerank_res : gp.GSEA
+        GSEA results object
+    n_top : int
+        Number of top terms to return
+
+    Returns
+    -------
+    tuple[pd.DataFrame, pd.DataFrame]
+        Top upregulated and downregulated pathways
+    """
+    terms = prerank_res.res2d.sort_values("NES", ascending=False)
+
+    print("Top Upregulated Pathways:")
+    print(terms[["Term", "NES", "FDR q-val"]].head(n_top))
+
+    print("\nTop Downregulated Pathways:")
+    print(terms[["Term", "NES", "FDR q-val"]].tail(n_top))
+
+    top_up = terms.head(n_top)
+    top_down = terms.tail(n_top)
+
+    return top_up, top_down
+
+
+def prepare_gsea_plot_data(
+    prerank_res: gp.GSEA,
+    n_top: int = 10,
+    label_prefix: str = "MSigDB_Hallmark_2020__",
+) -> pd.DataFrame:
+    """Prepare GSEA results for plotting.
+
+    Parameters
+    ----------
+    prerank_res : gp.GSEA
+        GSEA results object
+    n_top : int
+        Number of top terms per direction
+    label_prefix : str
+        Prefix to remove from term names
+
+    Returns
+    -------
+    pd.DataFrame
+        Prepared dataframe for plotting
+    """
+    gsea_df = prerank_res.res2d.copy()
+    gsea_df = gsea_df.sort_values("NES", ascending=False)
+
+    top_up = gsea_df.head(n_top).copy()
+    top_down = gsea_df.tail(n_top).copy()
+    combined = pd.concat([top_up, top_down])
+
+    # Add direction
+    combined["Direction"] = combined["NES"].apply(
+        lambda x: "Upregulated" if x > 0 else "Downregulated"
+    )
+
+    # Compute -log10(FDR)
+    combined["FDR q-val"] = pd.to_numeric(combined["FDR q-val"], errors="coerce")
+    combined["log_FDR"] = -np.log10(combined["FDR q-val"] + 1e-10)
+
+    # Get gene count from leading edge
+    combined["Count"] = combined["Lead_genes"].apply(lambda x: len(str(x).split(";")))
+
+    # Clean term names
+    combined["Term"] = combined["Term"].str.replace(label_prefix, "", regex=False)
+
+    return combined
+
+
+def plot_gsea_results(
+    combined_gsea: pd.DataFrame,
+    figure_dir: Path | None = None,
+    title: str = "Top GSEA Pathways (Up vs Down)",
+) -> None:
+    """Plot GSEA results as dot plot.
+
+    Parameters
+    ----------
+    combined_gsea : pd.DataFrame
+        Prepared GSEA dataframe
+    figure_dir : Path, optional
+        Directory to save figures
+    title : str
+        Plot title
+    """
+    plt.figure(figsize=(10, 8))
+
+    sns.scatterplot(
+        data=combined_gsea,
+        x="log_FDR",
+        y="Term",
+        hue="Direction",
+        size="Count",
+        palette={"Upregulated": "#E41A1C", "Downregulated": "#377EB8"},
+        sizes=(50, 400),
+        alpha=0.8,
+    )
+
+    plt.title(title, fontsize=14)
+    plt.xlabel("-log10(FDR q-value)", fontsize=12)
+    plt.ylabel("")
+
+    plt.axvline(
+        -np.log10(0.25),
+        color="gray",
+        linestyle=":",
+        label="FDR=0.25 (GSEA standard)",
+    )
+    plt.axvline(-np.log10(0.05), color="gray", linestyle="--", label="FDR=0.05")
+
+    plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
+    plt.grid(axis="x", alpha=0.3)
+    plt.tight_layout()
+
+    if figure_dir is not None:
+        plt.savefig(figure_dir / "gsea_pathways.png", dpi=300, bbox_inches="tight")
+    plt.close()
+
+
+def run_gsea_pipeline(
+    results_df: pd.DataFrame,
+    gene_sets: list[str] | None = None,
+    n_top: int = 10,
+    figure_dir: Path | None = None,
+) -> gp.GSEA:
+    """Run complete GSEA pipeline.
+
+    Parameters
+    ----------
+    results_df : pd.DataFrame
+        DESeq2 results dataframe
+    gene_sets : list[str], optional
+        Gene set databases
+    n_top : int
+        Number of top pathways to show
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    gp.GSEA
+        GSEA results object
+    """
+    # Prepare ranked list
+    rank_df = prepare_ranked_list(results_df)
+
+    # Run GSEA
+    prerank_res = run_gsea_prerank(rank_df, gene_sets)
+
+    # Get top terms
+    get_gsea_top_terms(prerank_res, n_top)
+
+    # Prepare and plot
+    combined = prepare_gsea_plot_data(prerank_res, n_top)
+    print(f"Plotting {len(combined)} pathways.")
+    print(combined[["Term", "NES", "FDR q-val", "Count"]].head())
+
+    plot_gsea_results(combined, figure_dir)
+
+    return prerank_res
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/predictive_modeling.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/predictive_modeling.py
new file mode 100644
index 0000000..474ecb4
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/predictive_modeling.py
@@ -0,0 +1,337 @@
+"""Predictive modeling module for scRNA-seq analysis workflow.
+
+Functions for building and evaluating age prediction models.
+"""
+
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from sklearn.metrics import mean_absolute_error, r2_score
+from sklearn.model_selection import ShuffleSplit
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import LinearSVR
+
+
+def prepare_features(
+    counts_df: pd.DataFrame,
+    metadata: pd.DataFrame,
+) -> tuple[pd.DataFrame, np.ndarray]:
+    """Prepare feature matrix and target variable.
+
+    Parameters
+    ----------
+    counts_df : pd.DataFrame
+        Gene expression counts
+    metadata : pd.DataFrame
+        Metadata with 'age' and 'sex' columns
+
+    Returns
+    -------
+    tuple[pd.DataFrame, np.ndarray]
+        Feature matrix (genes + sex) and age target
+    """
+    X_genes = counts_df.copy()
+
+    # Add sex as binary feature
+    sex_encoded = pd.get_dummies(metadata["sex"], drop_first=True)
+    X = pd.concat([X_genes, sex_encoded], axis=1)
+
+    # Target: age
+    y = metadata["age"].values
+
+    print(f"Feature matrix shape: {X.shape}")
+    print(f"Number of samples: {len(y)}")
+    print(f"Age range: {y.min():.1f} - {y.max():.1f} years")
+
+    return X, y
+
+
+def prepare_baseline_features(metadata: pd.DataFrame) -> pd.DataFrame:
+    """Prepare baseline feature matrix (sex only).
+
+    Parameters
+    ----------
+    metadata : pd.DataFrame
+        Metadata with 'sex' column
+
+    Returns
+    -------
+    pd.DataFrame
+        Sex-only feature matrix
+    """
+    return pd.get_dummies(metadata["sex"], drop_first=True)
+
+
+def train_evaluate_fold(
+    X_train: np.ndarray,
+    X_test: np.ndarray,
+    y_train: np.ndarray,
+    y_test: np.ndarray,
+    C: float = 1.0,
+    max_iter: int = 10000,
+    random_state: int = 42,
+) -> tuple[float, float, np.ndarray]:
+    """Train and evaluate model for one fold.
+
+    Parameters
+    ----------
+    X_train : np.ndarray
+        Training features
+    X_test : np.ndarray
+        Test features
+    y_train : np.ndarray
+        Training target
+    y_test : np.ndarray
+        Test target
+    C : float
+        Regularization parameter
+    max_iter : int
+        Maximum iterations
+    random_state : int
+        Random seed
+
+    Returns
+    -------
+    tuple[float, float, np.ndarray]
+        R2 score, MAE, and predictions
+    """
+    # Scale features
+    scaler = StandardScaler()
+    X_train_scaled = scaler.fit_transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    # Train model
+    model = LinearSVR(C=C, max_iter=max_iter, random_state=random_state, dual="auto")
+    model.fit(X_train_scaled, y_train)
+
+    # Predict
+    y_pred = model.predict(X_test_scaled)
+
+    # Metrics
+    r2 = r2_score(y_test, y_pred)
+    mae = mean_absolute_error(y_test, y_pred)
+
+    return r2, mae, y_pred
+
+
+def run_cross_validation(
+    X: pd.DataFrame,
+    y: np.ndarray,
+    n_splits: int = 5,
+    test_size: float = 0.2,
+    random_state: int = 42,
+) -> tuple[list[float], list[float], list[float], list[float]]:
+    """Run cross-validation for age prediction.
+
+    Parameters
+    ----------
+    X : pd.DataFrame
+        Feature matrix
+    y : np.ndarray
+        Target variable
+    n_splits : int
+        Number of CV splits
+    test_size : float
+        Fraction for test set
+    random_state : int
+        Random seed
+
+    Returns
+    -------
+    tuple[list, list, list, list]
+        R2 scores, MAE scores, predictions, actuals
+    """
+    cv = ShuffleSplit(n_splits=n_splits, test_size=test_size, random_state=random_state)
+
+    r2_scores = []
+    mae_scores = []
+    predictions_list = []
+    actual_list = []
+
+    for fold, (train_idx, test_idx) in enumerate(cv.split(X)):
+        print(f"\nFold {fold + 1}/{n_splits}")
+
+        X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
+        y_train, y_test = y[train_idx], y[test_idx]
+
+        r2, mae, y_pred = train_evaluate_fold(
+            X_train.values, X_test.values, y_train, y_test
+        )
+
+        r2_scores.append(r2)
+        mae_scores.append(mae)
+        predictions_list.extend(y_pred)
+        actual_list.extend(y_test)
+
+        print(f"  R2 Score: {r2:.3f}")
+        print(f"  MAE: {mae:.2f} years")
+
+    return r2_scores, mae_scores, predictions_list, actual_list
+
+
+def print_cv_results(
+    r2_scores: list[float],
+    mae_scores: list[float],
+    model_name: str = "Model",
+) -> None:
+    """Print cross-validation summary.
+
+    Parameters
+    ----------
+    r2_scores : list[float]
+        R2 scores per fold
+    mae_scores : list[float]
+        MAE scores per fold
+    model_name : str
+        Name of the model
+    """
+    print("\n" + "=" * 50)
+    print(f"{model_name} CROSS-VALIDATION RESULTS")
+    print("=" * 50)
+    print(f"R2 Score: {np.mean(r2_scores):.3f} +/- {np.std(r2_scores):.3f}")
+    print(f"MAE: {np.mean(mae_scores):.2f} +/- {np.std(mae_scores):.2f} years")
+    print("=" * 50)
+
+
+def plot_predictions(
+    actual: list[float],
+    predicted: list[float],
+    r2_scores: list[float],
+    mae_scores: list[float],
+    figure_dir: Path | None = None,
+) -> None:
+    """Plot predicted vs actual ages.
+
+    Parameters
+    ----------
+    actual : list[float]
+        Actual ages
+    predicted : list[float]
+        Predicted ages
+    r2_scores : list[float]
+        R2 scores
+    mae_scores : list[float]
+        MAE scores
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    plt.figure(figsize=(8, 6))
+
+    plt.scatter(actual, predicted, alpha=0.6, s=80)
+
+    min_age = min(min(actual), min(predicted))
+    max_age = max(max(actual), max(predicted))
+    plt.plot(
+        [min_age, max_age],
+        [min_age, max_age],
+        "r--",
+        linewidth=2,
+        label="Perfect Prediction",
+    )
+
+    plt.xlabel("Actual Age (years)", fontsize=12)
+    plt.ylabel("Predicted Age (years)", fontsize=12)
+    plt.title(
+        f"Age Prediction Performance\n"
+        f"R2 = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years",
+        fontsize=14,
+    )
+    plt.legend()
+    plt.grid(alpha=0.3)
+    plt.tight_layout()
+
+    if figure_dir is not None:
+        plt.savefig(
+            figure_dir / "age_prediction_performance.png", dpi=300, bbox_inches="tight"
+        )
+    plt.close()
+
+
+def compare_models(
+    full_r2: list[float],
+    full_mae: list[float],
+    baseline_r2: list[float],
+    baseline_mae: list[float],
+) -> None:
+    """Print comparison between full and baseline models.
+
+    Parameters
+    ----------
+    full_r2 : list[float]
+        R2 scores for full model
+    full_mae : list[float]
+        MAE scores for full model
+    baseline_r2 : list[float]
+        R2 scores for baseline
+    baseline_mae : list[float]
+        MAE scores for baseline
+    """
+    print("=" * 60)
+    print("MODEL COMPARISON")
+    print("=" * 60)
+    print("Full Model (Genes + Sex):")
+    print(f"  R2 Score: {np.mean(full_r2):.3f} +/- {np.std(full_r2):.3f}")
+    print(f"  MAE: {np.mean(full_mae):.2f} +/- {np.std(full_mae):.2f} years")
+    print("\nBaseline Model (Sex Only):")
+    print(f"  R2 Score: {np.mean(baseline_r2):.3f} +/- {np.std(baseline_r2):.3f}")
+    print(f"  MAE: {np.mean(baseline_mae):.2f} +/- {np.std(baseline_mae):.2f} years")
+    print("\nImprovement:")
+    print(f"  Delta R2: {np.mean(full_r2) - np.mean(baseline_r2):.3f}")
+    print(f"  Delta MAE: {np.mean(baseline_mae) - np.mean(full_mae):.2f} years")
+    print("=" * 60)
+
+
+def run_predictive_modeling_pipeline(
+    counts_df: pd.DataFrame,
+    metadata: pd.DataFrame,
+    n_splits: int = 5,
+    figure_dir: Path | None = None,
+) -> dict:
+    """Run complete predictive modeling pipeline.
+
+    Parameters
+    ----------
+    counts_df : pd.DataFrame
+        Gene expression counts
+    metadata : pd.DataFrame
+        Metadata with age and sex
+    n_splits : int
+        Number of CV splits
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    dict
+        Results dictionary with scores
+    """
+    # Prepare features
+    X, y = prepare_features(counts_df, metadata)
+    X_baseline = prepare_baseline_features(metadata)
+
+    # Run full model
+    print("\n--- Full Model (Genes + Sex) ---")
+    r2_scores, mae_scores, predictions, actuals = run_cross_validation(X, y, n_splits)
+    print_cv_results(r2_scores, mae_scores, "Full Model")
+
+    # Plot predictions
+    plot_predictions(actuals, predictions, r2_scores, mae_scores, figure_dir)
+
+    # Run baseline model
+    print("\n--- Baseline Model (Sex Only) ---")
+    baseline_r2, baseline_mae, _, _ = run_cross_validation(X_baseline, y, n_splits)
+    print_cv_results(baseline_r2, baseline_mae, "Baseline")
+
+    # Compare models
+    compare_models(r2_scores, mae_scores, baseline_r2, baseline_mae)
+
+    return {
+        "full_r2": r2_scores,
+        "full_mae": mae_scores,
+        "baseline_r2": baseline_r2,
+        "baseline_mae": baseline_mae,
+        "predictions": predictions,
+        "actuals": actuals,
+    }
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/preprocessing.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/preprocessing.py
new file mode 100644
index 0000000..4ab383e
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/preprocessing.py
@@ -0,0 +1,210 @@
+"""Preprocessing module for scRNA-seq analysis workflow.
+
+Functions for normalization, log transformation, and feature selection.
+"""
+
+import re
+
+import anndata as ad
+import scanpy as sc
+
+
+def normalize_counts(adata: ad.AnnData, target_sum: float = 1e4) -> ad.AnnData:
+    """Normalize counts to target sum per cell.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with raw counts
+    target_sum : float
+        Target sum for normalization (default: 10,000)
+
+    Returns
+    -------
+    AnnData
+        Normalized AnnData object
+    """
+    sc.pp.normalize_total(adata, target_sum=target_sum)
+    return adata
+
+
+def log_transform(adata: ad.AnnData) -> ad.AnnData:
+    """Apply log1p transformation.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+
+    Returns
+    -------
+    AnnData
+        Log-transformed AnnData object
+    """
+    sc.pp.log1p(adata)
+    return adata
+
+
+def select_highly_variable_genes(
+    adata: ad.AnnData,
+    n_top_genes: int = 3000,
+    batch_key: str = "donor_id",
+    layer: str = "counts",
+    span: float = 0.8,
+) -> ad.AnnData:
+    """Select highly variable genes using seurat_v3 method.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+    n_top_genes : int
+        Number of top variable genes to select
+    batch_key : str
+        Column name for batch correction
+    layer : str
+        Layer containing raw counts
+    span : float
+        LOESS span parameter
+
+    Returns
+    -------
+    AnnData
+        AnnData with highly_variable annotation
+    """
+    sc.pp.highly_variable_genes(
+        adata,
+        n_top_genes=n_top_genes,
+        flavor="seurat_v3",
+        batch_key=batch_key,
+        span=span,
+        layer=layer,
+        subset=False,
+    )
+    return adata
+
+
+def identify_nuisance_genes(adata: ad.AnnData) -> list[str]:
+    """Identify nuisance genes to exclude from HVG list.
+
+    Identifies TCR/BCR variable regions, mitochondrial, and ribosomal genes.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+
+    Returns
+    -------
+    list[str]
+        List of gene names to block
+    """
+    # TCR/BCR genes (V(D)J recombination genes)
+    immune_receptor_genes = [
+        name for name in adata.var_names if re.match(r"^(IG[HKL]|TR[ABDG])[VDJC]", name)
+    ]
+
+    # Mitochondrial genes
+    mt_genes = adata.var_names[adata.var_names.str.startswith("MT-")]
+
+    # Ribosomal genes
+    rb_genes = adata.var_names[adata.var_names.str.startswith(("RPS", "RPL"))]
+
+    genes_to_block = list(immune_receptor_genes) + list(mt_genes) + list(rb_genes)
+    return genes_to_block
+
+
+def filter_nuisance_genes_from_hvg(adata: ad.AnnData) -> ad.AnnData:
+    """Remove nuisance genes from HVG list.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with highly_variable annotation
+
+    Returns
+    -------
+    AnnData
+        AnnData with filtered HVG list
+    """
+    genes_to_block = identify_nuisance_genes(adata)
+
+    # Count immune receptor genes separately for reporting
+    immune_receptor_genes = [
+        name for name in adata.var_names if re.match(r"^(IG[HKL]|TR[ABDG])[VDJC]", name)
+    ]
+
+    # Set blocked genes to not highly variable
+    adata.var.loc[adata.var_names.isin(genes_to_block), "highly_variable"] = False
+
+    print(f"Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.")
+    print(f"Final HVG count: {adata.var['highly_variable'].sum()}")
+
+    return adata
+
+
+def run_pca(
+    adata: ad.AnnData,
+    svd_solver: str = "arpack",
+    use_highly_variable: bool = True,
+) -> ad.AnnData:
+    """Run PCA on the data.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object
+    svd_solver : str
+        SVD solver to use
+    use_highly_variable : bool
+        Whether to use only HVGs
+
+    Returns
+    -------
+    AnnData
+        AnnData with PCA results
+    """
+    sc.tl.pca(adata, svd_solver=svd_solver, use_highly_variable=use_highly_variable)
+    return adata
+
+
+def run_preprocessing_pipeline(
+    adata: ad.AnnData,
+    target_sum: float = 1e4,
+    n_top_genes: int = 3000,
+    batch_key: str = "donor_id",
+) -> ad.AnnData:
+    """Run complete preprocessing pipeline.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Input AnnData object with raw counts in 'counts' layer
+    target_sum : float
+        Target sum for normalization
+    n_top_genes : int
+        Number of HVGs to select
+    batch_key : str
+        Column for batch correction
+
+    Returns
+    -------
+    AnnData
+        Preprocessed AnnData object
+    """
+    # Normalize
+    adata = normalize_counts(adata, target_sum)
+
+    # Log transform
+    adata = log_transform(adata)
+
+    # Select HVGs
+    adata = select_highly_variable_genes(adata, n_top_genes, batch_key)
+
+    # Filter nuisance genes
+    adata = filter_nuisance_genes_from_hvg(adata)
+
+    # Run PCA
+    adata = run_pca(adata)
+
+    return adata
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py
new file mode 100644
index 0000000..3fd1a92
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py
@@ -0,0 +1,207 @@
+"""Pseudobulking module for scRNA-seq analysis workflow.
+
+Functions for aggregating single-cell counts to pseudobulk samples.
+"""
+
+from pathlib import Path
+
+import anndata as ad
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import scanpy as sc
+from sklearn.preprocessing import OneHotEncoder
+
+
+def create_pseudobulk(
+    adata: ad.AnnData,
+    group_col: str,
+    donor_col: str,
+    layer: str = "counts",
+    metadata_cols: list[str] | None = None,
+) -> ad.AnnData:
+    """Sum raw counts for each (Donor, CellType) pair.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Input single-cell data
+    group_col : str
+        Column name for grouping (e.g., 'cell_type')
+    donor_col : str
+        Column name for donor ID
+    layer : str
+        Layer to use for aggregation (default: 'counts')
+    metadata_cols : list of str, optional
+        Additional metadata columns to preserve from obs
+
+    Returns
+    -------
+    AnnData
+        Pseudobulk AnnData object
+    """
+    # Create a combined key (e.g., "Bcell::Donor1")
+    groups = adata.obs[group_col].astype(str)
+    donors = adata.obs[donor_col].astype(str)
+
+    group_df = pd.DataFrame({"group": groups, "donor": donors})
+    group_df["combined"] = group_df["group"] + "::" + group_df["donor"]
+
+    # Build the aggregation matrix (One-Hot Encoding)
+    enc = OneHotEncoder(sparse_output=True, dtype=np.float32)
+    membership_matrix = enc.fit_transform(group_df[["combined"]])
+
+    # Get source matrix
+    if layer is not None and layer in adata.layers:
+        X_source = adata.layers[layer]
+    else:
+        X_source = adata.X
+
+    # Aggregate by summing
+    pseudobulk_X = membership_matrix.T @ X_source
+
+    # Create obs metadata for the new object
+    unique_ids = enc.categories_[0]
+
+    obs_data = []
+    for uid in unique_ids:
+        ctype, donor = uid.split("::")
+        obs_data.append({"cell_type": ctype, "donor_id": donor})
+
+    pb_obs = pd.DataFrame(obs_data, index=unique_ids)
+
+    # Count cells per pseudobulk sample
+    cell_counts = np.array(membership_matrix.sum(axis=0)).flatten()
+    pb_obs["n_cells"] = cell_counts.astype(int)
+
+    # Add additional metadata columns
+    if metadata_cols is not None:
+        for col in metadata_cols:
+            if col in adata.obs.columns:
+                col_values = []
+                for uid in unique_ids:
+                    ctype, donor = uid.split("::")
+                    donor_mask = adata.obs[donor_col] == donor
+                    if donor_mask.any():
+                        col_values.append(adata.obs.loc[donor_mask, col].iloc[0])
+                    else:
+                        col_values.append(None)
+                pb_obs[col] = col_values
+
+    # Assemble the AnnData
+    pb_adata = ad.AnnData(X=pseudobulk_X, obs=pb_obs, var=adata.var.copy())
+
+    return pb_adata
+
+
+def filter_pseudobulk_by_cell_count(
+    pb_adata: ad.AnnData, min_cells: int = 10
+) -> ad.AnnData:
+    """Filter pseudobulk samples with too few cells.
+
+    Parameters
+    ----------
+    pb_adata : AnnData
+        Pseudobulk AnnData object
+    min_cells : int
+        Minimum cells required per sample
+
+    Returns
+    -------
+    AnnData
+        Filtered pseudobulk AnnData
+    """
+    print(f"Dropping samples with < {min_cells} cells...")
+    pb_adata = pb_adata[pb_adata.obs["n_cells"] >= min_cells].copy()
+    print(f"Remaining samples: {pb_adata.n_obs}")
+    return pb_adata
+
+
+def compute_pseudobulk_qc(pb_adata: ad.AnnData) -> ad.AnnData:
+    """Compute QC metrics for pseudobulk samples.
+
+    Parameters
+    ----------
+    pb_adata : AnnData
+        Pseudobulk AnnData object
+
+    Returns
+    -------
+    AnnData
+        Pseudobulk AnnData with QC metrics
+    """
+    pb_adata.obs["total_counts"] = np.array(pb_adata.X.sum(axis=1)).flatten()
+    return pb_adata
+
+
+def plot_pseudobulk_qc(pb_adata: ad.AnnData, figure_dir: Path | None = None) -> None:
+    """Plot QC metrics for pseudobulk samples.
+
+    Parameters
+    ----------
+    pb_adata : AnnData
+        Pseudobulk AnnData object
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    sc.pl.violin(pb_adata, ["n_cells", "total_counts"], multi_panel=True, show=False)
+    if figure_dir is not None:
+        plt.savefig(figure_dir / "pseudobulk_violin.png", dpi=300, bbox_inches="tight")
+    plt.close()
+
+
+def run_pseudobulk_pipeline(
+    adata: ad.AnnData,
+    group_col: str = "cell_type",
+    donor_col: str = "donor_id",
+    metadata_cols: list[str] | None = None,
+    min_cells: int = 10,
+    figure_dir: Path | None = None,
+) -> ad.AnnData:
+    """Run complete pseudobulking pipeline.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Input single-cell AnnData object
+    group_col : str
+        Column for cell type grouping
+    donor_col : str
+        Column for donor ID
+    metadata_cols : list of str, optional
+        Metadata columns to preserve
+    min_cells : int
+        Minimum cells per pseudobulk sample
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    AnnData
+        Pseudobulk AnnData object
+    """
+    if metadata_cols is None:
+        metadata_cols = ["development_stage", "sex"]
+
+    print("Aggregating counts...")
+    pb_adata = create_pseudobulk(
+        adata,
+        group_col=group_col,
+        donor_col=donor_col,
+        layer="counts",
+        metadata_cols=metadata_cols,
+    )
+
+    print("Pseudobulk complete.")
+    print(f"Original shape: {adata.shape}")
+    print(f"Pseudobulk shape: {pb_adata.shape} (Samples x Genes)")
+    print(pb_adata.obs.head())
+
+    # Filter by cell count
+    pb_adata = filter_pseudobulk_by_cell_count(pb_adata, min_cells)
+
+    # Compute and plot QC
+    pb_adata = compute_pseudobulk_qc(pb_adata)
+    plot_pseudobulk_qc(pb_adata, figure_dir)
+
+    return pb_adata
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
new file mode 100644
index 0000000..7115679
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
@@ -0,0 +1,322 @@
+"""Quality control module for scRNA-seq analysis workflow.
+
+Functions for identifying bad cells and doublets.
+"""
+
+from pathlib import Path
+
+import anndata as ad
+import matplotlib.pyplot as plt
+import scanpy as sc
+import seaborn as sns
+
+
+def annotate_gene_types(adata: ad.AnnData) -> ad.AnnData:
+    """Annotate mitochondrial, ribosomal, and hemoglobin genes.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with 'feature_name' in var
+
+    Returns
+    -------
+    AnnData
+        AnnData with mt, ribo, hb annotations in var
+    """
+    # Mitochondrial genes
+    adata.var["mt"] = adata.var["feature_name"].str.startswith("MT-")
+    print(f"Number of mitochondrial genes: {adata.var['mt'].sum()}")
+
+    # Ribosomal genes
+    adata.var["ribo"] = adata.var["feature_name"].str.startswith(("RPS", "RPL"))
+    print(f"Number of ribosomal genes: {adata.var['ribo'].sum()}")
+
+    # Hemoglobin genes
+    adata.var["hb"] = adata.var["feature_name"].str.contains("^HB[^(P)]")
+    print(f"Number of hemoglobin genes: {adata.var['hb'].sum()}")
+
+    return adata
+
+
+def calculate_qc_metrics(adata: ad.AnnData) -> ad.AnnData:
+    """Calculate QC metrics for cells.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with gene type annotations
+
+    Returns
+    -------
+    AnnData
+        AnnData with QC metrics in obs
+    """
+    sc.pp.calculate_qc_metrics(
+        adata,
+        qc_vars=["mt", "ribo", "hb"],
+        inplace=True,
+        percent_top=[20],
+        log1p=True,
+    )
+    return adata
+
+
+def plot_qc_metrics(adata: ad.AnnData, figure_dir: Path | None = None) -> None:
+    """Plot QC metric distributions.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with QC metrics
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    # Violin plots for QC metrics
+    sc.pl.violin(
+        adata,
+        ["total_counts", "n_genes_by_counts", "pct_counts_mt"],
+        jitter=0.4,
+        multi_panel=True,
+        show=False,
+    )
+    if figure_dir is not None:
+        plt.savefig(figure_dir / "qc_violin_plots.png", dpi=300, bbox_inches="tight")
+    plt.close()
+
+    # Scatter plot for doublets and dying cells
+    sc.pl.scatter(
+        adata,
+        x="total_counts",
+        y="n_genes_by_counts",
+        color="pct_counts_mt",
+        show=False,
+    )
+    if figure_dir is not None:
+        plt.savefig(
+            figure_dir / "qc_scatter_doublets.png", dpi=300, bbox_inches="tight"
+        )
+    plt.close()
+
+
+def plot_hemoglobin_distribution(
+    adata: ad.AnnData, figure_dir: Path | None = None
+) -> None:
+    """Plot hemoglobin content distribution to check RBC contamination.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with QC metrics
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    plt.figure(figsize=(6, 4))
+    sns.histplot(adata.obs["pct_counts_hb"], bins=50, log_scale=(False, True))
+    plt.title("Hemoglobin Content Distribution")
+    plt.xlabel("% Hemoglobin Counts")
+    plt.axvline(5, color="red", linestyle="--", label="5% Cutoff")
+    plt.legend()
+    if figure_dir is not None:
+        plt.savefig(
+            figure_dir / "hemoglobin_distribution.png", dpi=300, bbox_inches="tight"
+        )
+    plt.close()
+
+
+def apply_qc_filters(
+    adata: ad.AnnData,
+    min_genes: int = 200,
+    max_genes: int = 6000,
+    min_counts: int = 500,
+    max_counts: int = 30000,
+    max_hb_pct: float = 5.0,
+) -> ad.AnnData:
+    """Apply QC filters to remove low quality cells and doublets.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with QC metrics
+    min_genes : int
+        Minimum genes per cell
+    max_genes : int
+        Maximum genes per cell (doublet filter)
+    min_counts : int
+        Minimum UMIs per cell
+    max_counts : int
+        Maximum UMIs per cell (doublet filter)
+    max_hb_pct : float
+        Maximum hemoglobin percentage (RBC filter)
+
+    Returns
+    -------
+    AnnData
+        Filtered AnnData object
+    """
+    adata_qc = adata.copy()
+    print(f"Before filtering: {adata_qc.n_obs} cells")
+
+    # Filter low quality and doublets
+    adata_qc = adata_qc[
+        (adata_qc.obs["n_genes_by_counts"] > min_genes)
+        & (adata_qc.obs["n_genes_by_counts"] < max_genes)
+        & (adata_qc.obs["total_counts"] > min_counts)
+        & (adata_qc.obs["total_counts"] < max_counts)
+    ]
+
+    # Filter Red Blood Cells
+    adata_qc = adata_qc[adata_qc.obs["pct_counts_hb"] < max_hb_pct]
+
+    print(f"After filtering: {adata_qc.n_obs} cells")
+    return adata_qc
+
+
+def detect_doublets_per_donor(
+    adata: ad.AnnData,
+    expected_doublet_rate: float = 0.06,
+    min_cells_per_donor: int = 100,
+) -> ad.AnnData:
+    """Run doublet detection separately for each donor.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with raw counts
+    expected_doublet_rate : float
+        Expected doublet rate for Scrublet
+    min_cells_per_donor : int
+        Minimum cells required to run Scrublet
+
+    Returns
+    -------
+    AnnData
+        AnnData with doublet annotations
+    """
+    print(f"Data shape before doublet detection: {adata.shape}")
+
+    adatas_list = []
+    donors = adata.obs["donor_id"].unique()
+
+    print(f"Running Scrublet on {len(donors)} donors...")
+
+    for donor in donors:
+        curr_adata = adata[adata.obs["donor_id"] == donor].copy()
+
+        if curr_adata.n_obs < min_cells_per_donor:
+            print(f"Skipping donor {donor}: too few cells ({curr_adata.n_obs})")
+            curr_adata.obs["doublet_score"] = 0
+            curr_adata.obs["predicted_doublet"] = False
+            adatas_list.append(curr_adata)
+            continue
+
+        sc.pp.scrublet(curr_adata, expected_doublet_rate=expected_doublet_rate)
+        adatas_list.append(curr_adata)
+
+    adata_combined = sc.concat(adatas_list)
+
+    print(
+        f"Detected {adata_combined.obs['predicted_doublet'].sum()} "
+        f"doublets across all donors."
+    )
+    print(adata_combined.obs["predicted_doublet"].value_counts())
+
+    return adata_combined
+
+
+def plot_doublets(adata: ad.AnnData, figure_dir: Path | None = None) -> None:
+    """Visualize doublet detection results on UMAP.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with doublet annotations
+    figure_dir : Path, optional
+        Directory to save figures
+    """
+    sc.pl.umap(adata, color=["doublet_score", "predicted_doublet"], size=20, show=False)
+    if figure_dir is not None:
+        plt.savefig(
+            figure_dir / "doublet_detection_umap.png", dpi=300, bbox_inches="tight"
+        )
+    plt.close()
+
+
+def filter_doublets(adata: ad.AnnData) -> ad.AnnData:
+    """Remove predicted doublets from the dataset.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object with doublet predictions
+
+    Returns
+    -------
+    AnnData
+        Filtered AnnData with only singlets
+    """
+    print(f"Found {adata.obs['predicted_doublet'].sum()} predicted doublets")
+    adata_filtered = adata[adata.obs["predicted_doublet"] == False, :]  # noqa: E712
+    print(f"Remaining cells: {adata_filtered.n_obs}")
+    return adata_filtered
+
+
+def run_qc_pipeline(
+    adata: ad.AnnData,
+    min_genes: int = 200,
+    max_genes: int = 6000,
+    min_counts: int = 500,
+    max_counts: int = 30000,
+    max_hb_pct: float = 5.0,
+    expected_doublet_rate: float = 0.06,
+    figure_dir: Path | None = None,
+) -> ad.AnnData:
+    """Run complete quality control pipeline.
+
+    Parameters
+    ----------
+    adata : AnnData
+        Input AnnData object
+    min_genes : int
+        Minimum genes per cell
+    max_genes : int
+        Maximum genes per cell
+    min_counts : int
+        Minimum UMIs per cell
+    max_counts : int
+        Maximum UMIs per cell
+    max_hb_pct : float
+        Maximum hemoglobin percentage
+    expected_doublet_rate : float
+        Expected doublet rate
+    figure_dir : Path, optional
+        Directory to save figures
+
+    Returns
+    -------
+    AnnData
+        QC-filtered AnnData object
+    """
+    # Annotate gene types
+    adata = annotate_gene_types(adata)
+
+    # Calculate QC metrics
+    adata = calculate_qc_metrics(adata)
+
+    # Plot QC metrics
+    plot_qc_metrics(adata, figure_dir)
+    plot_hemoglobin_distribution(adata, figure_dir)
+
+    # Apply QC filters
+    adata = apply_qc_filters(
+        adata, min_genes, max_genes, min_counts, max_counts, max_hb_pct
+    )
+
+    # Detect and filter doublets
+    adata = detect_doublets_per_donor(adata, expected_doublet_rate)
+    adata = filter_doublets(adata)
+
+    # Save raw counts for later use
+    adata.layers["counts"] = adata.X.copy()
+
+    return adata
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py
new file mode 100644
index 0000000..f88d965
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py
@@ -0,0 +1,314 @@
+"""Main workflow runner for scRNA-seq immune aging analysis.
+
+This script orchestrates the complete analysis workflow using the modular components.
+"""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import (
+    run_clustering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import (
+    run_filtering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import (
+    download_data,
+    load_anndata,
+    load_lazy_anndata,
+    save_anndata,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import (
+    run_differential_expression_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import (
+    run_dimensionality_reduction_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import (
+    run_overrepresentation_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import (
+    run_gsea_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import (
+    run_predictive_modeling_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import (
+    run_preprocessing_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import (
+    run_pseudobulk_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import (
+    run_qc_pipeline,
+)
+
+
+def run_full_workflow(
+    datadir: Path,
+    dataset_name: str = "OneK1K",
+    url: str = "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad",
+    cell_type_for_de: str = "central memory CD4-positive, alpha-beta T cell",
+    skip_download: bool = False,
+    skip_filtering: bool = False,
+    skip_qc: bool = False,
+) -> dict:
+    """Run the complete immune aging scRNA-seq analysis workflow.
+
+    Parameters
+    ----------
+    datadir : Path
+        Base directory for data files
+    dataset_name : str
+        Name of the dataset
+    url : str
+        URL to download data from
+    cell_type_for_de : str
+        Cell type to use for differential expression
+    skip_download : bool
+        Skip data download step
+    skip_filtering : bool
+        Skip filtering, load pre-filtered data
+    skip_qc : bool
+        Skip QC, load post-QC data
+
+    Returns
+    -------
+    dict
+        Dictionary containing all results
+    """
+    # Setup directories
+    figure_dir = datadir / "workflow/figures"
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    results = {}
+
+    # =====================================================================
+    # STEP 1: Data Loading
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 1: DATA LOADING")
+    print("=" * 60)
+
+    datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad"
+    filtered_file = datadir / f"dataset-{dataset_name}_subset-immune_filtered.h5ad"
+
+    if not skip_download:
+        download_data(datafile, url)
+
+    # =====================================================================
+    # STEP 2: Data Filtering
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 2: DATA FILTERING")
+    print("=" * 60)
+
+    if skip_filtering and filtered_file.exists():
+        print("Loading pre-filtered data...")
+        adata = load_anndata(filtered_file)
+    else:
+        adata = load_lazy_anndata(datafile)
+        print(f"Loaded dataset: {adata}")
+
+        adata = run_filtering_pipeline(
+            adata,
+            cutoff_percentile=1.0,
+            min_cells_per_celltype=10,
+            percent_donors=0.95,
+            figure_dir=figure_dir,
+        )
+
+        # Save filtered data
+        save_anndata(adata, filtered_file)
+        print(f"Saved filtered data to {filtered_file}")
+
+    print(f"Dataset after filtering: {adata}")
+
+    # Build var_to_feature mapping
+    var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"]))
+
+    # =====================================================================
+    # STEP 3: Quality Control
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 3: QUALITY CONTROL")
+    print("=" * 60)
+
+    qc_file = datadir / f"dataset-{dataset_name}_subset-immune_qc.h5ad"
+
+    if skip_qc and qc_file.exists():
+        print("Loading post-QC data...")
+        adata = load_anndata(qc_file)
+    else:
+        adata = run_qc_pipeline(
+            adata,
+            min_genes=200,
+            max_genes=6000,
+            min_counts=500,
+            max_counts=30000,
+            max_hb_pct=5.0,
+            expected_doublet_rate=0.06,
+            figure_dir=figure_dir,
+        )
+        save_anndata(adata, qc_file)
+
+    print(f"Dataset after QC: {adata}")
+
+    # =====================================================================
+    # STEP 4: Preprocessing
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 4: PREPROCESSING")
+    print("=" * 60)
+
+    adata = run_preprocessing_pipeline(
+        adata,
+        target_sum=1e4,
+        n_top_genes=3000,
+        batch_key="donor_id",
+    )
+
+    # =====================================================================
+    # STEP 5: Dimensionality Reduction
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 5: DIMENSIONALITY REDUCTION")
+    print("=" * 60)
+
+    adata = run_dimensionality_reduction_pipeline(
+        adata,
+        batch_key="donor_id",
+        n_neighbors=30,
+        n_pcs=40,
+        figure_dir=figure_dir,
+    )
+
+    # =====================================================================
+    # STEP 6: Clustering
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 6: CLUSTERING")
+    print("=" * 60)
+
+    adata = run_clustering_pipeline(
+        adata,
+        resolution=1.0,
+        figure_dir=figure_dir,
+    )
+
+    results["adata"] = adata
+
+    # =====================================================================
+    # STEP 7: Pseudobulking
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 7: PSEUDOBULKING")
+    print("=" * 60)
+
+    pb_adata = run_pseudobulk_pipeline(
+        adata,
+        group_col="cell_type",
+        donor_col="donor_id",
+        metadata_cols=["development_stage", "sex"],
+        min_cells=10,
+        figure_dir=figure_dir,
+    )
+
+    results["pb_adata"] = pb_adata
+
+    # =====================================================================
+    # STEP 8: Differential Expression
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 8: DIFFERENTIAL EXPRESSION")
+    print("=" * 60)
+
+    stat_res, de_results, counts_df_ct = run_differential_expression_pipeline(
+        pb_adata,
+        cell_type=cell_type_for_de,
+        design_factors=["age_scaled", "sex"],
+        var_to_feature=var_to_feature,
+        n_cpus=8,
+    )
+
+    results["de_results"] = de_results
+    results["counts_df"] = counts_df_ct
+
+    # =====================================================================
+    # STEP 9: Pathway Analysis (GSEA)
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 9: PATHWAY ANALYSIS (GSEA)")
+    print("=" * 60)
+
+    gsea_results = run_gsea_pipeline(
+        de_results,
+        gene_sets=["MSigDB_Hallmark_2020"],
+        n_top=10,
+        figure_dir=figure_dir,
+    )
+
+    results["gsea"] = gsea_results
+
+    # =====================================================================
+    # STEP 10: Overrepresentation Analysis (Enrichr)
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 10: OVERREPRESENTATION ANALYSIS (Enrichr)")
+    print("=" * 60)
+
+    enr_up, enr_down = run_overrepresentation_pipeline(
+        de_results,
+        gene_sets=["MSigDB_Hallmark_2020"],
+        padj_threshold=0.05,
+        n_top=10,
+        figure_dir=figure_dir,
+    )
+
+    results["enrichr_up"] = enr_up
+    results["enrichr_down"] = enr_down
+
+    # =====================================================================
+    # STEP 11: Predictive Modeling
+    # =====================================================================
+    print("\n" + "=" * 60)
+    print("STEP 11: PREDICTIVE MODELING")
+    print("=" * 60)
+
+    # Get metadata for the cell type
+    pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type_for_de].copy()
+    pb_adata_ct.obs["age"] = (
+        pb_adata_ct.obs["development_stage"]
+        .str.extract(r"(\d+)-year-old")[0]
+        .astype(float)
+    )
+    metadata_ct = pb_adata_ct.obs.copy()
+
+    prediction_results = run_predictive_modeling_pipeline(
+        counts_df_ct,
+        metadata_ct,
+        n_splits=5,
+        figure_dir=figure_dir,
+    )
+
+    results["prediction"] = prediction_results
+
+    print("\n" + "=" * 60)
+    print("WORKFLOW COMPLETE")
+    print("=" * 60)
+    print(f"Figures saved to: {figure_dir}")
+
+    return results
+
+
+if __name__ == "__main__":
+    load_dotenv()
+
+    datadir_env = os.getenv("DATADIR")
+    if datadir_env is None:
+        raise ValueError("DATADIR environment variable not set")
+
+    datadir = Path(datadir_env) / "immune_aging"
+    results = run_full_workflow(datadir)

From 9b1daeb41a7be9f3fa9a428a1bfa43ce352aedcd Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 11:13:50 -0800
Subject: [PATCH 36/87] cleanup

---
 .../refactor_monolithic_to_modular.md                             | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename refactor_monolithic_to_modular.md => prompts/refactor_monolithic_to_modular.md (100%)

diff --git a/refactor_monolithic_to_modular.md b/prompts/refactor_monolithic_to_modular.md
similarity index 100%
rename from refactor_monolithic_to_modular.md
rename to prompts/refactor_monolithic_to_modular.md

From 5ad1df94ec559628594e1f8a74442750568f13be Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 11:22:05 -0800
Subject: [PATCH 37/87] Add stateless workflow with checkpointing and execution
 logging
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implement a stateless execution pattern for the scRNA-seq workflow that:
- Saves checkpoint files after each step for resumption
- Automatically skips completed steps by loading from cache
- Logs execution details (timing, parameters, status) to JSON
- Supports forced re-execution from any step onwards

New files:
- checkpoint.py: Utilities for saving/loading checkpoints with auto-format detection
- execution_log.py: Structured logging with StepRecord and ExecutionLog dataclasses
- run_workflow.py: Workflow runner using checkpoint wrappers

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/stateless_workflow/__init__.py     |   0
 .../rnaseq/stateless_workflow/checkpoint.py   | 342 +++++++++
 .../stateless_workflow/execution_log.py       | 202 ++++++
 .../rnaseq/stateless_workflow/run_workflow.py | 650 ++++++++++++++++++
 4 files changed, 1194 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/stateless_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/stateless_workflow/execution_log.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py

diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
new file mode 100644
index 0000000..11d2eba
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
@@ -0,0 +1,342 @@
+"""Checkpoint utilities for stateless workflow execution.
+
+Provides functions to save and load intermediate results, enabling
+workflow resumption from any step.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import pickle
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import anndata as ad
+import pandas as pd
+
+if TYPE_CHECKING:
+    from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import (
+        ExecutionLog,
+    )
+
+
+def get_file_type(filepath: Path) -> str:
+    """Determine file type from extension.
+
+    Parameters
+    ----------
+    filepath : Path
+        Path to the file
+
+    Returns
+    -------
+    str
+        File type identifier: 'h5ad', 'parquet', or 'pickle'
+    """
+    suffix = filepath.suffix.lower()
+    if suffix == ".h5ad":
+        return "h5ad"
+    elif suffix == ".parquet":
+        return "parquet"
+    else:
+        return "pickle"
+
+
+def save_checkpoint(data: Any, filepath: Path) -> None:
+    """Save data to a checkpoint file.
+
+    Automatically selects serialization format based on file extension:
+    - .h5ad: AnnData objects
+    - .parquet: pandas DataFrames
+    - .pkl: Any picklable object
+
+    Parameters
+    ----------
+    data : Any
+        Data to save
+    filepath : Path
+        Path to save the checkpoint
+    """
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+    file_type = get_file_type(filepath)
+
+    if file_type == "h5ad":
+        if not isinstance(data, ad.AnnData):
+            raise TypeError(f"Expected AnnData for .h5ad file, got {type(data)}")
+        data.write(filepath)
+    elif file_type == "parquet":
+        if not isinstance(data, pd.DataFrame):
+            raise TypeError(f"Expected DataFrame for .parquet file, got {type(data)}")
+        data.to_parquet(filepath)
+    else:
+        with open(filepath, "wb") as f:
+            pickle.dump(data, f)
+
+
+def load_checkpoint(filepath: Path) -> Any:
+    """Load data from a checkpoint file.
+
+    Automatically selects deserialization format based on file extension.
+
+    Parameters
+    ----------
+    filepath : Path
+        Path to the checkpoint file
+
+    Returns
+    -------
+    Any
+        Loaded data
+    """
+    file_type = get_file_type(filepath)
+
+    if file_type == "h5ad":
+        return ad.read_h5ad(filepath)
+    elif file_type == "parquet":
+        return pd.read_parquet(filepath)
+    else:
+        with open(filepath, "rb") as f:
+            return pickle.load(f)
+
+
+def hash_parameters(**kwargs) -> str:
+    """Create a hash of parameters for cache invalidation.
+
+    Parameters
+    ----------
+    **kwargs
+        Parameters to hash
+
+    Returns
+    -------
+    str
+        8-character hash string
+    """
+    param_str = json.dumps(kwargs, sort_keys=True, default=str)
+    return hashlib.md5(param_str.encode()).hexdigest()[:8]
+
+
+def run_with_checkpoint(
+    step_name: str,
+    checkpoint_file: Path,
+    func: Callable,
+    *args,
+    force: bool = False,
+    execution_log: ExecutionLog | None = None,
+    step_number: int | None = None,
+    log_parameters: dict[str, Any] | None = None,
+    **kwargs,
+) -> Any:
+    """Execute a function with checkpoint caching.
+
+    If the checkpoint file exists and force=False, loads and returns
+    the cached result. Otherwise, executes the function, saves the
+    result, and returns it.
+
+    Parameters
+    ----------
+    step_name : str
+        Human-readable name for logging
+    checkpoint_file : Path
+        Path to save/load the checkpoint
+    func : Callable
+        Function to execute
+    *args
+        Positional arguments for func
+    force : bool
+        If True, ignore existing checkpoint and re-run
+    execution_log : ExecutionLog, optional
+        Execution log to record step details
+    step_number : int, optional
+        Step number for logging
+    log_parameters : dict, optional
+        Parameters to record in the execution log
+    **kwargs
+        Keyword arguments for func
+
+    Returns
+    -------
+    Any
+        Result of func(*args, **kwargs) or cached result
+    """
+    # Start logging if provided
+    step_record = None
+    if execution_log is not None and step_number is not None:
+        step_record = execution_log.add_step(
+            step_number=step_number,
+            step_name=step_name,
+            parameters=log_parameters,
+            checkpoint_file=str(checkpoint_file),
+        )
+
+    from_cache = False
+    error_message = None
+
+    try:
+        if checkpoint_file.exists() and not force:
+            print(f"[{step_name}] Loading from checkpoint: {checkpoint_file.name}")
+            from_cache = True
+            result = load_checkpoint(checkpoint_file)
+        else:
+            print(f"[{step_name}] Executing...")
+            result = func(*args, **kwargs)
+
+            print(f"[{step_name}] Saving checkpoint: {checkpoint_file.name}")
+            save_checkpoint(result, checkpoint_file)
+
+        return result
+
+    except Exception as e:
+        error_message = str(e)
+        raise
+
+    finally:
+        if step_record is not None:
+            execution_log.complete_step(
+                step_record, from_cache=from_cache, error_message=error_message
+            )
+
+
+def run_with_checkpoint_multi(
+    step_name: str,
+    checkpoint_files: dict[str, Path],
+    func: Callable,
+    *args,
+    force: bool = False,
+    execution_log: ExecutionLog | None = None,
+    step_number: int | None = None,
+    log_parameters: dict[str, Any] | None = None,
+    **kwargs,
+) -> dict[str, Any]:
+    """Execute a function that returns multiple outputs with checkpoint caching.
+
+    The function must return a dict with keys matching checkpoint_files.
+
+    Parameters
+    ----------
+    step_name : str
+        Human-readable name for logging
+    checkpoint_files : dict[str, Path]
+        Mapping of output names to checkpoint file paths
+    func : Callable
+        Function to execute (must return dict)
+    *args
+        Positional arguments for func
+    force : bool
+        If True, ignore existing checkpoints and re-run
+    execution_log : ExecutionLog, optional
+        Execution log to record step details
+    step_number : int, optional
+        Step number for logging
+    log_parameters : dict, optional
+        Parameters to record in the execution log
+    **kwargs
+        Keyword arguments for func
+
+    Returns
+    -------
+    dict[str, Any]
+        Dict of results keyed by output names
+    """
+    # Start logging if provided
+    step_record = None
+    if execution_log is not None and step_number is not None:
+        checkpoint_files_str = {k: str(v) for k, v in checkpoint_files.items()}
+        step_record = execution_log.add_step(
+            step_number=step_number,
+            step_name=step_name,
+            parameters=log_parameters,
+            checkpoint_file=str(checkpoint_files_str),
+        )
+
+    from_cache = False
+    error_message = None
+
+    try:
+        all_exist = all(fp.exists() for fp in checkpoint_files.values())
+
+        if all_exist and not force:
+            print(f"[{step_name}] Loading from checkpoints...")
+            from_cache = True
+            return {key: load_checkpoint(fp) for key, fp in checkpoint_files.items()}
+
+        print(f"[{step_name}] Executing...")
+        results = func(*args, **kwargs)
+
+        if not isinstance(results, dict):
+            raise TypeError(
+                f"Function must return dict for multi-checkpoint, got {type(results)}"
+            )
+
+        print(f"[{step_name}] Saving checkpoints...")
+        for key, filepath in checkpoint_files.items():
+            if key not in results:
+                raise KeyError(f"Function result missing key: {key}")
+            save_checkpoint(results[key], filepath)
+
+        return results
+
+    except Exception as e:
+        error_message = str(e)
+        raise
+
+    finally:
+        if step_record is not None:
+            execution_log.complete_step(
+                step_record, from_cache=from_cache, error_message=error_message
+            )
+
+
+def clear_checkpoints(checkpoint_dir: Path, pattern: str = "step*.") -> list[Path]:
+    """Remove checkpoint files matching a pattern.
+
+    Parameters
+    ----------
+    checkpoint_dir : Path
+        Directory containing checkpoints
+    pattern : str
+        Glob pattern for files to remove
+
+    Returns
+    -------
+    list[Path]
+        List of removed files
+    """
+    removed = []
+    for filepath in checkpoint_dir.glob(pattern + "*"):
+        filepath.unlink()
+        removed.append(filepath)
+        print(f"Removed: {filepath.name}")
+    return removed
+
+
+def clear_checkpoints_from_step(checkpoint_dir: Path, from_step: int) -> list[Path]:
+    """Remove checkpoints from a specific step onwards.
+
+    Useful for invalidating downstream results when re-running an upstream step.
+
+    Parameters
+    ----------
+    checkpoint_dir : Path
+        Directory containing checkpoints
+    from_step : int
+        Step number to start clearing from (inclusive)
+
+    Returns
+    -------
+    list[Path]
+        List of removed files
+    """
+    removed = []
+    for filepath in checkpoint_dir.glob("step*"):
+        try:
+            step_num = int(filepath.name.split("_")[0].replace("step", ""))
+            if step_num >= from_step:
+                filepath.unlink()
+                removed.append(filepath)
+                print(f"Removed: {filepath.name}")
+        except (ValueError, IndexError):
+            continue
+    return removed
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/execution_log.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/execution_log.py
new file mode 100644
index 0000000..b496d96
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/execution_log.py
@@ -0,0 +1,202 @@
+"""Execution logging for stateless workflow.
+
+Tracks execution details including timing, parameters, and status for each step.
+"""
+
+import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class StepRecord:
+    """Record of a single workflow step execution."""
+
+    step_number: int
+    step_name: str
+    start_time: str
+    end_time: str | None = None
+    duration_seconds: float | None = None
+    parameters: dict[str, Any] = field(default_factory=dict)
+    from_cache: bool = False
+    status: str = "running"
+    checkpoint_file: str | None = None
+    error_message: str | None = None
+
+
+@dataclass
+class ExecutionLog:
+    """Complete execution log for a workflow run."""
+
+    workflow_name: str
+    run_id: str
+    start_time: str
+    end_time: str | None = None
+    total_duration_seconds: float | None = None
+    status: str = "running"
+    steps: list[StepRecord] = field(default_factory=list)
+    workflow_parameters: dict[str, Any] = field(default_factory=dict)
+
+    def add_step(
+        self,
+        step_number: int,
+        step_name: str,
+        parameters: dict[str, Any] | None = None,
+        checkpoint_file: str | None = None,
+    ) -> StepRecord:
+        """Add a new step record and return it."""
+        record = StepRecord(
+            step_number=step_number,
+            step_name=step_name,
+            start_time=datetime.now().isoformat(),
+            parameters=parameters or {},
+            checkpoint_file=checkpoint_file,
+        )
+        self.steps.append(record)
+        return record
+
+    def complete_step(
+        self,
+        record: StepRecord,
+        from_cache: bool = False,
+        error_message: str | None = None,
+    ) -> None:
+        """Mark a step as completed."""
+        record.end_time = datetime.now().isoformat()
+        start = datetime.fromisoformat(record.start_time)
+        end = datetime.fromisoformat(record.end_time)
+        record.duration_seconds = (end - start).total_seconds()
+        record.from_cache = from_cache
+        record.status = "completed" if error_message is None else "failed"
+        record.error_message = error_message
+
+    def complete(self, error_message: str | None = None) -> None:
+        """Mark the entire workflow as completed."""
+        self.end_time = datetime.now().isoformat()
+        start = datetime.fromisoformat(self.start_time)
+        end = datetime.fromisoformat(self.end_time)
+        self.total_duration_seconds = (end - start).total_seconds()
+        self.status = "completed" if error_message is None else "failed"
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "workflow_name": self.workflow_name,
+            "run_id": self.run_id,
+            "start_time": self.start_time,
+            "end_time": self.end_time,
+            "total_duration_seconds": self.total_duration_seconds,
+            "status": self.status,
+            "workflow_parameters": self.workflow_parameters,
+            "steps": [asdict(step) for step in self.steps],
+        }
+
+    def save(self, log_dir: Path) -> Path:
+        """Save execution log to a date-stamped JSON file.
+
+        Parameters
+        ----------
+        log_dir : Path
+            Directory to save the log file
+
+        Returns
+        -------
+        Path
+            Path to the saved log file
+        """
+        log_dir.mkdir(parents=True, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        log_file = log_dir / f"execution_log_{timestamp}.json"
+
+        with open(log_file, "w") as f:
+            json.dump(self.to_dict(), f, indent=2, default=str)
+
+        return log_file
+
+    def print_summary(self) -> None:
+        """Print a summary of the execution."""
+        print("\n" + "=" * 60)
+        print("EXECUTION SUMMARY")
+        print("=" * 60)
+        print(f"Workflow: {self.workflow_name}")
+        print(f"Run ID: {self.run_id}")
+        print(f"Status: {self.status}")
+        if self.total_duration_seconds is not None:
+            print(f"Total Duration: {self.total_duration_seconds:.1f} seconds")
+
+        print("\nStep Details:")
+        print("-" * 60)
+        for step in self.steps:
+            cache_indicator = " [cached]" if step.from_cache else ""
+            duration = (
+                f"{step.duration_seconds:.1f}s"
+                if step.duration_seconds is not None
+                else "N/A"
+            )
+            status_icon = "✓" if step.status == "completed" else "✗"
+            print(
+                f"  {status_icon} Step {step.step_number}: {step.step_name:<25} "
+                f"{duration:>8}{cache_indicator}"
+            )
+        print("-" * 60)
+
+
+def create_execution_log(
+    workflow_name: str,
+    workflow_parameters: dict[str, Any] | None = None,
+) -> ExecutionLog:
+    """Create a new execution log.
+
+    Parameters
+    ----------
+    workflow_name : str
+        Name of the workflow
+    workflow_parameters : dict, optional
+        Parameters passed to the workflow
+
+    Returns
+    -------
+    ExecutionLog
+        New execution log instance
+    """
+    run_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return ExecutionLog(
+        workflow_name=workflow_name,
+        run_id=run_id,
+        start_time=datetime.now().isoformat(),
+        workflow_parameters=workflow_parameters or {},
+    )
+
+
+def serialize_parameters(**kwargs) -> dict[str, Any]:
+    """Convert parameters to JSON-serializable format.
+
+    Handles common non-serializable types like Path objects.
+
+    Parameters
+    ----------
+    **kwargs
+        Parameters to serialize
+
+    Returns
+    -------
+    dict
+        Serialized parameters
+    """
+    result = {}
+    for key, value in kwargs.items():
+        if isinstance(value, Path):
+            result[key] = str(value)
+        elif hasattr(value, "tolist"):  # numpy arrays
+            result[key] = value.tolist()
+        elif hasattr(value, "__dict__"):  # objects
+            result[key] = str(type(value).__name__)
+        else:
+            try:
+                json.dumps(value)
+                result[key] = value
+            except (TypeError, ValueError):
+                result[key] = str(value)
+    return result
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
new file mode 100644
index 0000000..76d4072
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
@@ -0,0 +1,650 @@
+"""Stateless workflow runner for scRNA-seq immune aging analysis.
+
+This script orchestrates the complete analysis workflow using checkpointing
+to enable stateless execution and resumption from any step.
+"""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import (
+    run_clustering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import (
+    run_filtering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import (
+    download_data,
+    load_lazy_anndata,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import (
+    run_differential_expression_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import (
+    run_dimensionality_reduction_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import (
+    run_overrepresentation_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import (
+    run_gsea_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import (
+    run_predictive_modeling_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import (
+    run_preprocessing_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import (
+    run_pseudobulk_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import (
+    run_qc_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    clear_checkpoints_from_step,
+    run_with_checkpoint,
+    run_with_checkpoint_multi,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import (
+    ExecutionLog,
+    create_execution_log,
+    serialize_parameters,
+)
+
+
+def _run_differential_expression_as_dict(
+    pb_adata,
+    cell_type,
+    design_factors,
+    var_to_feature,
+    n_cpus,
+):
+    """Wrapper to return DE results as dict for checkpointing."""
+    stat_res, de_results, counts_df = run_differential_expression_pipeline(
+        pb_adata,
+        cell_type=cell_type,
+        design_factors=design_factors,
+        var_to_feature=var_to_feature,
+        n_cpus=n_cpus,
+    )
+    return {
+        "stat_res": stat_res,
+        "de_results": de_results,
+        "counts_df": counts_df,
+    }
+
+
+def _run_overrepresentation_as_dict(
+    de_results,
+    gene_sets,
+    padj_threshold,
+    n_top,
+    figure_dir,
+):
+    """Wrapper to return enrichment results as dict for checkpointing."""
+    enr_up, enr_down = run_overrepresentation_pipeline(
+        de_results,
+        gene_sets=gene_sets,
+        padj_threshold=padj_threshold,
+        n_top=n_top,
+        figure_dir=figure_dir,
+    )
+    return {
+        "enr_up": enr_up,
+        "enr_down": enr_down,
+    }
+
+
+def run_stateless_workflow(
+    datadir: Path,
+    dataset_name: str = "OneK1K",
+    url: str = "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad",
+    cell_type_for_de: str = "central memory CD4-positive, alpha-beta T cell",
+    force_from_step: int | None = None,
+) -> dict:
+    """Run the complete immune aging scRNA-seq analysis workflow with checkpointing.
+
+    Each step saves its output to a checkpoint file. On subsequent runs,
+    completed steps are skipped by loading from checkpoints.
+
+    Parameters
+    ----------
+    datadir : Path
+        Base directory for data files
+    dataset_name : str
+        Name of the dataset
+    url : str
+        URL to download data from
+    cell_type_for_de : str
+        Cell type to use for differential expression
+    force_from_step : int, optional
+        If provided, clears checkpoints from this step onwards and re-runs
+
+    Returns
+    -------
+    dict
+        Dictionary containing all results
+    """
+    # Setup directories
+    figure_dir = datadir / "workflow/figures"
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    checkpoint_dir = datadir / "workflow/checkpoints"
+    checkpoint_dir.mkdir(parents=True, exist_ok=True)
+
+    log_dir = datadir / "workflow/logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    # Clear downstream checkpoints if forcing re-run
+    if force_from_step is not None:
+        print(f"\nClearing checkpoints from step {force_from_step} onwards...")
+        clear_checkpoints_from_step(checkpoint_dir, force_from_step)
+
+    # Initialize execution log
+    execution_log = create_execution_log(
+        workflow_name="immune_aging_scrnaseq",
+        workflow_parameters=serialize_parameters(
+            datadir=datadir,
+            dataset_name=dataset_name,
+            url=url,
+            cell_type_for_de=cell_type_for_de,
+            force_from_step=force_from_step,
+        ),
+    )
+
+    results = {}
+    error_occurred = None
+
+    try:
+        # =====================================================================
+        # STEP 1: Data Download
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 1: DATA DOWNLOAD")
+        print("=" * 60)
+
+        datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad"
+
+        # Log step 1 manually (no checkpoint wrapper for download)
+        step1_record = execution_log.add_step(
+            step_number=1,
+            step_name="data_download",
+            parameters=serialize_parameters(datafile=datafile, url=url),
+        )
+        download_data(datafile, url)
+        execution_log.complete_step(
+            step1_record, from_cache=datafile.exists(), error_message=None
+        )
+
+        # =====================================================================
+        # STEP 2: Data Filtering
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 2: DATA FILTERING")
+        print("=" * 60)
+
+        step2_params = {
+            "cutoff_percentile": 1.0,
+            "min_cells_per_celltype": 10,
+            "percent_donors": 0.95,
+        }
+
+        def _load_and_filter():
+            adata = load_lazy_anndata(datafile)
+            print(f"Loaded dataset: {adata}")
+            return run_filtering_pipeline(
+                adata,
+                cutoff_percentile=step2_params["cutoff_percentile"],
+                min_cells_per_celltype=step2_params["min_cells_per_celltype"],
+                percent_donors=step2_params["percent_donors"],
+                figure_dir=figure_dir,
+            )
+
+        adata = run_with_checkpoint(
+            "filtering",
+            checkpoint_dir / "step02_filtered.h5ad",
+            _load_and_filter,
+            execution_log=execution_log,
+            step_number=2,
+            log_parameters=step2_params,
+        )
+        print(f"Dataset after filtering: {adata}")
+
+        # Build var_to_feature mapping
+        var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"]))
+
+        # =====================================================================
+        # STEP 3: Quality Control
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 3: QUALITY CONTROL")
+        print("=" * 60)
+
+        step3_params = {
+            "min_genes": 200,
+            "max_genes": 6000,
+            "min_counts": 500,
+            "max_counts": 30000,
+            "max_hb_pct": 5.0,
+            "expected_doublet_rate": 0.06,
+        }
+
+        adata = run_with_checkpoint(
+            "quality_control",
+            checkpoint_dir / "step03_qc.h5ad",
+            run_qc_pipeline,
+            adata,
+            min_genes=step3_params["min_genes"],
+            max_genes=step3_params["max_genes"],
+            min_counts=step3_params["min_counts"],
+            max_counts=step3_params["max_counts"],
+            max_hb_pct=step3_params["max_hb_pct"],
+            expected_doublet_rate=step3_params["expected_doublet_rate"],
+            figure_dir=figure_dir,
+            execution_log=execution_log,
+            step_number=3,
+            log_parameters=step3_params,
+        )
+        print(f"Dataset after QC: {adata}")
+
+        # =====================================================================
+        # STEP 4: Preprocessing
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 4: PREPROCESSING")
+        print("=" * 60)
+
+        step4_params = {
+            "target_sum": 1e4,
+            "n_top_genes": 3000,
+            "batch_key": "donor_id",
+        }
+
+        adata = run_with_checkpoint(
+            "preprocessing",
+            checkpoint_dir / "step04_preprocessed.h5ad",
+            run_preprocessing_pipeline,
+            adata,
+            target_sum=step4_params["target_sum"],
+            n_top_genes=step4_params["n_top_genes"],
+            batch_key=step4_params["batch_key"],
+            execution_log=execution_log,
+            step_number=4,
+            log_parameters=step4_params,
+        )
+
+        # =====================================================================
+        # STEP 5: Dimensionality Reduction
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 5: DIMENSIONALITY REDUCTION")
+        print("=" * 60)
+
+        step5_params = {
+            "batch_key": "donor_id",
+            "n_neighbors": 30,
+            "n_pcs": 40,
+        }
+
+        adata = run_with_checkpoint(
+            "dimensionality_reduction",
+            checkpoint_dir / "step05_dimreduced.h5ad",
+            run_dimensionality_reduction_pipeline,
+            adata,
+            batch_key=step5_params["batch_key"],
+            n_neighbors=step5_params["n_neighbors"],
+            n_pcs=step5_params["n_pcs"],
+            figure_dir=figure_dir,
+            execution_log=execution_log,
+            step_number=5,
+            log_parameters=step5_params,
+        )
+
+        # =====================================================================
+        # STEP 6: Clustering
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 6: CLUSTERING")
+        print("=" * 60)
+
+        step6_params = {"resolution": 1.0}
+
+        adata = run_with_checkpoint(
+            "clustering",
+            checkpoint_dir / "step06_clustered.h5ad",
+            run_clustering_pipeline,
+            adata,
+            resolution=step6_params["resolution"],
+            figure_dir=figure_dir,
+            execution_log=execution_log,
+            step_number=6,
+            log_parameters=step6_params,
+        )
+
+        results["adata"] = adata
+
+        # =====================================================================
+        # STEP 7: Pseudobulking
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 7: PSEUDOBULKING")
+        print("=" * 60)
+
+        step7_params = {
+            "group_col": "cell_type",
+            "donor_col": "donor_id",
+            "metadata_cols": ["development_stage", "sex"],
+            "min_cells": 10,
+        }
+
+        pb_adata = run_with_checkpoint(
+            "pseudobulking",
+            checkpoint_dir / "step07_pseudobulk.h5ad",
+            run_pseudobulk_pipeline,
+            adata,
+            group_col=step7_params["group_col"],
+            donor_col=step7_params["donor_col"],
+            metadata_cols=step7_params["metadata_cols"],
+            min_cells=step7_params["min_cells"],
+            figure_dir=figure_dir,
+            execution_log=execution_log,
+            step_number=7,
+            log_parameters=step7_params,
+        )
+
+        results["pb_adata"] = pb_adata
+
+        # =====================================================================
+        # STEP 8: Differential Expression
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 8: DIFFERENTIAL EXPRESSION")
+        print("=" * 60)
+
+        step8_params = {
+            "cell_type": cell_type_for_de,
+            "design_factors": ["age_scaled", "sex"],
+            "n_cpus": 8,
+        }
+
+        de_outputs = run_with_checkpoint_multi(
+            "differential_expression",
+            {
+                "stat_res": checkpoint_dir / "step08_stat_res.pkl",
+                "de_results": checkpoint_dir / "step08_de_results.parquet",
+                "counts_df": checkpoint_dir / "step08_counts.parquet",
+            },
+            _run_differential_expression_as_dict,
+            pb_adata,
+            cell_type=step8_params["cell_type"],
+            design_factors=step8_params["design_factors"],
+            var_to_feature=var_to_feature,
+            n_cpus=step8_params["n_cpus"],
+            execution_log=execution_log,
+            step_number=8,
+            log_parameters=step8_params,
+        )
+
+        de_results = de_outputs["de_results"]
+        counts_df_ct = de_outputs["counts_df"]
+
+        results["stat_res"] = de_outputs["stat_res"]
+        results["de_results"] = de_results
+        results["counts_df"] = counts_df_ct
+
+        # =====================================================================
+        # STEP 9: Pathway Analysis (GSEA)
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 9: PATHWAY ANALYSIS (GSEA)")
+        print("=" * 60)
+
+        step9_params = {
+            "gene_sets": ["MSigDB_Hallmark_2020"],
+            "n_top": 10,
+        }
+
+        gsea_results = run_with_checkpoint(
+            "gsea",
+            checkpoint_dir / "step09_gsea.pkl",
+            run_gsea_pipeline,
+            de_results,
+            gene_sets=step9_params["gene_sets"],
+            n_top=step9_params["n_top"],
+            figure_dir=figure_dir,
+            execution_log=execution_log,
+            step_number=9,
+            log_parameters=step9_params,
+        )
+
+        results["gsea"] = gsea_results
+
+        # =====================================================================
+        # STEP 10: Overrepresentation Analysis (Enrichr)
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 10: OVERREPRESENTATION ANALYSIS (Enrichr)")
+        print("=" * 60)
+
+        step10_params = {
+            "gene_sets": ["MSigDB_Hallmark_2020"],
+            "padj_threshold": 0.05,
+            "n_top": 10,
+        }
+
+        enr_outputs = run_with_checkpoint_multi(
+            "overrepresentation",
+            {
+                "enr_up": checkpoint_dir / "step10_enr_up.pkl",
+                "enr_down": checkpoint_dir / "step10_enr_down.pkl",
+            },
+            _run_overrepresentation_as_dict,
+            de_results,
+            gene_sets=step10_params["gene_sets"],
+            padj_threshold=step10_params["padj_threshold"],
+            n_top=step10_params["n_top"],
+            figure_dir=figure_dir,
+            execution_log=execution_log,
+            step_number=10,
+            log_parameters=step10_params,
+        )
+
+        results["enrichr_up"] = enr_outputs["enr_up"]
+        results["enrichr_down"] = enr_outputs["enr_down"]
+
+        # =====================================================================
+        # STEP 11: Predictive Modeling
+        # =====================================================================
+        print("\n" + "=" * 60)
+        print("STEP 11: PREDICTIVE MODELING")
+        print("=" * 60)
+
+        # Get metadata for the cell type
+        pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type_for_de].copy()
+        pb_adata_ct.obs["age"] = (
+            pb_adata_ct.obs["development_stage"]
+            .str.extract(r"(\d+)-year-old")[0]
+            .astype(float)
+        )
+        metadata_ct = pb_adata_ct.obs.copy()
+
+        step11_params = {"n_splits": 5}
+
+        prediction_results = run_with_checkpoint(
+            "predictive_modeling",
+            checkpoint_dir / "step11_prediction.pkl",
+            run_predictive_modeling_pipeline,
+            counts_df_ct,
+            metadata_ct,
+            n_splits=step11_params["n_splits"],
+            figure_dir=figure_dir,
+            execution_log=execution_log,
+            step_number=11,
+            log_parameters=step11_params,
+        )
+
+        results["prediction"] = prediction_results
+
+    except Exception as e:
+        error_occurred = str(e)
+        raise
+
+    finally:
+        # Complete and save execution log
+        execution_log.complete(error_message=error_occurred)
+        log_file = execution_log.save(log_dir)
+        execution_log.print_summary()
+        print(f"\nExecution log saved to: {log_file}")
+
+    print("\n" + "=" * 60)
+    print("WORKFLOW COMPLETE")
+    print("=" * 60)
+    print(f"Figures saved to: {figure_dir}")
+    print(f"Checkpoints saved to: {checkpoint_dir}")
+
+    return results
+
+
+def list_checkpoints(datadir: Path) -> list[tuple[str, Path]]:
+    """List all checkpoint files in the workflow directory.
+
+    Parameters
+    ----------
+    datadir : Path
+        Base directory for data files
+
+    Returns
+    -------
+    list[tuple[str, Path]]
+        List of (step_name, file_path) tuples
+    """
+    checkpoint_dir = datadir / "workflow/checkpoints"
+    if not checkpoint_dir.exists():
+        return []
+
+    checkpoints = []
+    for filepath in sorted(checkpoint_dir.glob("step*")):
+        step_name = (
+            filepath.stem.split("_", 1)[1] if "_" in filepath.stem else filepath.stem
+        )
+        checkpoints.append((step_name, filepath))
+
+    return checkpoints
+
+
+def print_checkpoint_status(datadir: Path) -> None:
+    """Print the status of all workflow checkpoints.
+
+    Parameters
+    ----------
+    datadir : Path
+        Base directory for data files
+    """
+    checkpoints = list_checkpoints(datadir)
+
+    if not checkpoints:
+        print("No checkpoints found.")
+        return
+
+    print("\nCheckpoint Status:")
+    print("-" * 50)
+    for step_name, filepath in checkpoints:
+        size_mb = filepath.stat().st_size / (1024 * 1024)
+        print(f"  {step_name:<30} ({size_mb:.1f} MB)")
+    print("-" * 50)
+
+
+def list_execution_logs(datadir: Path) -> list[Path]:
+    """List all execution log files.
+
+    Parameters
+    ----------
+    datadir : Path
+        Base directory for data files
+
+    Returns
+    -------
+    list[Path]
+        List of log file paths, sorted by date (newest first)
+    """
+    log_dir = datadir / "workflow/logs"
+    if not log_dir.exists():
+        return []
+
+    return sorted(log_dir.glob("execution_log_*.json"), reverse=True)
+
+
+def load_execution_log(log_file: Path) -> ExecutionLog:
+    """Load an execution log from a JSON file.
+
+    Parameters
+    ----------
+    log_file : Path
+        Path to the log file
+
+    Returns
+    -------
+    ExecutionLog
+        Loaded execution log
+    """
+    import json
+
+    from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import (
+        StepRecord,
+    )
+
+    with open(log_file) as f:
+        data = json.load(f)
+
+    log = ExecutionLog(
+        workflow_name=data["workflow_name"],
+        run_id=data["run_id"],
+        start_time=data["start_time"],
+        end_time=data.get("end_time"),
+        total_duration_seconds=data.get("total_duration_seconds"),
+        status=data.get("status", "unknown"),
+        workflow_parameters=data.get("workflow_parameters", {}),
+    )
+
+    for step_data in data.get("steps", []):
+        step = StepRecord(
+            step_number=step_data["step_number"],
+            step_name=step_data["step_name"],
+            start_time=step_data["start_time"],
+            end_time=step_data.get("end_time"),
+            duration_seconds=step_data.get("duration_seconds"),
+            parameters=step_data.get("parameters", {}),
+            from_cache=step_data.get("from_cache", False),
+            status=step_data.get("status", "unknown"),
+            checkpoint_file=step_data.get("checkpoint_file"),
+            error_message=step_data.get("error_message"),
+        )
+        log.steps.append(step)
+
+    return log
+
+
+if __name__ == "__main__":
+    load_dotenv()
+
+    datadir_env = os.getenv("DATADIR")
+    if datadir_env is None:
+        raise ValueError("DATADIR environment variable not set")
+
+    datadir = Path(datadir_env) / "immune_aging"
+
+    # Print current checkpoint status
+    print_checkpoint_status(datadir)
+
+    # Show recent execution logs
+    logs = list_execution_logs(datadir)
+    if logs:
+        print(f"\nRecent execution logs: {len(logs)} found")
+        for log_path in logs[:3]:
+            print(f"  {log_path.name}")
+
+    # Run the workflow (will resume from last checkpoint)
+    results = run_stateless_workflow(datadir)

From e7d52c47281b109d886f8dff1e3d82e20d6383e4 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 11:36:58 -0800
Subject: [PATCH 38/87] Fix checkpoint logging to correctly handle interrupts
 during save
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The checkpoint wrapper was incorrectly marking steps as "completed" even
when saving was interrupted (e.g., by Ctrl+C). This happened because:

1. KeyboardInterrupt/SystemExit are BaseException, not Exception
2. The `except Exception` block didn't catch them
3. The finally block would mark the step as completed with no error

Now we:
- Track `save_succeeded` flag, only set True after save completes
- Catch BaseException to properly log all interruptions
- Only report success when checkpoint is actually persisted

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/stateless_workflow/checkpoint.py   | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
index 11d2eba..ebac03c 100644
--- a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
@@ -173,23 +173,28 @@ def run_with_checkpoint(
 
     from_cache = False
     error_message = None
+    save_succeeded = False
 
     try:
         if checkpoint_file.exists() and not force:
             print(f"[{step_name}] Loading from checkpoint: {checkpoint_file.name}")
             from_cache = True
             result = load_checkpoint(checkpoint_file)
+            save_succeeded = True  # Loading counts as success
         else:
             print(f"[{step_name}] Executing...")
             result = func(*args, **kwargs)
 
             print(f"[{step_name}] Saving checkpoint: {checkpoint_file.name}")
             save_checkpoint(result, checkpoint_file)
+            save_succeeded = True  # Only mark success after save completes
 
         return result
 
-    except Exception as e:
-        error_message = str(e)
+    except BaseException as e:
+        # Catch all exceptions including KeyboardInterrupt, SystemExit
+        if not save_succeeded:
+            error_message = f"{type(e).__name__}: {e}"
         raise
 
     finally:
@@ -253,6 +258,7 @@ def run_with_checkpoint_multi(
 
     from_cache = False
     error_message = None
+    save_succeeded = False
 
     try:
         all_exist = all(fp.exists() for fp in checkpoint_files.values())
@@ -260,7 +266,9 @@ def run_with_checkpoint_multi(
         if all_exist and not force:
             print(f"[{step_name}] Loading from checkpoints...")
             from_cache = True
-            return {key: load_checkpoint(fp) for key, fp in checkpoint_files.items()}
+            result = {key: load_checkpoint(fp) for key, fp in checkpoint_files.items()}
+            save_succeeded = True  # Loading counts as success
+            return result
 
         print(f"[{step_name}] Executing...")
         results = func(*args, **kwargs)
@@ -276,10 +284,13 @@ def run_with_checkpoint_multi(
                 raise KeyError(f"Function result missing key: {key}")
             save_checkpoint(results[key], filepath)
 
+        save_succeeded = True  # Only mark success after all saves complete
         return results
 
-    except Exception as e:
-        error_message = str(e)
+    except BaseException as e:
+        # Catch all exceptions including KeyboardInterrupt, SystemExit
+        if not save_succeeded:
+            error_message = f"{type(e).__name__}: {e}"
         raise
 
     finally:

From 8df37e526dee6d7f48f386ae8f906a3601a9369e Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 16:05:57 -0800
Subject: [PATCH 39/87] Optimize checkpoint storage and add selective
 checkpointing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add BIDS naming for checkpoint files (dataset-{name}_step-{num}_desc-{desc}.ext)
- Enable gzip compression for h5ad checkpoint files
- Remove redundant layers["counts"] storage by loading raw counts from step 3
  checkpoint during pseudobulking (step 7)
- Add checkpoint_steps parameter to control which steps save checkpoints
  (default: {2, 3, 5} for filtering, QC, and dimensionality reduction)
- Add skip_save parameter to run_with_checkpoint() functions
- Update pseudobulk pipeline to accept layer parameter

These changes reduce checkpoint storage by ~50% for steps 3-6 and allow
users to checkpoint only expensive steps.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          |  45 +++++++
 .../rnaseq/modular_workflow/pseudobulk.py     |   5 +-
 .../modular_workflow/quality_control.py       |   5 +-
 .../rnaseq/stateless_workflow/checkpoint.py   | 117 ++++++++++++++----
 .../rnaseq/stateless_workflow/run_workflow.py | 114 +++++++++++++----
 5 files changed, 237 insertions(+), 49 deletions(-)
 create mode 100644 problems_to_solve.md

diff --git a/problems_to_solve.md b/problems_to_solve.md
new file mode 100644
index 0000000..14c82c4
--- /dev/null
+++ b/problems_to_solve.md
@@ -0,0 +1,45 @@
+## Problems to be fixed
+
+Open problems marked with [ ]
+Fixed problems marked with [x]
+
+
+[x] Please change the file naming scheme for the checkpoint files to use a BIDS schema, just like the downloaded data.
+    - Implemented `bids_checkpoint_name()` and `parse_bids_checkpoint_name()` functions
+    - Checkpoint files now use format: `dataset-{name}_step-{number}_desc-{description}.{extension}`
+    - Updated `list_checkpoints()` and `clear_checkpoints_from_step()` to support both BIDS and legacy naming
+
+[x] Please save the checkpoint h5ad files using compression='gzip'
+    - Added `compression="gzip"` to `data.write()` in `save_checkpoint()` function
+
+[x] The size of the checkpoint files is very large, I think in part due to their storage of the original counts within the .X variable in the dataset.  However, I'm not sure if and when that's actually necessary, versus simply reloading the original data or an earlier checkpoint to re-populate that variable. Please examine the usage of this .X variable and determine whether it would make more sense to remove it for the sake of space and then reload if needed from an earlier checkpoint.
+
+### Analysis of .X variable usage:
+
+The workflow uses two main data storage locations in AnnData:
+
+1. **`.X`** - The main expression matrix:
+   - Steps 2-3: Contains raw counts
+   - Steps 4-6: Contains normalized, log-transformed expression data (after preprocessing)
+   - Used for: QC metrics, normalization, HVG selection, PCA, neighbor graph, UMAP, clustering
+
+2. **`layers["counts"]`** - Raw counts layer (no longer used):
+   - Previously created at end of Step 3 (QC) - now removed
+   - Step 7 (pseudobulking) now loads step 3 checkpoint directly to get raw counts from `.X`
+
+**Optimization implemented:**
+- Removed `layers["counts"]` creation from step 3 (QC)
+- Step 7 (pseudobulking) now loads the step 3 checkpoint to get raw counts from `.X`
+- This eliminates redundant storage of raw counts in `layers["counts"]` for steps 3-6 checkpoints
+
+**Storage savings:**
+- Steps 3-6 checkpoints now store only `.X` (not both `.X` and `layers["counts"]`)
+- Combined with gzip compression, this roughly halves the expression data storage for these checkpoints
+
+After Step 7, the pseudobulk AnnData is a separate object with only aggregated counts in `.X` (no layers needed). Steps 8-11 use pickle/parquet files, not h5ad.
+
+**Selective checkpointing:**
+- Added `checkpoint_steps` parameter to `run_stateless_workflow()` (default: `{2, 3, 5}`)
+- Only specified steps save checkpoints; other steps run without saving
+- Step 3 is always required (provides raw counts for pseudobulking)
+- Added `skip_save` parameter to `run_with_checkpoint()` and `run_with_checkpoint_multi()`
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py
index 3fd1a92..14f64e7 100644
--- a/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py
@@ -157,6 +157,7 @@ def run_pseudobulk_pipeline(
     metadata_cols: list[str] | None = None,
     min_cells: int = 10,
     figure_dir: Path | None = None,
+    layer: str | None = None,
 ) -> ad.AnnData:
     """Run complete pseudobulking pipeline.
 
@@ -174,6 +175,8 @@ def run_pseudobulk_pipeline(
         Minimum cells per pseudobulk sample
     figure_dir : Path, optional
         Directory to save figures
+    layer : str, optional
+        Layer to use for counts. If None, uses .X directly.
 
     Returns
     -------
@@ -188,7 +191,7 @@ def run_pseudobulk_pipeline(
         adata,
         group_col=group_col,
         donor_col=donor_col,
-        layer="counts",
+        layer=layer,
         metadata_cols=metadata_cols,
     )
 
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
index 7115679..8200e37 100644
--- a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
@@ -316,7 +316,8 @@ def run_qc_pipeline(
     adata = detect_doublets_per_donor(adata, expected_doublet_rate)
     adata = filter_doublets(adata)
 
-    # Save raw counts for later use
-    adata.layers["counts"] = adata.X.copy()
+    # Note: Raw counts remain in .X at this point.
+    # They will be accessed from this checkpoint during pseudobulking (step 7).
+    # This avoids redundant storage of counts in layers["counts"] for steps 4-6.
 
     return adata
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
index ebac03c..08459ba 100644
--- a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py
@@ -22,6 +22,60 @@
     )
 
 
+def bids_checkpoint_name(
+    dataset_name: str,
+    step_number: int,
+    description: str,
+    extension: str = "h5ad",
+) -> str:
+    """Generate a BIDS-compliant checkpoint filename.
+
+    Parameters
+    ----------
+    dataset_name : str
+        Name of the dataset (e.g., "OneK1K")
+    step_number : int
+        Step number in the workflow
+    description : str
+        Description of the checkpoint content (e.g., "filtered", "qc", "preprocessed")
+    extension : str
+        File extension without the dot (e.g., "h5ad", "pkl", "parquet")
+
+    Returns
+    -------
+    str
+        BIDS-formatted filename like "dataset-OneK1K_step-02_desc-filtered.h5ad"
+    """
+    return f"dataset-{dataset_name}_step-{step_number:02d}_desc-{description}.{extension}"
+
+
+def parse_bids_checkpoint_name(filename: str) -> dict[str, str | int]:
+    """Parse a BIDS-formatted checkpoint filename.
+
+    Parameters
+    ----------
+    filename : str
+        BIDS-formatted filename
+
+    Returns
+    -------
+    dict
+        Dictionary with keys: dataset, step_number, description, extension
+    """
+    import re
+
+    pattern = r"dataset-([^_]+)_step-(\d+)_desc-([^.]+)\.(.+)"
+    match = re.match(pattern, filename)
+    if match:
+        return {
+            "dataset": match.group(1),
+            "step_number": int(match.group(2)),
+            "description": match.group(3),
+            "extension": match.group(4),
+        }
+    return {}
+
+
 def get_file_type(filepath: Path) -> str:
     """Determine file type from extension.
 
@@ -65,7 +119,7 @@ def save_checkpoint(data: Any, filepath: Path) -> None:
     if file_type == "h5ad":
         if not isinstance(data, ad.AnnData):
             raise TypeError(f"Expected AnnData for .h5ad file, got {type(data)}")
-        data.write(filepath)
+        data.write(filepath, compression="gzip")
     elif file_type == "parquet":
         if not isinstance(data, pd.DataFrame):
             raise TypeError(f"Expected DataFrame for .parquet file, got {type(data)}")
@@ -124,6 +178,7 @@ def run_with_checkpoint(
     func: Callable,
     *args,
     force: bool = False,
+    skip_save: bool = False,
     execution_log: ExecutionLog | None = None,
     step_number: int | None = None,
     log_parameters: dict[str, Any] | None = None,
@@ -133,7 +188,7 @@ def run_with_checkpoint(
 
     If the checkpoint file exists and force=False, loads and returns
     the cached result. Otherwise, executes the function, saves the
-    result, and returns it.
+    result (unless skip_save=True), and returns it.
 
     Parameters
     ----------
@@ -147,6 +202,8 @@ def run_with_checkpoint(
         Positional arguments for func
     force : bool
         If True, ignore existing checkpoint and re-run
+    skip_save : bool
+        If True, don't save checkpoint after running (still loads if exists)
     execution_log : ExecutionLog, optional
         Execution log to record step details
     step_number : int, optional
@@ -168,7 +225,7 @@ def run_with_checkpoint(
             step_number=step_number,
             step_name=step_name,
             parameters=log_parameters,
-            checkpoint_file=str(checkpoint_file),
+            checkpoint_file=str(checkpoint_file) if not skip_save else None,
         )
 
     from_cache = False
@@ -185,9 +242,10 @@ def run_with_checkpoint(
             print(f"[{step_name}] Executing...")
             result = func(*args, **kwargs)
 
-            print(f"[{step_name}] Saving checkpoint: {checkpoint_file.name}")
-            save_checkpoint(result, checkpoint_file)
-            save_succeeded = True  # Only mark success after save completes
+            if not skip_save:
+                print(f"[{step_name}] Saving checkpoint: {checkpoint_file.name}")
+                save_checkpoint(result, checkpoint_file)
+            save_succeeded = True  # Mark success after execution (and optional save)
 
         return result
 
@@ -210,6 +268,7 @@ def run_with_checkpoint_multi(
     func: Callable,
     *args,
     force: bool = False,
+    skip_save: bool = False,
     execution_log: ExecutionLog | None = None,
     step_number: int | None = None,
     log_parameters: dict[str, Any] | None = None,
@@ -231,6 +290,8 @@ def run_with_checkpoint_multi(
         Positional arguments for func
     force : bool
         If True, ignore existing checkpoints and re-run
+    skip_save : bool
+        If True, don't save checkpoints after running (still loads if exists)
     execution_log : ExecutionLog, optional
         Execution log to record step details
     step_number : int, optional
@@ -253,7 +314,7 @@ def run_with_checkpoint_multi(
             step_number=step_number,
             step_name=step_name,
             parameters=log_parameters,
-            checkpoint_file=str(checkpoint_files_str),
+            checkpoint_file=str(checkpoint_files_str) if not skip_save else None,
         )
 
     from_cache = False
@@ -278,13 +339,14 @@ def run_with_checkpoint_multi(
                 f"Function must return dict for multi-checkpoint, got {type(results)}"
             )
 
-        print(f"[{step_name}] Saving checkpoints...")
-        for key, filepath in checkpoint_files.items():
-            if key not in results:
-                raise KeyError(f"Function result missing key: {key}")
-            save_checkpoint(results[key], filepath)
+        if not skip_save:
+            print(f"[{step_name}] Saving checkpoints...")
+            for key, filepath in checkpoint_files.items():
+                if key not in results:
+                    raise KeyError(f"Function result missing key: {key}")
+                save_checkpoint(results[key], filepath)
 
-        save_succeeded = True  # Only mark success after all saves complete
+        save_succeeded = True  # Mark success after execution (and optional saves)
         return results
 
     except BaseException as e:
@@ -327,6 +389,7 @@ def clear_checkpoints_from_step(checkpoint_dir: Path, from_step: int) -> list[Pa
     """Remove checkpoints from a specific step onwards.
 
     Useful for invalidating downstream results when re-running an upstream step.
+    Supports both legacy naming (step02_*) and BIDS naming (dataset-*_step-02_*).
 
     Parameters
     ----------
@@ -341,13 +404,23 @@ def clear_checkpoints_from_step(checkpoint_dir: Path, from_step: int) -> list[Pa
         List of removed files
     """
     removed = []
-    for filepath in checkpoint_dir.glob("step*"):
-        try:
-            step_num = int(filepath.name.split("_")[0].replace("step", ""))
-            if step_num >= from_step:
-                filepath.unlink()
-                removed.append(filepath)
-                print(f"Removed: {filepath.name}")
-        except (ValueError, IndexError):
-            continue
+    for filepath in checkpoint_dir.glob("*"):
+        step_num = None
+        # Try BIDS format first
+        parsed = parse_bids_checkpoint_name(filepath.name)
+        if parsed:
+            step_num = parsed["step_number"]
+        else:
+            # Try legacy format (step02_*)
+            try:
+                if filepath.name.startswith("step"):
+                    step_num = int(filepath.name.split("_")[0].replace("step", ""))
+            except (ValueError, IndexError):
+                pass
+
+        if step_num is not None and step_num >= from_step:
+            filepath.unlink()
+            removed.append(filepath)
+            print(f"Removed: {filepath.name}")
+
     return removed
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
index 76d4072..28c0e08 100644
--- a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
@@ -44,7 +44,10 @@
     run_qc_pipeline,
 )
 from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    bids_checkpoint_name,
     clear_checkpoints_from_step,
+    load_checkpoint,
+    parse_bids_checkpoint_name,
     run_with_checkpoint,
     run_with_checkpoint_multi,
 )
@@ -98,17 +101,21 @@ def _run_overrepresentation_as_dict(
     }
 
 
+DEFAULT_CHECKPOINT_STEPS = frozenset({2, 3, 5})
+
+
 def run_stateless_workflow(
     datadir: Path,
     dataset_name: str = "OneK1K",
     url: str = "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad",
     cell_type_for_de: str = "central memory CD4-positive, alpha-beta T cell",
     force_from_step: int | None = None,
+    checkpoint_steps: set[int] | None = None,
 ) -> dict:
     """Run the complete immune aging scRNA-seq analysis workflow with checkpointing.
 
-    Each step saves its output to a checkpoint file. On subsequent runs,
-    completed steps are skipped by loading from checkpoints.
+    Only specified steps save checkpoints. On subsequent runs, steps with
+    existing checkpoints are skipped by loading from checkpoints.
 
     Parameters
     ----------
@@ -122,12 +129,28 @@ def run_stateless_workflow(
         Cell type to use for differential expression
     force_from_step : int, optional
         If provided, clears checkpoints from this step onwards and re-runs
+    checkpoint_steps : set[int], optional
+        Set of step numbers that should save checkpoints. Defaults to {2, 3, 5}.
+        Step 3 is always required (provides raw counts for pseudobulking).
 
     Returns
     -------
     dict
         Dictionary containing all results
     """
+    # Setup checkpoint steps
+    if checkpoint_steps is None:
+        checkpoint_steps = set(DEFAULT_CHECKPOINT_STEPS)
+    else:
+        checkpoint_steps = set(checkpoint_steps)
+
+    # Step 3 is required for pseudobulking (provides raw counts)
+    if 3 not in checkpoint_steps:
+        print("Warning: Step 3 is required for pseudobulking. Adding to checkpoint_steps.")
+        checkpoint_steps.add(3)
+
+    print(f"Checkpointing enabled for steps: {sorted(checkpoint_steps)}")
+
     # Setup directories
     figure_dir = datadir / "workflow/figures"
     figure_dir.mkdir(parents=True, exist_ok=True)
@@ -152,6 +175,7 @@ def run_stateless_workflow(
             url=url,
             cell_type_for_de=cell_type_for_de,
             force_from_step=force_from_step,
+            checkpoint_steps=sorted(checkpoint_steps),
         ),
     )
 
@@ -205,8 +229,9 @@ def _load_and_filter():
 
         adata = run_with_checkpoint(
             "filtering",
-            checkpoint_dir / "step02_filtered.h5ad",
+            checkpoint_dir / bids_checkpoint_name(dataset_name, 2, "filtered"),
             _load_and_filter,
+            skip_save=2 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=2,
             log_parameters=step2_params,
@@ -234,7 +259,7 @@ def _load_and_filter():
 
         adata = run_with_checkpoint(
             "quality_control",
-            checkpoint_dir / "step03_qc.h5ad",
+            checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc"),
             run_qc_pipeline,
             adata,
             min_genes=step3_params["min_genes"],
@@ -244,6 +269,7 @@ def _load_and_filter():
             max_hb_pct=step3_params["max_hb_pct"],
             expected_doublet_rate=step3_params["expected_doublet_rate"],
             figure_dir=figure_dir,
+            skip_save=3 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=3,
             log_parameters=step3_params,
@@ -265,12 +291,13 @@ def _load_and_filter():
 
         adata = run_with_checkpoint(
             "preprocessing",
-            checkpoint_dir / "step04_preprocessed.h5ad",
+            checkpoint_dir / bids_checkpoint_name(dataset_name, 4, "preprocessed"),
             run_preprocessing_pipeline,
             adata,
             target_sum=step4_params["target_sum"],
             n_top_genes=step4_params["n_top_genes"],
             batch_key=step4_params["batch_key"],
+            skip_save=4 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=4,
             log_parameters=step4_params,
@@ -291,13 +318,14 @@ def _load_and_filter():
 
         adata = run_with_checkpoint(
             "dimensionality_reduction",
-            checkpoint_dir / "step05_dimreduced.h5ad",
+            checkpoint_dir / bids_checkpoint_name(dataset_name, 5, "dimreduced"),
             run_dimensionality_reduction_pipeline,
             adata,
             batch_key=step5_params["batch_key"],
             n_neighbors=step5_params["n_neighbors"],
             n_pcs=step5_params["n_pcs"],
             figure_dir=figure_dir,
+            skip_save=5 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=5,
             log_parameters=step5_params,
@@ -314,11 +342,12 @@ def _load_and_filter():
 
         adata = run_with_checkpoint(
             "clustering",
-            checkpoint_dir / "step06_clustered.h5ad",
+            checkpoint_dir / bids_checkpoint_name(dataset_name, 6, "clustered"),
             run_clustering_pipeline,
             adata,
             resolution=step6_params["resolution"],
             figure_dir=figure_dir,
+            skip_save=6 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=6,
             log_parameters=step6_params,
@@ -333,6 +362,12 @@ def _load_and_filter():
         print("STEP 7: PSEUDOBULKING")
         print("=" * 60)
 
+        # Load step 3 checkpoint to get raw counts (stored in .X)
+        # This avoids redundant storage of counts in layers["counts"] for steps 4-6
+        step3_checkpoint = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc")
+        adata_raw_counts = load_checkpoint(step3_checkpoint)
+        print(f"Loaded raw counts from step 3 checkpoint: {adata_raw_counts.shape}")
+
         step7_params = {
             "group_col": "cell_type",
             "donor_col": "donor_id",
@@ -342,14 +377,16 @@ def _load_and_filter():
 
         pb_adata = run_with_checkpoint(
             "pseudobulking",
-            checkpoint_dir / "step07_pseudobulk.h5ad",
+            checkpoint_dir / bids_checkpoint_name(dataset_name, 7, "pseudobulk"),
             run_pseudobulk_pipeline,
-            adata,
+            adata_raw_counts,  # Use step 3 data with raw counts in .X
             group_col=step7_params["group_col"],
             donor_col=step7_params["donor_col"],
             metadata_cols=step7_params["metadata_cols"],
             min_cells=step7_params["min_cells"],
             figure_dir=figure_dir,
+            layer=None,  # Use .X directly (raw counts)
+            skip_save=7 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=7,
             log_parameters=step7_params,
@@ -373,9 +410,12 @@ def _load_and_filter():
         de_outputs = run_with_checkpoint_multi(
             "differential_expression",
             {
-                "stat_res": checkpoint_dir / "step08_stat_res.pkl",
-                "de_results": checkpoint_dir / "step08_de_results.parquet",
-                "counts_df": checkpoint_dir / "step08_counts.parquet",
+                "stat_res": checkpoint_dir
+                / bids_checkpoint_name(dataset_name, 8, "statres", "pkl"),
+                "de_results": checkpoint_dir
+                / bids_checkpoint_name(dataset_name, 8, "deresults", "parquet"),
+                "counts_df": checkpoint_dir
+                / bids_checkpoint_name(dataset_name, 8, "counts", "parquet"),
             },
             _run_differential_expression_as_dict,
             pb_adata,
@@ -383,6 +423,7 @@ def _load_and_filter():
             design_factors=step8_params["design_factors"],
             var_to_feature=var_to_feature,
             n_cpus=step8_params["n_cpus"],
+            skip_save=8 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=8,
             log_parameters=step8_params,
@@ -409,12 +450,13 @@ def _load_and_filter():
 
         gsea_results = run_with_checkpoint(
             "gsea",
-            checkpoint_dir / "step09_gsea.pkl",
+            checkpoint_dir / bids_checkpoint_name(dataset_name, 9, "gsea", "pkl"),
             run_gsea_pipeline,
             de_results,
             gene_sets=step9_params["gene_sets"],
             n_top=step9_params["n_top"],
             figure_dir=figure_dir,
+            skip_save=9 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=9,
             log_parameters=step9_params,
@@ -438,8 +480,10 @@ def _load_and_filter():
         enr_outputs = run_with_checkpoint_multi(
             "overrepresentation",
             {
-                "enr_up": checkpoint_dir / "step10_enr_up.pkl",
-                "enr_down": checkpoint_dir / "step10_enr_down.pkl",
+                "enr_up": checkpoint_dir
+                / bids_checkpoint_name(dataset_name, 10, "enrup", "pkl"),
+                "enr_down": checkpoint_dir
+                / bids_checkpoint_name(dataset_name, 10, "enrdown", "pkl"),
             },
             _run_overrepresentation_as_dict,
             de_results,
@@ -447,6 +491,7 @@ def _load_and_filter():
             padj_threshold=step10_params["padj_threshold"],
             n_top=step10_params["n_top"],
             figure_dir=figure_dir,
+            skip_save=10 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=10,
             log_parameters=step10_params,
@@ -475,12 +520,14 @@ def _load_and_filter():
 
         prediction_results = run_with_checkpoint(
             "predictive_modeling",
-            checkpoint_dir / "step11_prediction.pkl",
+            checkpoint_dir
+            / bids_checkpoint_name(dataset_name, 11, "prediction", "pkl"),
             run_predictive_modeling_pipeline,
             counts_df_ct,
             metadata_ct,
             n_splits=step11_params["n_splits"],
             figure_dir=figure_dir,
+            skip_save=11 not in checkpoint_steps,
             execution_log=execution_log,
             step_number=11,
             log_parameters=step11_params,
@@ -511,6 +558,8 @@ def _load_and_filter():
 def list_checkpoints(datadir: Path) -> list[tuple[str, Path]]:
     """List all checkpoint files in the workflow directory.
 
+    Supports both BIDS naming (dataset-*_step-*_desc-*) and legacy naming (step*_*).
+
     Parameters
     ----------
     datadir : Path
@@ -519,20 +568,37 @@ def list_checkpoints(datadir: Path) -> list[tuple[str, Path]]:
     Returns
     -------
     list[tuple[str, Path]]
-        List of (step_name, file_path) tuples
+        List of (step_name, file_path) tuples, sorted by step number
     """
     checkpoint_dir = datadir / "workflow/checkpoints"
     if not checkpoint_dir.exists():
         return []
 
     checkpoints = []
-    for filepath in sorted(checkpoint_dir.glob("step*")):
-        step_name = (
-            filepath.stem.split("_", 1)[1] if "_" in filepath.stem else filepath.stem
-        )
-        checkpoints.append((step_name, filepath))
-
-    return checkpoints
+    for filepath in checkpoint_dir.glob("*"):
+        if filepath.is_dir():
+            continue
+
+        # Try BIDS format first
+        parsed = parse_bids_checkpoint_name(filepath.name)
+        if parsed:
+            step_num = parsed["step_number"]
+            step_name = parsed["description"]
+            checkpoints.append((step_num, step_name, filepath))
+        else:
+            # Try legacy format (step02_*)
+            if filepath.name.startswith("step"):
+                try:
+                    parts = filepath.stem.split("_", 1)
+                    step_num = int(parts[0].replace("step", ""))
+                    step_name = parts[1] if len(parts) > 1 else filepath.stem
+                    checkpoints.append((step_num, step_name, filepath))
+                except (ValueError, IndexError):
+                    continue
+
+    # Sort by step number and return as (step_name, filepath) tuples
+    checkpoints.sort(key=lambda x: x[0])
+    return [(step_name, filepath) for _, step_name, filepath in checkpoints]
 
 
 def print_checkpoint_status(datadir: Path) -> None:

From 319ccc4f2a16cf52106b69d361195cc04bf52f47 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 16:17:56 -0800
Subject: [PATCH 40/87] Fix: Restore layers['counts'] for HVG selection, delete
 after step 4
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The HVG selection in preprocessing (step 4) requires raw counts in
layers["counts"]. This was incorrectly removed in the previous commit.

Fix:
- Restore layers["counts"] creation in QC step (needed for step 4)
- Delete counts layer after step 4, before step 5 saves checkpoint
- This still saves space in steps 5-6 checkpoints

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          | 19 +++++++++++--------
 .../modular_workflow/quality_control.py       |  7 ++++---
 .../rnaseq/stateless_workflow/run_workflow.py |  6 ++++++
 3 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/problems_to_solve.md b/problems_to_solve.md
index 14c82c4..d803a69 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -23,18 +23,21 @@ The workflow uses two main data storage locations in AnnData:
    - Steps 4-6: Contains normalized, log-transformed expression data (after preprocessing)
    - Used for: QC metrics, normalization, HVG selection, PCA, neighbor graph, UMAP, clustering
 
-2. **`layers["counts"]`** - Raw counts layer (no longer used):
-   - Previously created at end of Step 3 (QC) - now removed
-   - Step 7 (pseudobulking) now loads step 3 checkpoint directly to get raw counts from `.X`
+2. **`layers["counts"]`** - Raw counts layer:
+   - Created at end of Step 3 (QC) for HVG selection in step 4
+   - Deleted after step 4 before step 5 checkpoint is saved
+   - Step 7 (pseudobulking) loads step 3 checkpoint directly to get raw counts from `.X`
 
 **Optimization implemented:**
-- Removed `layers["counts"]` creation from step 3 (QC)
-- Step 7 (pseudobulking) now loads the step 3 checkpoint to get raw counts from `.X`
-- This eliminates redundant storage of raw counts in `layers["counts"]` for steps 3-6 checkpoints
+- `layers["counts"]` is created in step 3 (needed for HVG selection in step 4)
+- After step 4 (preprocessing), the counts layer is deleted before step 5 saves its checkpoint
+- Step 7 (pseudobulking) loads the step 3 checkpoint to get raw counts from `.X`
+- This eliminates redundant storage of raw counts in steps 5-6 checkpoints
 
 **Storage savings:**
-- Steps 3-6 checkpoints now store only `.X` (not both `.X` and `layers["counts"]`)
-- Combined with gzip compression, this roughly halves the expression data storage for these checkpoints
+- Step 3 checkpoint stores both `.X` (raw counts) and `layers["counts"]` (needed for step 4)
+- Steps 5-6 checkpoints store only `.X` (counts layer deleted after step 4)
+- Combined with gzip compression, this reduces storage for steps 5-6 checkpoints
 
 After Step 7, the pseudobulk AnnData is a separate object with only aggregated counts in `.X` (no layers needed). Steps 8-11 use pickle/parquet files, not h5ad.
 
diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
index 8200e37..92fa012 100644
--- a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
@@ -316,8 +316,9 @@ def run_qc_pipeline(
     adata = detect_doublets_per_donor(adata, expected_doublet_rate)
     adata = filter_doublets(adata)
 
-    # Note: Raw counts remain in .X at this point.
-    # They will be accessed from this checkpoint during pseudobulking (step 7).
-    # This avoids redundant storage of counts in layers["counts"] for steps 4-6.
+    # Save raw counts for HVG selection (step 4) and pseudobulking (step 7)
+    # Note: Raw counts are also in .X at this point, which will be used
+    # by pseudobulking when loading this checkpoint directly.
+    adata.layers["counts"] = adata.X.copy()
 
     return adata
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
index 28c0e08..3592857 100644
--- a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
@@ -303,6 +303,12 @@ def _load_and_filter():
             log_parameters=step4_params,
         )
 
+        # Remove counts layer after preprocessing to save space in subsequent checkpoints
+        # (counts layer was needed for HVG selection but is no longer needed)
+        if "counts" in adata.layers:
+            del adata.layers["counts"]
+            print("Removed counts layer to save checkpoint space")
+
         # =====================================================================
         # STEP 5: Dimensionality Reduction
         # =====================================================================

From 20f2e71c97664c2cefad53b8f3b70960f5ac77f6 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Sun, 21 Dec 2025 19:28:44 -0800
Subject: [PATCH 41/87] Add steps 9-11 to default checkpoint steps
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

These steps produce small pickle files, so caching them adds minimal
disk usage while avoiding re-computation on subsequent runs.

Default checkpoint_steps now: {2, 3, 5, 9, 10, 11}

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                                          | 3 ++-
 .../rnaseq/stateless_workflow/run_workflow.py                 | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/problems_to_solve.md b/problems_to_solve.md
index d803a69..5ad9246 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -42,7 +42,8 @@ The workflow uses two main data storage locations in AnnData:
 After Step 7, the pseudobulk AnnData is a separate object with only aggregated counts in `.X` (no layers needed). Steps 8-11 use pickle/parquet files, not h5ad.
 
 **Selective checkpointing:**
-- Added `checkpoint_steps` parameter to `run_stateless_workflow()` (default: `{2, 3, 5}`)
+- Added `checkpoint_steps` parameter to `run_stateless_workflow()` (default: `{2, 3, 5, 9, 10, 11}`)
 - Only specified steps save checkpoints; other steps run without saving
 - Step 3 is always required (provides raw counts for pseudobulking)
+- Steps 9-11 included by default as they produce small pickle files
 - Added `skip_save` parameter to `run_with_checkpoint()` and `run_with_checkpoint_multi()`
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
index 3592857..861c285 100644
--- a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
@@ -101,7 +101,7 @@ def _run_overrepresentation_as_dict(
     }
 
 
-DEFAULT_CHECKPOINT_STEPS = frozenset({2, 3, 5})
+DEFAULT_CHECKPOINT_STEPS = frozenset({2, 3, 5, 9, 10, 11})
 
 
 def run_stateless_workflow(
@@ -130,7 +130,7 @@ def run_stateless_workflow(
     force_from_step : int, optional
         If provided, clears checkpoints from this step onwards and re-runs
     checkpoint_steps : set[int], optional
-        Set of step numbers that should save checkpoints. Defaults to {2, 3, 5}.
+        Set of step numbers that should save checkpoints. Defaults to {2, 3, 5, 9, 10, 11}.
         Step 3 is always required (provides raw counts for pseudobulking).
 
     Returns

From 70ad51be2fdc2613e53cc50ad13d26c5db3b978b Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 06:19:48 -0800
Subject: [PATCH 42/87] Add step 8 (differential expression) to default
 checkpoint steps
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Default checkpoint_steps now: {2, 3, 5, 8, 9, 10, 11}

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                                          | 4 ++--
 .../rnaseq/stateless_workflow/run_workflow.py                 | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/problems_to_solve.md b/problems_to_solve.md
index 5ad9246..03cffce 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -42,8 +42,8 @@ The workflow uses two main data storage locations in AnnData:
 After Step 7, the pseudobulk AnnData is a separate object with only aggregated counts in `.X` (no layers needed). Steps 8-11 use pickle/parquet files, not h5ad.
 
 **Selective checkpointing:**
-- Added `checkpoint_steps` parameter to `run_stateless_workflow()` (default: `{2, 3, 5, 9, 10, 11}`)
+- Added `checkpoint_steps` parameter to `run_stateless_workflow()` (default: `{2, 3, 5, 8, 9, 10, 11}`)
 - Only specified steps save checkpoints; other steps run without saving
 - Step 3 is always required (provides raw counts for pseudobulking)
-- Steps 9-11 included by default as they produce small pickle files
+- Steps 8-11 included by default as they produce small pickle/parquet files
 - Added `skip_save` parameter to `run_with_checkpoint()` and `run_with_checkpoint_multi()`
diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
index 861c285..f43384a 100644
--- a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py
@@ -101,7 +101,7 @@ def _run_overrepresentation_as_dict(
     }
 
 
-DEFAULT_CHECKPOINT_STEPS = frozenset({2, 3, 5, 9, 10, 11})
+DEFAULT_CHECKPOINT_STEPS = frozenset({2, 3, 5, 8, 9, 10, 11})
 
 
 def run_stateless_workflow(
@@ -130,7 +130,7 @@ def run_stateless_workflow(
     force_from_step : int, optional
         If provided, clears checkpoints from this step onwards and re-runs
     checkpoint_steps : set[int], optional
-        Set of step numbers that should save checkpoints. Defaults to {2, 3, 5, 9, 10, 11}.
+        Set of step numbers that should save checkpoints. Defaults to {2, 3, 5, 8, 9, 10, 11}.
         Step 3 is always required (provides raw counts for pseudobulking).
 
     Returns

From c68aa0f10892f3250c696424cb231b7c26cec584 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 06:53:43 -0800
Subject: [PATCH 43/87] finished checkpointed workflow section

---
 book/workflows.md | 151 +++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 129 insertions(+), 22 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index edae351..9f7c432 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -1,12 +1,12 @@
 # Workflow Management
 
-In most parts of science today, data processing and analysis comprises many different steps.  We will refer to such a set of steps as a computational *workflow*. If you have been doing science for very long, you have very likely encountered a *mega-script* that implements such a workflow. Usually written in a scripting language like *Bash*, this is a script that may be hundreds or even thousands of lines long that runs a single workflow from start to end.  Often these scripts are handed down to new trainees over generations, such that users become afraid to make any changes lest the entire house of cards comes crashing down.  I think that most of us can agree that this is not an optimal workflow, and in this chapter I will discuss in detail how to move from a mega-script to a workflow that will meet all of the requirements that are required to provide robust and reliable answers to our scientific questions.
+In most parts of science today, data processing and analysis comprise many different steps.  We will refer to such a set of steps as a computational *workflow*. If you have been doing science for very long, you have very likely encountered a *mega-script* that implements such a workflow. Usually written in a scripting language like *Bash*, this is a script that may be hundreds or even thousands of lines long that runs a single workflow from start to end.  Often these scripts are handed down to new trainees over generations, such that users become afraid to make any changes lest the entire house of cards comes crashing down.  I think that most of us can agree that this is not an optimal workflow, and in this chapter I will discuss in detail how to move from a mega-script to a workflow that will meet all of the requirements to provide robust and reliable answers to our scientific questions.
 
 ## What do we want from a scientific workflow?
 
 First let's ask: What do we want from a computational scientific workflow?  Here are some of the factors that I think are important.  First, we care about the *correctness* of the workflow, which includes the following factors:
 
-- *Verifiability*:  The workflow includes validation procedures to ensure against known problems or edge cases.
+- *Validity*:  The workflow includes validation procedures to ensure against known problems or edge cases.
 - *Reproducibility*:  The workflow can be rerun from scratch on the same data and get the same answer, at least within the limits of uncontrollable factors such as floating point imprecision.
 - *Robustness*: When there is a problem, the workflow fails quickly with explicit error messages, or degrades gracefully when possible.
 
@@ -20,19 +20,19 @@ Third, we care about the *engineering quality* of the code, which includes:
 
 - *Maintainability*: The workflow is structured and documented so that others (including your future self) can easily maintain, update, and extend it in the future.
 - *Modularity*: The workflow is composed of a set of independently testable modules, which can be swapped in or out relatively easily.
-- *Idempotency*: This term from computer science means that running the workflow multiple times gives the same result as running it once, which allows safely rerunning the workflow when there is a failure.
+- *Idempotency*: This term from computer science means that the result of the workflow does not change after its first successful run, which allows safely rerunning the workflow when there is a failure.
 - *Traceability*:  All operations are logged, and provenance information is stored for outputs.
 
 Finally, we care about the *efficiency* of the workflow implementation. This includes:
 
 - *Incremental execution*: The workflow only reruns a module if necessary, such as when an input changes.
-- *Amortized computation*: The workflow pre-computes and reuses results from expensive operations when possible.
+- *Cached computation*: The workflow pre-computes and reuses results from expensive operations when possible.
 
-It's worth noting that these different desiderata will sometimes conflict with one another (such as configurability versus maintainability), and that no workflow will be perfect.  
+It's worth noting that these different desiderata will sometimes conflict with one another (such as configurability versus maintainability), and that no workflow will be perfect.  For example, a highly configurable workflow will often be more difficult to maintain.
 
-### Pipelines versus workflows
+## Pipelines versus workflows
 
-The terms *workflow* and *pipeline* are sometimes used interchangeable, but in this chapter I will use them to refer to different kinds of applications. I will use *workflow* as the more general term to refer to any set of analysis procedures that are implemented as separate modules.  I will use the term *pipeline* to refer more specifically to a data analysis workflow where the several operations are combined into a single command through the use of *pipes*, which are a syntactic construct that feed the output of one process directly into the next process as input.  Some readers may be familiar with pipes from the UNIX filesystem, where they are represented by the vertical bar "|".  For example, let's say that we had a log file that contains the follow entries:
+The terms *workflow* and *pipeline* are sometimes used interchangeably, but in this chapter I will use them to refer to different kinds of applications. I will use *workflow* as the more general term to refer to any set of analysis procedures that are implemented as separate modules.  I will use the term *pipeline* to refer more specifically to a data analysis workflow where several operations are combined into a single command through the use of *pipes*, which are a syntactic construct that feed the output of one process directly into the next process as input.  Some readers may be familiar with pipes from the UNIX command line, where they are represented by the vertical bar "|".  For example, let's say that we had a log file that contains the following entries:
 
 ```bash
 2024-01-15 10:23:45 ERROR: Database connection failed
@@ -51,16 +51,16 @@ grep "ERROR" app.log | sed 's/.*ERROR: //' | sort | uniq -c | sort -rn > error_s
 
 where:
 
-- `grep "ERROR" app.log` extracts line containing the word "ERROR"
+- `grep "ERROR" app.log` extracts lines containing the word "ERROR"
 - `sed 's/.*ERROR: //'` replaces everything up to the actual message with an empty string
 - `sort` sorts the rows alphabetically
 - `uniq -c` counts the number of appearances of each unique error message
-- `sort -rn`  sorts the rows in numerical order
+- `sort -rn`  sorts the rows in reverse numerical order (largest to smallest)
 - `> error_summary.txt` redirects the output into a file called `error_summary.txt`
 
 #### Method chaining
 
-One way that simple pipelines can be built in Python is using *method chaining*, where the output of one class method is redirected into the next class method.  This is commonly used to perform data transformations in `pandas`, as it allows composing multiple transformations into a single command.  As an example, we will work with the Eisenberg et al. dataset that we used in a previous chapter, to compute the probability of having ever been arrested separately for males and females in the sample. To do this we need to perform a number of operations:
+One way that simple pipelines can be built in Python is using *method chaining*, where each method returns an object on which the next method is called; this is slightly different from the operation of UNIX pipes, where it is the result of each command that is being passed through the pipe.  This is commonly used to perform data transformations in `pandas`, as it allows composing multiple transformations into a single command.  As an example, we will work with the Eisenberg et al. dataset that we used in a previous chapter, to compute the probability of having ever been arrested separately for males and females in the sample. To do this we need to perform a number of operations:
 
 - drop any observations that have missing values for the `Sex` or `ArrestedChargedLifeCount` variables
 - replace the numeric values in the `Sex` variable with text labels
@@ -69,7 +69,7 @@ One way that simple pipelines can be built in Python is using *method chaining*,
 - select the column that we want to compute the mean of (`EverArrested`)
 - compute the mean
 
-We can do this in a single command using method chaining in `pandas`.  It's useful to format the code in a way that makes the pipeline steps explicit, by putting parentheses around the operation; in Python, any commands within parentheses are combined into a single command, which can be useful for making complex code more readable:
+We can do this in a single command using method chaining in `pandas`.  It's useful to format the code in a way that makes the pipeline steps explicit, by putting parentheses around the operation; in Python, any commands within parentheses are implicitly treated as a single line, which can be useful for making complex code more readable:
 
 ```python
 arrest_stats_by_sex = (df
@@ -94,7 +94,7 @@ Note that `pandas` data frames also include an explicit `.pipe` method that allo
 
 ## An example of a complex workflow
 
-In this chapter we will focus primarily on complex workflows that have many stages. I will use a running example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features outlined above.  For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from about 1.3 million immune system cells for about 35K transcripts.  I chose this particular example for several reasons:
+In this chapter we will focus primarily on complex workflows that have many stages. I will use a running example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features described earlier.  For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from about 1.3 million immune system cells for about 35K transcripts.  I chose this particular example for several reasons:
 
 - It is a realistic example of a workflow that a researcher might actually perform.
 - The data are large enough to call for a real workflow management scheme, but small enough to be processed on a single laptop (assuming it has decent memory). 
@@ -104,7 +104,7 @@ In this chapter we will focus primarily on complex workflows that have many stag
 
 ### Starting point: One huge notebook
 
-I developed the initial version of this workflow in a way that many researchers would do so: By creating a Jupyter notebook that implements the entire workflow, which can be found [here]().  Although I don't usually prefer to do code generation using a chatbot, I did most of the coding for this example using the Google Gemini 3.0 chatbot, for a couple of reasons.  First, this model seemed particularly knowledgeable about this kind of analysis and the relevant packages.  Second, I found it useful to read the commentary about why particular analysis steps were being selected.  For debugging I used a mixture of the Gemini 3.0 chatbot and the VSCode Copilot agent, depending on the nature of the problem; for problems specific to the RNA-seq analysis tools I used Gemini, while for standard Python/Pandas issues I used Copilot. The total execution time for this notebook is about two hours on an M3 Max Macbook Pro.  
+I developed the initial version of this workflow as many researchers would: by creating a Jupyter notebook that implements the entire workflow, which can be found [here]().  Although I don't usually prefer to do code generation using a chatbot, I did most of the coding for this example using the Google Gemini 3 chatbot, for a couple of reasons.  First, this model seemed particularly knowledgeable about this kind of analysis and the relevant packages.  Second, I found it useful to read the commentary about why particular analysis steps were being selected.  For debugging I used a mixture of the Gemini 3 chatbot and the VSCode Copilot agent, depending on the nature of the problem; for problems specific to the RNA-seq analysis tools I used Gemini, while for standard Python/Pandas issues I used Copilot. The total execution time for this notebook is about two hours on an M3 Max Macbook Pro.  
 
 #### The problem of in-place operations
 
@@ -138,28 +138,135 @@ The first thing we need to do with a large monolithic workflow is to determine h
 - Overrepresentation analysis (Enrichr)
 - Predictive modeling
 
-In addition to a conceptual breakdown, there are also other reasons that one might to further decompose the workflow:
+In addition to a conceptual breakdown, there are also other reasons that one might want to further decompose the workflow:
 
-- There may be points where one might need to restart the computation (e.g. due to computational cost)
-- There may be sections where one might wish to swap in a new method or different parameterization
-- There may be points where the output could be reusable elsewhere
+- There may be points where one might need to restart the computation (e.g. due to computational cost).
+- There may be sections where one might wish to swap in a new method or different parameterization.
+- There may be points where the output could be reusable elsewhere.
 
 
 
 ## Stateless workflows
 
-I asked Claude Code to help modularize the monolithic workflow, using a prompt that provided the conceptual breakdown described above.  The resulting code (found at XXX) ran correctly, but crashed about two hours into the process due to a resource issue that appeared to be due to asking for too many CPU cores in the differential expression analysis.  This left me in the situation of having to rerun the entire two hours of preliminary workflow simply to get to a point where I could test my fix for the differential expression component, which is not a particularly efficient way of coding.  The problem here is that the workflow execution is *stateful*, in the sense that the previous steps need to be rerun prior to performing the current step in order to establish the required objects in memory.  The solution to this problem is to implement the workflow in a *stateless* way, which doesn't require that earlier steps be rerun if they have already been completed.  One way to do this is by implementing a process called *checkpointing*, in which intermediate results are stored for each step.  These can then be used to start the workflow at any point without having to rerun all of the previous steps.  
+I asked Claude Code to help modularize the monolithic workflow, using a prompt that provided the conceptual breakdown described above.  The resulting code (found at XXX - link to commit 678983e1c337b6a23b0f35cfb974a87587cfd13e) ran correctly, but crashed about two hours into the process due to a resource issue that appeared to be due to asking for too many CPU cores in the differential expression analysis.  This left me in the situation of having to rerun the entire two hours of preliminary workflow simply to get to a point where I could test my fix for the differential expression component, which is not a particularly efficient way of coding.  The problem here is that the workflow execution is *stateful*, in the sense that the previous steps need to be rerun prior to performing the current step in order to establish the required objects in memory.  The solution to this problem is to implement the workflow in a *stateless* way, which doesn't require that earlier steps be rerun if they have already been completed.  One way to do this is by implementing a process called *checkpointing*, in which intermediate results are stored for each step.  These can then be used to start the workflow at any point without having to rerun all of the previous steps.  
 
+Another important feature of a workflow related to statelessness is *idempotency*, which means that a workflow will result in the same answer when run multiple times.  This is related to, but not the same as, the idea of statelessness.  For example, a stateless workflow that saves its outputs to checkpoint files could fail to be idempotent if the results were appended to the output file with each execution, rather than overwriting them.  This would result in different outputs depending on how many times the workflow has been executed.  Thus, when we use checkpointing we should be sure to either reuse the existing file or rewrite it completely with a new version.
 
 
+I asked Claude Code to help with this:
 
-the workflow should be stateless when possible
+> I would like to modify the workflow described in src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py to make it execute in a stateless way through the use of checkpointing.  Please analyze the code and suggest the best way to accomplish this.
 
-- allows each state to be run independently
+After analyzing the codebase Claude came up with three proposed solutions to the problem:
+
+- 1. Use a "registry pattern" in which we define each step in terms of its inputs, outputs, and checkpoint file, and then assemble these into a workflow that can be executed in a stateless way, automatically skipping completed steps.  This was its recommended approach.
+- 2. Use simple "wrapper" approach in which each module in the workflow is executed via a wrapper function that checks for cached checkpoint values.
+- 3. Use a well-established existing workflow engine such as [Prefect](https://www.prefect.io/) or [Luigi](https://github.com/spotify/luigi). While these are powerful, they incur additional dependencies and complexity and may be too heavyweight for our problem.
+
+Here we will examine the first (recommended) option and the third solution; while the second option is easy to implement, it's not as clean as the registry approach.
+
+### A workflow registry with checkpointing
+
+We start with a custom approach in order to get a better view of the details of workflow orchestration.   
+
+> let's implement the recommended Stateless Workflow with Checkpointing.  Please generate new code within src/BetterCodeBetterScience/rnaseq/stateless_workflow.
+
+The resulting code worked straight out of the box, but it didn't maintain any sort of log of its processing, which can be very useful.  In particular, I wanted to log the time required to execute each step in the workflow, for use in optimization that I will discuss further below.  I asked Claude to add this:
+
+> I would like to log information about execution, including the time required to execute each step along with the details about execution such as parameters passed for each step.  please record these during execution and save to a date-stamped json file within the workflows directory.
+
+After Claude's implementation of this feature, a fresh run of the workflow gives the following summary:
+
+```bash
+============================================================
+EXECUTION SUMMARY
+============================================================
+Workflow: immune_aging_scrnaseq
+Run ID: 20251221_114458
+Status: completed
+Total Duration: 7094.5 seconds
+
+Step Details:
+------------------------------------------------------------
+  ✓ Step 1: data_download                 0.0s [cached]
+  ✓ Step 2: filtering                    74.7s
+  ✓ Step 3: quality_control             263.3s
+  ✓ Step 4: preprocessing                35.9s
+  ✓ Step 5: dimensionality_reduction   6565.4s
+  ✓ Step 6: clustering                   69.6s
+  ✓ Step 7: pseudobulking                11.6s
+  ✓ Step 8: differential_expression      19.0s
+  ✓ Step 9: gsea                          1.7s
+  ✓ Step 10: overrepresentation           13.3s
+  ✓ Step 11: predictive_modeling          39.8s
+------------------------------------------------------------
+```
+
+The associated JSON file contains much more detail regarding each workflow step.  If we run the workflow again, we see that it now uses cached results at each step:
+
+```bash
+============================================================
+EXECUTION SUMMARY
+============================================================
+Workflow: immune_aging_scrnaseq
+Run ID: 20251221_142225
+Status: completed
+Total Duration: 17.4 seconds
+
+Step Details:
+------------------------------------------------------------
+  ✓ Step 1: data_download                 0.0s [cached]
+  ✓ Step 2: filtering                     1.9s [cached]
+  ✓ Step 3: quality_control               3.0s [cached]
+  ✓ Step 4: preprocessing                 3.1s [cached]
+  ✓ Step 5: dimensionality_reduction      3.4s [cached]
+  ✓ Step 6: clustering                    4.3s [cached]
+  ✓ Step 7: pseudobulking                 0.1s [cached]
+  ✓ Step 8: differential_expression       1.4s [cached]
+  ✓ Step 9: gsea                          0.0s [cached]
+  ✓ Step 10: overrepresentation            0.0s [cached]
+  ✓ Step 11: predictive_modeling           0.0s [cached]
+------------------------------------------------------------
+```
+
+Checkpointing thus solved our problem, by allowing each step to be skipped over once it's been completed.
+
+#### Checkpointing and disk usage
+
+One potential drawback of checkpointing is that it can result in substantial disk usage when working with large datasets. In the example above, the checkpoint directory after workflow completion weighs in at a whopping 64 Gigabytes, with numerous very large files:
+
+```bash
+➤  du -sh *
+
+7.3G    step02_filtered.h5ad
+ 13G    step03_qc.h5ad
+ 13G    step04_preprocessed.h5ad
+ 14G    step05_dimreduced.h5ad
+ 14G    step06_clustered.h5ad
+380M    step07_pseudobulk.h5ad
+ 28M    step08_counts.parquet
+1.6M    step08_de_results.parquet
+1.8G    step08_stat_res.pkl
+ 13M    step09_gsea.pkl
+ 44K    step10_enr_down.pkl
+ 28K    step10_enr_up.pkl
+ 36K    step11_prediction.pkl
+ ```
+
+In particular, in step 3 a copy of the original data was added for reuse in a later step (in a separate variable within the dataset) alongside the results of processing at that step, leading to files that were roughly doubled in size.  However, those raw data were not needed again until step 7.  By changing the workflow to avoid saving those data in the checkpoints and instead loading them directly at step 7, we were able to halve the size of those intermediate checkpoints.
+
+In this implementation a checkpoint file was stored for each step in the workflow.  However, if the goal of checkpointing is primarily to avoid having to rerun expensive computations, then we don't need to checkpoint every step given that some of them take relatively little time.  In this case, we can checkpoint only after a subset of steps.  In this case I chose to checkpoint after steps 2, 3, and 5 since those each take well over a minute to run (with step 5 taking well over an hour).  Another goal of checkpointing is to store files that might be useful for later analyses or QA by the researcher.  In this example workflow, steps 1-7 can be classified as "preprocessing" in the sense that they are preparing the data for analysis, whereas steps 8-11 reflect actual analyses of the data, such that the results could be reported in a publication.  It is thus important to save those outputs for later analyses and for sharing with the final results.
+
+#### Compressing checkpoint files
+
+Another potentially helpful solution is to compress the checkpoint data if they are not already being compressed by default.  In this example, the default in the AnnData package for saving `h5ad` files is to use no compression, so there are substantial savings in disk space to be had by compressing the data: whereas the raw data file was 7.3 GB, a version of the same data saved using compression took up only 2.9 GB.  The tradeoff is that working with compressed files takes longer.  This is particularly the case for saving of files; whereas it took about 3 seconds to save an uncompressed version of the data, it took about 105 seconds to store the compressed version.  Given that the saving of the compressed file will happen in the context of an already long workflow, that doesn't seem like such a concern.  We are more concerned about how the use of compression increases loading times, and here the difference is not quite so dramatic, at 1.3 seconds versus 19.8 seconds.  The decision about whether or not to compress will ultimately come down to the relative cost of time versus disk space, but in this case I decided to go ahead and compress the checkpoint files.
+
+Combining these strategies of reducing data duplication, eliminating some intermediate checkpoints, and compressing the stored data, our final pipeline generates about 13 GB worth of checkpoint data, substantially smaller than the initial 64 GB.  With all checkpoints generated, the entire workflow completes in less than four minutes, with only three time-consuming steps being rerun each time.   The initial execution of the workflow is a few minutes longer due to the extra time needed to read and write compressed checkpoint files, but these few minutes are hardly noticeable for a workflow that takes more than two hours to complete.
+
+
+### Using a workflow engine
 
-but sometimes state is required
 
-- e.g. training a neural network, one needs to know where you are in the process
 
 
 

From ad9381ae07731a69bbb5c21f69c430e4f317a6f9 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 07:34:11 -0800
Subject: [PATCH 44/87] Add Prefect-based workflow with parallel per-cell-type
 analysis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implements a new Prefect workflow at rnaseq/prefect_workflow/ that:
- Wraps existing modular workflow functions as Prefect tasks
- Runs steps 1-7 sequentially with checkpoint caching
- Runs steps 8-11 (DE, GSEA, Enrichr, prediction) in parallel for each cell type
- Organizes results by cell type in workflow/results/per_cell_type/

New files:
- tasks.py: Prefect task definitions
- flows.py: Main workflow flow with parallel execution
- run_workflow.py: CLI entry point with --force-from, --cell-type, --list-cell-types

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          |  56 +--
 pyproject.toml                                |   1 +
 .../rnaseq/prefect_workflow/__init__.py       |   0
 .../rnaseq/prefect_workflow/flows.py          | 430 +++++++++++++++++
 .../rnaseq/prefect_workflow/run_workflow.py   | 177 +++++++
 .../rnaseq/prefect_workflow/tasks.py          | 376 +++++++++++++++
 uv.lock                                       | 446 +++++++++++++++++-
 7 files changed, 1427 insertions(+), 59 deletions(-)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/prefect_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/prefect_workflow/tasks.py

diff --git a/problems_to_solve.md b/problems_to_solve.md
index 03cffce..f1e6d77 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -3,47 +3,15 @@
 Open problems marked with [ ]
 Fixed problems marked with [x]
 
-
-[x] Please change the file naming scheme for the checkpoint files to use a BIDS schema, just like the downloaded data.
-    - Implemented `bids_checkpoint_name()` and `parse_bids_checkpoint_name()` functions
-    - Checkpoint files now use format: `dataset-{name}_step-{number}_desc-{description}.{extension}`
-    - Updated `list_checkpoints()` and `clear_checkpoints_from_step()` to support both BIDS and legacy naming
-
-[x] Please save the checkpoint h5ad files using compression='gzip'
-    - Added `compression="gzip"` to `data.write()` in `save_checkpoint()` function
-
-[x] The size of the checkpoint files is very large, I think in part due to their storage of the original counts within the .X variable in the dataset.  However, I'm not sure if and when that's actually necessary, versus simply reloading the original data or an earlier checkpoint to re-populate that variable. Please examine the usage of this .X variable and determine whether it would make more sense to remove it for the sake of space and then reload if needed from an earlier checkpoint.
-
-### Analysis of .X variable usage:
-
-The workflow uses two main data storage locations in AnnData:
-
-1. **`.X`** - The main expression matrix:
-   - Steps 2-3: Contains raw counts
-   - Steps 4-6: Contains normalized, log-transformed expression data (after preprocessing)
-   - Used for: QC metrics, normalization, HVG selection, PCA, neighbor graph, UMAP, clustering
-
-2. **`layers["counts"]`** - Raw counts layer:
-   - Created at end of Step 3 (QC) for HVG selection in step 4
-   - Deleted after step 4 before step 5 checkpoint is saved
-   - Step 7 (pseudobulking) loads step 3 checkpoint directly to get raw counts from `.X`
-
-**Optimization implemented:**
-- `layers["counts"]` is created in step 3 (needed for HVG selection in step 4)
-- After step 4 (preprocessing), the counts layer is deleted before step 5 saves its checkpoint
-- Step 7 (pseudobulking) loads the step 3 checkpoint to get raw counts from `.X`
-- This eliminates redundant storage of raw counts in steps 5-6 checkpoints
-
-**Storage savings:**
-- Step 3 checkpoint stores both `.X` (raw counts) and `layers["counts"]` (needed for step 4)
-- Steps 5-6 checkpoints store only `.X` (counts layer deleted after step 4)
-- Combined with gzip compression, this reduces storage for steps 5-6 checkpoints
-
-After Step 7, the pseudobulk AnnData is a separate object with only aggregated counts in `.X` (no layers needed). Steps 8-11 use pickle/parquet files, not h5ad.
-
-**Selective checkpointing:**
-- Added `checkpoint_steps` parameter to `run_stateless_workflow()` (default: `{2, 3, 5, 8, 9, 10, 11}`)
-- Only specified steps save checkpoints; other steps run without saving
-- Step 3 is always required (provides raw counts for pseudobulking)
-- Steps 8-11 included by default as they produce small pickle/parquet files
-- Added `skip_save` parameter to `run_with_checkpoint()` and `run_with_checkpoint_multi()`
+[x] I would like to add a new workflow, with code saved to src/BetterCodeBetterScience/rnaseq/prefect_workflow. This workflow will use the Prefect workflow manager (https://github.com/PrefectHQ/prefect) to manage the workflow that was previously developed in src/BetterCodeBetterScience/rnaseq/stateless_workflow. The one new feature that I would like to add here is to perform steps 8-11 separately on each different cell type that survives the initial filtering.
+    - Created `prefect_workflow/` directory with:
+      - `tasks.py`: Prefect task definitions wrapping modular workflow functions
+      - `flows.py`: Main workflow flow with parallel per-cell-type analysis
+      - `run_workflow.py`: CLI entry point with argument parsing
+    - Steps 1-7 run sequentially with checkpoint caching (reuses existing system)
+    - Steps 8-11 run in parallel for each cell type:
+      - DE tasks submitted in parallel across all cell types
+      - GSEA, Enrichr, and predictive modeling run in parallel within each cell type
+    - Added `prefect>=3.0` dependency to pyproject.toml
+    - Results organized by cell type in `workflow/results/per_cell_type/`
+    - CLI supports: `--force-from`, `--cell-type`, `--list-cell-types`, `--min-samples`  
diff --git a/pyproject.toml b/pyproject.toml
index 50c0f88..2874068 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -79,6 +79,7 @@ dependencies = [
     "ipython>=9.8.0",
     "harmonypy>=0.0.10",
     "rpy2>=3.6.4",
+    "prefect>=3.0",
 ]
 
 [build-system]
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
new file mode 100644
index 0000000..a0b06f0
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
@@ -0,0 +1,430 @@
+"""Prefect flow definitions for scRNA-seq workflow.
+
+Main workflow flow that orchestrates all tasks.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from prefect import flow, get_run_logger
+
+from BetterCodeBetterScience.rnaseq.prefect_workflow.tasks import (
+    clustering_task,
+    differential_expression_task,
+    dimensionality_reduction_task,
+    download_data_task,
+    load_and_filter_task,
+    overrepresentation_task,
+    pathway_analysis_task,
+    predictive_modeling_task,
+    preprocessing_task,
+    pseudobulk_task,
+    quality_control_task,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    bids_checkpoint_name,
+    load_checkpoint,
+)
+
+
+@flow(name="immune_aging_scrna_workflow", log_prints=True)
+def run_workflow(
+    datadir: Path,
+    dataset_name: str = "OneK1K",
+    url: str = "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad",
+    force_from_step: int | None = None,
+    min_samples_per_cell_type: int = 10,
+) -> dict[str, Any]:
+    """Run the complete immune aging scRNA-seq workflow with Prefect.
+
+    Steps 1-7 run sequentially (shared preprocessing).
+    Steps 8-11 run in parallel for each cell type.
+
+    Parameters
+    ----------
+    datadir : Path
+        Base directory for data files
+    dataset_name : str
+        Name of the dataset
+    url : str
+        URL to download data from
+    force_from_step : int, optional
+        If provided, forces re-run from this step onwards
+    min_samples_per_cell_type : int
+        Minimum samples required per cell type to run steps 8-11
+
+    Returns
+    -------
+    dict
+        Dictionary containing all results organized by cell type
+    """
+    logger = get_run_logger()
+
+    # Setup directories
+    figure_dir = datadir / "workflow/figures"
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    checkpoint_dir = datadir / "workflow/checkpoints"
+    checkpoint_dir.mkdir(parents=True, exist_ok=True)
+
+    results_dir = datadir / "workflow/results/per_cell_type"
+    results_dir.mkdir(parents=True, exist_ok=True)
+
+    # Determine which steps to force re-run
+    force = {i: False for i in range(1, 12)}
+    if force_from_step is not None:
+        for i in range(force_from_step, 12):
+            force[i] = True
+
+    # =========================================================================
+    # STEP 1: Data Download
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEP 1: DATA DOWNLOAD")
+    logger.info("=" * 60)
+
+    datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad"
+    download_data_task(datafile, url)
+
+    # =========================================================================
+    # STEP 2: Data Filtering
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEP 2: DATA FILTERING")
+    logger.info("=" * 60)
+
+    adata = load_and_filter_task(
+        datafile=datafile,
+        checkpoint_file=checkpoint_dir
+        / bids_checkpoint_name(dataset_name, 2, "filtered"),
+        cutoff_percentile=1.0,
+        min_cells_per_celltype=10,
+        percent_donors=0.95,
+        figure_dir=figure_dir,
+        force=force[2],
+    )
+
+    # Build var_to_feature mapping
+    var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"]))
+
+    # =========================================================================
+    # STEP 3: Quality Control
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEP 3: QUALITY CONTROL")
+    logger.info("=" * 60)
+
+    adata = quality_control_task(
+        adata=adata,
+        checkpoint_file=checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc"),
+        min_genes=200,
+        max_genes=6000,
+        min_counts=500,
+        max_counts=30000,
+        max_hb_pct=5.0,
+        expected_doublet_rate=0.06,
+        figure_dir=figure_dir,
+        force=force[3],
+    )
+
+    # =========================================================================
+    # STEP 4: Preprocessing
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEP 4: PREPROCESSING")
+    logger.info("=" * 60)
+
+    adata = preprocessing_task(
+        adata=adata,
+        checkpoint_file=checkpoint_dir
+        / bids_checkpoint_name(dataset_name, 4, "preprocessed"),
+        target_sum=1e4,
+        n_top_genes=3000,
+        batch_key="donor_id",
+        force=force[4],
+    )
+
+    # =========================================================================
+    # STEP 5: Dimensionality Reduction
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEP 5: DIMENSIONALITY REDUCTION")
+    logger.info("=" * 60)
+
+    adata = dimensionality_reduction_task(
+        adata=adata,
+        checkpoint_file=checkpoint_dir
+        / bids_checkpoint_name(dataset_name, 5, "dimreduced"),
+        batch_key="donor_id",
+        n_neighbors=30,
+        n_pcs=40,
+        figure_dir=figure_dir,
+        force=force[5],
+    )
+
+    # =========================================================================
+    # STEP 6: Clustering
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEP 6: CLUSTERING")
+    logger.info("=" * 60)
+
+    adata = clustering_task(
+        adata=adata,
+        checkpoint_file=checkpoint_dir
+        / bids_checkpoint_name(dataset_name, 6, "clustered"),
+        resolution=1.0,
+        figure_dir=figure_dir,
+        force=force[6],
+    )
+
+    # =========================================================================
+    # STEP 7: Pseudobulking
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEP 7: PSEUDOBULKING")
+    logger.info("=" * 60)
+
+    # Load step 3 checkpoint for raw counts
+    step3_checkpoint = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc")
+    adata_raw_counts = load_checkpoint(step3_checkpoint)
+    logger.info(f"Loaded raw counts from step 3: {adata_raw_counts.shape}")
+
+    pb_adata = pseudobulk_task(
+        adata=adata_raw_counts,
+        checkpoint_file=checkpoint_dir
+        / bids_checkpoint_name(dataset_name, 7, "pseudobulk"),
+        group_col="cell_type",
+        donor_col="donor_id",
+        metadata_cols=["development_stage", "sex"],
+        min_cells=10,
+        figure_dir=figure_dir,
+        layer=None,  # Use .X directly (raw counts)
+        force=force[7],
+    )
+
+    # =========================================================================
+    # STEPS 8-11: Per-Cell-Type Analysis (Parallel)
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("STEPS 8-11: PER-CELL-TYPE ANALYSIS")
+    logger.info("=" * 60)
+
+    # Get all cell types from pseudobulk
+    cell_types = pb_adata.obs["cell_type"].unique().tolist()
+    logger.info(f"Found {len(cell_types)} cell types to analyze")
+
+    # Filter cell types with insufficient samples
+    cell_type_counts = pb_adata.obs["cell_type"].value_counts()
+    valid_cell_types = [
+        ct for ct in cell_types if cell_type_counts[ct] >= min_samples_per_cell_type
+    ]
+    skipped_cell_types = [ct for ct in cell_types if ct not in valid_cell_types]
+
+    if skipped_cell_types:
+        logger.warning(
+            f"Skipping {len(skipped_cell_types)} cell types with < {min_samples_per_cell_type} samples: "
+            f"{skipped_cell_types}"
+        )
+
+    logger.info(f"Analyzing {len(valid_cell_types)} cell types")
+
+    # Step 8: Submit all DE tasks in parallel
+    logger.info("Submitting differential expression tasks...")
+    de_futures = {}
+    for cell_type in valid_cell_types:
+        de_futures[cell_type] = differential_expression_task.submit(
+            pb_adata=pb_adata,
+            cell_type=cell_type,
+            var_to_feature=var_to_feature,
+            output_dir=results_dir,
+            design_factors=["age_scaled", "sex"],
+            n_cpus=4,  # Reduced per-task to allow parallelism
+        )
+
+    # Steps 9-11: Submit pathway/enrichment/prediction tasks as DE completes
+    gsea_futures = {}
+    enrichr_futures = {}
+    prediction_futures = {}
+
+    for cell_type in valid_cell_types:
+        # Wait for DE to complete for this cell type
+        de_result = de_futures[cell_type].result()
+
+        # Get metadata for this cell type (for predictive modeling)
+        pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
+        pb_adata_ct.obs["age"] = (
+            pb_adata_ct.obs["development_stage"]
+            .str.extract(r"(\d+)-year-old")[0]
+            .astype(float)
+        )
+        metadata_ct = pb_adata_ct.obs.copy()
+
+        # Submit steps 9, 10, 11 in parallel for this cell type
+        gsea_futures[cell_type] = pathway_analysis_task.submit(
+            de_results=de_result["de_results"],
+            cell_type=cell_type,
+            output_dir=results_dir,
+            gene_sets=["MSigDB_Hallmark_2020"],
+            n_top=10,
+        )
+
+        enrichr_futures[cell_type] = overrepresentation_task.submit(
+            de_results=de_result["de_results"],
+            cell_type=cell_type,
+            output_dir=results_dir,
+            gene_sets=["MSigDB_Hallmark_2020"],
+            padj_threshold=0.05,
+            n_top=10,
+        )
+
+        prediction_futures[cell_type] = predictive_modeling_task.submit(
+            counts_df=de_result["counts_df"],
+            metadata=metadata_ct,
+            cell_type=cell_type,
+            output_dir=results_dir,
+            n_splits=5,
+        )
+
+    # Collect all results
+    logger.info("Collecting results...")
+    all_results = {
+        "adata": adata,
+        "pb_adata": pb_adata,
+        "per_cell_type": {},
+    }
+
+    for cell_type in valid_cell_types:
+        try:
+            all_results["per_cell_type"][cell_type] = {
+                "de": de_futures[cell_type].result(),
+                "gsea": gsea_futures[cell_type].result(),
+                "enrichment": enrichr_futures[cell_type].result(),
+                "prediction": prediction_futures[cell_type].result(),
+            }
+            logger.info(f"Completed analysis for: {cell_type}")
+        except Exception as e:
+            logger.error(f"Failed analysis for {cell_type}: {e}")
+            all_results["per_cell_type"][cell_type] = {"error": str(e)}
+
+    # =========================================================================
+    # Summary
+    # =========================================================================
+    logger.info("=" * 60)
+    logger.info("WORKFLOW COMPLETE")
+    logger.info("=" * 60)
+
+    successful = sum(
+        1
+        for ct_results in all_results["per_cell_type"].values()
+        if "error" not in ct_results
+    )
+    failed = len(valid_cell_types) - successful
+
+    logger.info(
+        f"Successfully analyzed: {successful}/{len(valid_cell_types)} cell types"
+    )
+    if failed > 0:
+        logger.warning(f"Failed: {failed} cell types")
+
+    logger.info(f"Figures saved to: {figure_dir}")
+    logger.info(f"Checkpoints saved to: {checkpoint_dir}")
+    logger.info(f"Per-cell-type results saved to: {results_dir}")
+
+    return all_results
+
+
+@flow(name="analyze_single_cell_type", log_prints=True)
+def analyze_single_cell_type(
+    datadir: Path,
+    cell_type: str,
+    dataset_name: str = "OneK1K",
+) -> dict[str, Any]:
+    """Run analysis for a single cell type (useful for debugging/testing).
+
+    Requires that steps 1-7 have already been run.
+
+    Parameters
+    ----------
+    datadir : Path
+        Base directory for data files
+    cell_type : str
+        Cell type to analyze
+    dataset_name : str
+        Name of the dataset
+
+    Returns
+    -------
+    dict
+        Results for the specified cell type
+    """
+    logger = get_run_logger()
+
+    checkpoint_dir = datadir / "workflow/checkpoints"
+    results_dir = datadir / "workflow/results/per_cell_type"
+    results_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load required checkpoints
+    pb_adata = load_checkpoint(
+        checkpoint_dir / bids_checkpoint_name(dataset_name, 7, "pseudobulk")
+    )
+    adata_filtered = load_checkpoint(
+        checkpoint_dir / bids_checkpoint_name(dataset_name, 2, "filtered")
+    )
+    var_to_feature = dict(
+        zip(adata_filtered.var_names, adata_filtered.var["feature_name"])
+    )
+
+    # Verify cell type exists
+    available_cell_types = pb_adata.obs["cell_type"].unique().tolist()
+    if cell_type not in available_cell_types:
+        raise ValueError(
+            f"Cell type '{cell_type}' not found. Available: {available_cell_types}"
+        )
+
+    logger.info(f"Analyzing cell type: {cell_type}")
+
+    # Run DE
+    de_result = differential_expression_task(
+        pb_adata=pb_adata,
+        cell_type=cell_type,
+        var_to_feature=var_to_feature,
+        output_dir=results_dir,
+    )
+
+    # Get metadata
+    pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
+    pb_adata_ct.obs["age"] = (
+        pb_adata_ct.obs["development_stage"]
+        .str.extract(r"(\d+)-year-old")[0]
+        .astype(float)
+    )
+    metadata_ct = pb_adata_ct.obs.copy()
+
+    # Run parallel tasks
+    gsea_future = pathway_analysis_task.submit(
+        de_results=de_result["de_results"],
+        cell_type=cell_type,
+        output_dir=results_dir,
+    )
+
+    enrichr_future = overrepresentation_task.submit(
+        de_results=de_result["de_results"],
+        cell_type=cell_type,
+        output_dir=results_dir,
+    )
+
+    prediction_future = predictive_modeling_task.submit(
+        counts_df=de_result["counts_df"],
+        metadata=metadata_ct,
+        cell_type=cell_type,
+        output_dir=results_dir,
+    )
+
+    return {
+        "cell_type": cell_type,
+        "de": de_result,
+        "gsea": gsea_future.result(),
+        "enrichment": enrichr_future.result(),
+        "prediction": prediction_future.result(),
+    }
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
new file mode 100644
index 0000000..bc5e8ff
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
@@ -0,0 +1,177 @@
+"""Entry point for running the Prefect-based scRNA-seq workflow.
+
+Usage:
+    python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow
+
+Or with arguments:
+    python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --force-from 8
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from BetterCodeBetterScience.rnaseq.prefect_workflow.flows import (
+    analyze_single_cell_type,
+    run_workflow,
+)
+
+
+def main():
+    """Run the Prefect workflow."""
+    parser = argparse.ArgumentParser(
+        description="Run the immune aging scRNA-seq workflow with Prefect"
+    )
+    parser.add_argument(
+        "--datadir",
+        type=Path,
+        default=None,
+        help="Base directory for data files (default: from DATADIR env var)",
+    )
+    parser.add_argument(
+        "--dataset-name",
+        type=str,
+        default="OneK1K",
+        help="Name of the dataset (default: OneK1K)",
+    )
+    parser.add_argument(
+        "--force-from",
+        type=int,
+        default=None,
+        dest="force_from_step",
+        help="Force re-run from this step onwards (1-11)",
+    )
+    parser.add_argument(
+        "--min-samples",
+        type=int,
+        default=10,
+        dest="min_samples",
+        help="Minimum samples per cell type for steps 8-11 (default: 10)",
+    )
+    parser.add_argument(
+        "--cell-type",
+        type=str,
+        default=None,
+        dest="cell_type",
+        help="Run analysis for a single cell type only (requires prior completion of steps 1-7)",
+    )
+    parser.add_argument(
+        "--list-cell-types",
+        action="store_true",
+        dest="list_cell_types",
+        help="List available cell types and exit",
+    )
+
+    args = parser.parse_args()
+
+    # Load environment variables
+    load_dotenv()
+
+    # Get data directory
+    if args.datadir is not None:
+        datadir = args.datadir
+    else:
+        datadir_env = os.getenv("DATADIR")
+        if datadir_env is None:
+            raise ValueError(
+                "DATADIR environment variable not set. "
+                "Set it or use --datadir argument."
+            )
+        datadir = Path(datadir_env) / "immune_aging"
+
+    print(f"Data directory: {datadir}")
+
+    # List cell types if requested
+    if args.list_cell_types:
+        from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+            bids_checkpoint_name,
+            load_checkpoint,
+        )
+
+        checkpoint_dir = datadir / "workflow/checkpoints"
+        pb_checkpoint = checkpoint_dir / bids_checkpoint_name(
+            args.dataset_name, 7, "pseudobulk"
+        )
+
+        if not pb_checkpoint.exists():
+            print(f"Pseudobulk checkpoint not found: {pb_checkpoint}")
+            print("Run steps 1-7 first to generate pseudobulk data.")
+            return
+
+        pb_adata = load_checkpoint(pb_checkpoint)
+        cell_types = pb_adata.obs["cell_type"].unique().tolist()
+        cell_type_counts = pb_adata.obs["cell_type"].value_counts()
+
+        print(f"\nAvailable cell types ({len(cell_types)} total):")
+        print("-" * 60)
+        for ct in sorted(cell_types):
+            count = cell_type_counts[ct]
+            status = (
+                "OK" if count >= args.min_samples else f"< {args.min_samples} samples"
+            )
+            print(f"  {ct}: {count} samples ({status})")
+        return
+
+    # Run single cell type analysis
+    if args.cell_type is not None:
+        print(f"\nRunning analysis for single cell type: {args.cell_type}")
+        results = analyze_single_cell_type(
+            datadir=datadir,
+            cell_type=args.cell_type,
+            dataset_name=args.dataset_name,
+        )
+        print("\nResults:")
+        print(f"  DE genes: {len(results['de']['de_results'])}")
+        if results["gsea"]["gsea_results"] is not None:
+            print(f"  GSEA pathways: {len(results['gsea']['gsea_results'].res2d)}")
+        if results["prediction"]["prediction_results"]:
+            pred = results["prediction"]["prediction_results"]
+            import numpy as np
+
+            print(f"  Prediction R2: {np.mean(pred['full_r2']):.3f}")
+            print(f"  Prediction MAE: {np.mean(pred['full_mae']):.2f} years")
+        return
+
+    # Run full workflow
+    print("\nRunning full workflow...")
+    if args.force_from_step:
+        print(f"Forcing re-run from step {args.force_from_step}")
+
+    results = run_workflow(
+        datadir=datadir,
+        dataset_name=args.dataset_name,
+        force_from_step=args.force_from_step,
+        min_samples_per_cell_type=args.min_samples,
+    )
+
+    # Print summary
+    print("\n" + "=" * 60)
+    print("RESULTS SUMMARY")
+    print("=" * 60)
+
+    successful_cell_types = [
+        ct for ct, res in results["per_cell_type"].items() if "error" not in res
+    ]
+
+    print(f"Analyzed {len(successful_cell_types)} cell types:")
+    for ct in sorted(successful_cell_types):
+        ct_res = results["per_cell_type"][ct]
+        de_count = len(ct_res["de"]["de_results"])
+        sig_genes = (ct_res["de"]["de_results"]["padj"] < 0.05).sum()
+        print(f"  {ct}:")
+        print(f"    - DE genes tested: {de_count}")
+        print(f"    - Significant (padj<0.05): {sig_genes}")
+
+    failed_cell_types = [
+        ct for ct, res in results["per_cell_type"].items() if "error" in res
+    ]
+    if failed_cell_types:
+        print(f"\nFailed cell types ({len(failed_cell_types)}):")
+        for ct in failed_cell_types:
+            print(f"  {ct}: {results['per_cell_type'][ct]['error']}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/tasks.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/tasks.py
new file mode 100644
index 0000000..b0c7c83
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/tasks.py
@@ -0,0 +1,376 @@
+"""Prefect task definitions for scRNA-seq workflow.
+
+Wraps modular workflow functions as Prefect tasks for orchestration.
+"""
+
+from pathlib import Path
+from typing import Any
+
+import anndata as ad
+import pandas as pd
+from prefect import task
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import (
+    run_clustering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import (
+    run_filtering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import (
+    download_data,
+    load_lazy_anndata,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import (
+    run_differential_expression_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import (
+    run_dimensionality_reduction_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import (
+    run_overrepresentation_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import (
+    run_gsea_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import (
+    run_predictive_modeling_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import (
+    run_preprocessing_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import (
+    run_pseudobulk_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import (
+    run_qc_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+@task(name="download_data", retries=2, retry_delay_seconds=30)
+def download_data_task(datafile: Path, url: str) -> Path:
+    """Download data file if it doesn't exist.
+
+    Returns the datafile path for chaining.
+    """
+    download_data(datafile, url)
+    return datafile
+
+
+@task(name="load_and_filter")
+def load_and_filter_task(
+    datafile: Path,
+    checkpoint_file: Path,
+    cutoff_percentile: float = 1.0,
+    min_cells_per_celltype: int = 10,
+    percent_donors: float = 0.95,
+    figure_dir: Path | None = None,
+    force: bool = False,
+) -> ad.AnnData:
+    """Load data and run filtering pipeline with checkpointing."""
+    if checkpoint_file.exists() and not force:
+        print(f"Loading from checkpoint: {checkpoint_file.name}")
+        return load_checkpoint(checkpoint_file)
+
+    adata = load_lazy_anndata(datafile)
+    print(f"Loaded dataset: {adata}")
+    adata = run_filtering_pipeline(
+        adata,
+        cutoff_percentile=cutoff_percentile,
+        min_cells_per_celltype=min_cells_per_celltype,
+        percent_donors=percent_donors,
+        figure_dir=figure_dir,
+    )
+    save_checkpoint(adata, checkpoint_file)
+    return adata
+
+
+@task(name="quality_control")
+def quality_control_task(
+    adata: ad.AnnData,
+    checkpoint_file: Path,
+    min_genes: int = 200,
+    max_genes: int = 6000,
+    min_counts: int = 500,
+    max_counts: int = 30000,
+    max_hb_pct: float = 5.0,
+    expected_doublet_rate: float = 0.06,
+    figure_dir: Path | None = None,
+    force: bool = False,
+) -> ad.AnnData:
+    """Run quality control pipeline with checkpointing."""
+    if checkpoint_file.exists() and not force:
+        print(f"Loading from checkpoint: {checkpoint_file.name}")
+        return load_checkpoint(checkpoint_file)
+
+    adata = run_qc_pipeline(
+        adata,
+        min_genes=min_genes,
+        max_genes=max_genes,
+        min_counts=min_counts,
+        max_counts=max_counts,
+        max_hb_pct=max_hb_pct,
+        expected_doublet_rate=expected_doublet_rate,
+        figure_dir=figure_dir,
+    )
+    save_checkpoint(adata, checkpoint_file)
+    return adata
+
+
+@task(name="preprocessing")
+def preprocessing_task(
+    adata: ad.AnnData,
+    checkpoint_file: Path,
+    target_sum: float = 1e4,
+    n_top_genes: int = 3000,
+    batch_key: str = "donor_id",
+    force: bool = False,
+) -> ad.AnnData:
+    """Run preprocessing pipeline with checkpointing."""
+    if checkpoint_file.exists() and not force:
+        print(f"Loading from checkpoint: {checkpoint_file.name}")
+        return load_checkpoint(checkpoint_file)
+
+    adata = run_preprocessing_pipeline(
+        adata,
+        target_sum=target_sum,
+        n_top_genes=n_top_genes,
+        batch_key=batch_key,
+    )
+    # Remove counts layer after preprocessing to save space
+    if "counts" in adata.layers:
+        del adata.layers["counts"]
+        print("Removed counts layer to save checkpoint space")
+
+    save_checkpoint(adata, checkpoint_file)
+    return adata
+
+
+@task(name="dimensionality_reduction")
+def dimensionality_reduction_task(
+    adata: ad.AnnData,
+    checkpoint_file: Path,
+    batch_key: str = "donor_id",
+    n_neighbors: int = 30,
+    n_pcs: int = 40,
+    figure_dir: Path | None = None,
+    force: bool = False,
+) -> ad.AnnData:
+    """Run dimensionality reduction pipeline with checkpointing."""
+    if checkpoint_file.exists() and not force:
+        print(f"Loading from checkpoint: {checkpoint_file.name}")
+        return load_checkpoint(checkpoint_file)
+
+    adata = run_dimensionality_reduction_pipeline(
+        adata,
+        batch_key=batch_key,
+        n_neighbors=n_neighbors,
+        n_pcs=n_pcs,
+        figure_dir=figure_dir,
+    )
+    save_checkpoint(adata, checkpoint_file)
+    return adata
+
+
+@task(name="clustering")
+def clustering_task(
+    adata: ad.AnnData,
+    checkpoint_file: Path,
+    resolution: float = 1.0,
+    figure_dir: Path | None = None,
+    force: bool = False,
+) -> ad.AnnData:
+    """Run clustering pipeline with checkpointing."""
+    if checkpoint_file.exists() and not force:
+        print(f"Loading from checkpoint: {checkpoint_file.name}")
+        return load_checkpoint(checkpoint_file)
+
+    adata = run_clustering_pipeline(
+        adata,
+        resolution=resolution,
+        figure_dir=figure_dir,
+    )
+    save_checkpoint(adata, checkpoint_file)
+    return adata
+
+
+@task(name="pseudobulk")
+def pseudobulk_task(
+    adata: ad.AnnData,
+    checkpoint_file: Path,
+    group_col: str = "cell_type",
+    donor_col: str = "donor_id",
+    metadata_cols: list[str] | None = None,
+    min_cells: int = 10,
+    figure_dir: Path | None = None,
+    layer: str | None = None,
+    force: bool = False,
+) -> ad.AnnData:
+    """Run pseudobulking pipeline with checkpointing."""
+    if checkpoint_file.exists() and not force:
+        print(f"Loading from checkpoint: {checkpoint_file.name}")
+        return load_checkpoint(checkpoint_file)
+
+    pb_adata = run_pseudobulk_pipeline(
+        adata,
+        group_col=group_col,
+        donor_col=donor_col,
+        metadata_cols=metadata_cols,
+        min_cells=min_cells,
+        figure_dir=figure_dir,
+        layer=layer,
+    )
+    save_checkpoint(pb_adata, checkpoint_file)
+    return pb_adata
+
+
+@task(name="differential_expression", retries=1)
+def differential_expression_task(
+    pb_adata: ad.AnnData,
+    cell_type: str,
+    var_to_feature: dict[str, str],
+    output_dir: Path,
+    design_factors: list[str] | None = None,
+    n_cpus: int = 8,
+) -> dict[str, Any]:
+    """Run differential expression for a specific cell type.
+
+    Returns dict with stat_res, de_results, and counts_df.
+    """
+    print(f"\n{'=' * 60}")
+    print(f"Running DE for cell type: {cell_type}")
+    print(f"{'=' * 60}")
+
+    stat_res, de_results, counts_df = run_differential_expression_pipeline(
+        pb_adata,
+        cell_type=cell_type,
+        design_factors=design_factors,
+        var_to_feature=var_to_feature,
+        n_cpus=n_cpus,
+    )
+
+    # Save results to cell-type specific directory
+    ct_dir = output_dir / _sanitize_cell_type(cell_type)
+    ct_dir.mkdir(parents=True, exist_ok=True)
+
+    save_checkpoint(stat_res, ct_dir / "stat_res.pkl")
+    de_results.to_parquet(ct_dir / "de_results.parquet")
+    counts_df.to_parquet(ct_dir / "counts.parquet")
+
+    return {
+        "cell_type": cell_type,
+        "stat_res": stat_res,
+        "de_results": de_results,
+        "counts_df": counts_df,
+    }
+
+
+@task(name="pathway_analysis")
+def pathway_analysis_task(
+    de_results: pd.DataFrame,
+    cell_type: str,
+    output_dir: Path,
+    gene_sets: list[str] | None = None,
+    n_top: int = 10,
+) -> dict[str, Any]:
+    """Run GSEA pathway analysis for a cell type."""
+    print(f"\n{'=' * 60}")
+    print(f"Running GSEA for cell type: {cell_type}")
+    print(f"{'=' * 60}")
+
+    ct_dir = output_dir / _sanitize_cell_type(cell_type)
+    ct_dir.mkdir(parents=True, exist_ok=True)
+    figure_dir = ct_dir / "figures"
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    gsea_results = run_gsea_pipeline(
+        de_results,
+        gene_sets=gene_sets,
+        n_top=n_top,
+        figure_dir=figure_dir,
+    )
+
+    save_checkpoint(gsea_results, ct_dir / "gsea_results.pkl")
+
+    return {
+        "cell_type": cell_type,
+        "gsea_results": gsea_results,
+    }
+
+
+@task(name="overrepresentation")
+def overrepresentation_task(
+    de_results: pd.DataFrame,
+    cell_type: str,
+    output_dir: Path,
+    gene_sets: list[str] | None = None,
+    padj_threshold: float = 0.05,
+    n_top: int = 10,
+) -> dict[str, Any]:
+    """Run Enrichr overrepresentation analysis for a cell type."""
+    print(f"\n{'=' * 60}")
+    print(f"Running Enrichr for cell type: {cell_type}")
+    print(f"{'=' * 60}")
+
+    ct_dir = output_dir / _sanitize_cell_type(cell_type)
+    ct_dir.mkdir(parents=True, exist_ok=True)
+    figure_dir = ct_dir / "figures"
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    enr_up, enr_down = run_overrepresentation_pipeline(
+        de_results,
+        gene_sets=gene_sets,
+        padj_threshold=padj_threshold,
+        n_top=n_top,
+        figure_dir=figure_dir,
+    )
+
+    save_checkpoint(enr_up, ct_dir / "enrichr_up.pkl")
+    save_checkpoint(enr_down, ct_dir / "enrichr_down.pkl")
+
+    return {
+        "cell_type": cell_type,
+        "enr_up": enr_up,
+        "enr_down": enr_down,
+    }
+
+
+@task(name="predictive_modeling")
+def predictive_modeling_task(
+    counts_df: pd.DataFrame,
+    metadata: pd.DataFrame,
+    cell_type: str,
+    output_dir: Path,
+    n_splits: int = 5,
+) -> dict[str, Any]:
+    """Run predictive modeling for a cell type."""
+    print(f"\n{'=' * 60}")
+    print(f"Running predictive modeling for cell type: {cell_type}")
+    print(f"{'=' * 60}")
+
+    ct_dir = output_dir / _sanitize_cell_type(cell_type)
+    ct_dir.mkdir(parents=True, exist_ok=True)
+    figure_dir = ct_dir / "figures"
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    prediction_results = run_predictive_modeling_pipeline(
+        counts_df,
+        metadata,
+        n_splits=n_splits,
+        figure_dir=figure_dir,
+    )
+
+    save_checkpoint(prediction_results, ct_dir / "prediction_results.pkl")
+
+    return {
+        "cell_type": cell_type,
+        "prediction_results": prediction_results,
+    }
+
+
+def _sanitize_cell_type(cell_type: str) -> str:
+    """Sanitize cell type name for use as directory name."""
+    return cell_type.replace(" ", "_").replace(",", "").replace("-", "_")
diff --git a/uv.lock b/uv.lock
index 996c206..5ab0f7a 100644
--- a/uv.lock
+++ b/uv.lock
@@ -85,6 +85,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
 ]
 
+[[package]]
+name = "aiosqlite"
+version = "0.22.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/0d/449c024bdabd0678ae07d804e60ed3b9786facd3add66f51eee67a0fccea/aiosqlite-0.22.0.tar.gz", hash = "sha256:7e9e52d72b319fcdeac727668975056c49720c995176dc57370935e5ba162bb9", size = 14707, upload-time = "2025-12-13T18:32:45.762Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/39/b2181148075272edfbbd6d87e6cd78cc71dca243446fa3b381fd4116950b/aiosqlite-0.22.0-py3-none-any.whl", hash = "sha256:96007fac2ce70eda3ca1bba7a3008c435258a592b8fbf2ee3eeaa36d33971a09", size = 17263, upload-time = "2025-12-13T18:32:44.619Z" },
+]
+
 [[package]]
 name = "airium"
 version = "0.2.7"
@@ -103,6 +112,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/34/d4e1c02d3bee589efb5dfa17f88ea08bdb3e3eac12bc475462aec52ed223/alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92", size = 13511, upload-time = "2024-01-10T00:56:08.388Z" },
 ]
 
+[[package]]
+name = "alembic"
+version = "1.17.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mako" },
+    { name = "sqlalchemy" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/a6/74c8cadc2882977d80ad756a13857857dbcf9bd405bc80b662eb10651282/alembic-1.17.2.tar.gz", hash = "sha256:bbe9751705c5e0f14877f02d46c53d10885e377e3d90eda810a016f9baa19e8e", size = 1988064, upload-time = "2025-11-14T20:35:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/88/6237e97e3385b57b5f1528647addea5cc03d4d65d5979ab24327d41fb00d/alembic-1.17.2-py3-none-any.whl", hash = "sha256:f483dd1fe93f6c5d49217055e4d15b905b425b6af906746abb35b69c1996c4e6", size = 248554, upload-time = "2025-11-14T20:35:05.699Z" },
+]
+
 [[package]]
 name = "anndata"
 version = "0.12.7"
@@ -212,6 +235,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" },
 ]
 
+[[package]]
+name = "apprise"
+version = "1.9.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "click" },
+    { name = "markdown" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "requests-oauthlib" },
+    { name = "tzdata", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/a7/bb182d81f35c3fe405505f0976da4b74f942cfdd53c7193b0fe50412aa27/apprise-1.9.6.tar.gz", hash = "sha256:4206be9cb5694a3d08dd8e0393bbb9b36212ac3a7769c2633620055e75c6caef", size = 1921714, upload-time = "2025-12-07T19:24:30.587Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/df/343d125241f8cd3c9af58fd09688cf2bf59cc1edfd609adafef3556ce8ec/apprise-1.9.6-py3-none-any.whl", hash = "sha256:2fd18e8a5251b6a12f6f9d169f1d895d458d1de36a5faee4db149cedcce51674", size = 1452059, upload-time = "2025-12-07T19:24:28.568Z" },
+]
+
 [[package]]
 name = "argon2-cffi"
 version = "25.1.0"
@@ -267,6 +308,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" },
 ]
 
+[[package]]
+name = "asgi-lifespan"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sniffio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6a/da/e7908b54e0f8043725a990bf625f2041ecf6bfe8eb7b19407f1c00b630f7/asgi-lifespan-2.1.0.tar.gz", hash = "sha256:5e2effaf0bfe39829cf2d64e7ecc47c7d86d676a6599f7afba378c31f5e3a308", size = 15627, upload-time = "2023-03-28T17:35:49.126Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/f5/c36551e93acba41a59939ae6a0fb77ddb3f2e8e8caa716410c65f7341f72/asgi_lifespan-2.1.0-py3-none-any.whl", hash = "sha256:ed840706680e28428c01e14afb3875d7d76d3206f3d5b2f2294e059b5c23804f", size = 10895, upload-time = "2023-03-28T17:35:47.772Z" },
+]
+
 [[package]]
 name = "asttokens"
 version = "3.0.1"
@@ -285,6 +338,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069, upload-time = "2025-03-16T17:25:35.422Z" },
 ]
 
+[[package]]
+name = "asyncpg"
+version = "0.31.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/cc/d18065ce2380d80b1bcce927c24a2642efd38918e33fd724bc4bca904877/asyncpg-0.31.0.tar.gz", hash = "sha256:c989386c83940bfbd787180f2b1519415e2d3d6277a70d9d0f0145ac73500735", size = 993667, upload-time = "2025-11-24T23:27:00.812Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/a6/59d0a146e61d20e18db7396583242e32e0f120693b67a8de43f1557033e2/asyncpg-0.31.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b44c31e1efc1c15188ef183f287c728e2046abb1d26af4d20858215d50d91fad", size = 662042, upload-time = "2025-11-24T23:25:49.578Z" },
+    { url = "https://files.pythonhosted.org/packages/36/01/ffaa189dcb63a2471720615e60185c3f6327716fdc0fc04334436fbb7c65/asyncpg-0.31.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0c89ccf741c067614c9b5fc7f1fc6f3b61ab05ae4aaa966e6fd6b93097c7d20d", size = 638504, upload-time = "2025-11-24T23:25:51.501Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/62/3f699ba45d8bd24c5d65392190d19656d74ff0185f42e19d0bbd973bb371/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:12b3b2e39dc5470abd5e98c8d3373e4b1d1234d9fbdedf538798b2c13c64460a", size = 3426241, upload-time = "2025-11-24T23:25:53.278Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d1/a867c2150f9c6e7af6462637f613ba67f78a314b00db220cd26ff559d532/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:aad7a33913fb8bcb5454313377cc330fbb19a0cd5faa7272407d8a0c4257b671", size = 3520321, upload-time = "2025-11-24T23:25:54.982Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1a/cce4c3f246805ecd285a3591222a2611141f1669d002163abef999b60f98/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3df118d94f46d85b2e434fd62c84cb66d5834d5a890725fe625f498e72e4d5ec", size = 3316685, upload-time = "2025-11-24T23:25:57.43Z" },
+    { url = "https://files.pythonhosted.org/packages/40/ae/0fc961179e78cc579e138fad6eb580448ecae64908f95b8cb8ee2f241f67/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bd5b6efff3c17c3202d4b37189969acf8927438a238c6257f66be3c426beba20", size = 3471858, upload-time = "2025-11-24T23:25:59.636Z" },
+    { url = "https://files.pythonhosted.org/packages/52/b2/b20e09670be031afa4cbfabd645caece7f85ec62d69c312239de568e058e/asyncpg-0.31.0-cp312-cp312-win32.whl", hash = "sha256:027eaa61361ec735926566f995d959ade4796f6a49d3bde17e5134b9964f9ba8", size = 527852, upload-time = "2025-11-24T23:26:01.084Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/f0/f2ed1de154e15b107dc692262395b3c17fc34eafe2a78fc2115931561730/asyncpg-0.31.0-cp312-cp312-win_amd64.whl", hash = "sha256:72d6bdcbc93d608a1158f17932de2321f68b1a967a13e014998db87a72ed3186", size = 597175, upload-time = "2025-11-24T23:26:02.564Z" },
+]
+
 [[package]]
 name = "attrs"
 version = "25.4.0"
@@ -425,6 +494,7 @@ dependencies = [
     { name = "pandas" },
     { name = "pickleshare" },
     { name = "pre-commit" },
+    { name = "prefect" },
     { name = "pyarrow" },
     { name = "pydeseq2" },
     { name = "pygithub" },
@@ -503,6 +573,7 @@ requires-dist = [
     { name = "pandas", specifier = ">=2.2.3" },
     { name = "pickleshare", specifier = ">=0.7.5" },
     { name = "pre-commit", specifier = ">=4.2.0" },
+    { name = "prefect", specifier = ">=3.0" },
     { name = "pyarrow", specifier = ">=22.0.0" },
     { name = "pydeseq2", specifier = ">=0.5.3" },
     { name = "pygithub", specifier = ">=2.4.0" },
@@ -714,11 +785,11 @@ wheels = [
 
 [[package]]
 name = "cachetools"
-version = "6.2.4"
+version = "5.5.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bc/1d/ede8680603f6016887c062a2cf4fc8fdba905866a3ab8831aa8aa651320c/cachetools-6.2.4.tar.gz", hash = "sha256:82c5c05585e70b6ba2d3ae09ea60b79548872185d2f24ae1f2709d37299fd607", size = 31731, upload-time = "2025-12-15T18:24:53.744Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380, upload-time = "2025-02-20T21:01:19.524Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/fc/1d7b80d0eb7b714984ce40efc78859c022cd930e402f599d8ca9e39c78a4/cachetools-6.2.4-py3-none-any.whl", hash = "sha256:69a7a52634fed8b8bf6e24a050fb60bff1c9bd8f6d24572b99c32d4e71e62a51", size = 11551, upload-time = "2025-12-15T18:24:52.332Z" },
+    { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080, upload-time = "2025-02-20T21:01:16.647Z" },
 ]
 
 [[package]]
@@ -883,14 +954,14 @@ wheels = [
 
 [[package]]
 name = "click"
-version = "8.3.1"
+version = "8.1.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" },
 ]
 
 [[package]]
@@ -985,6 +1056,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" },
 ]
 
+[[package]]
+name = "coolname"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c5/c6/1eaa4495ff4640e80d9af64f540e427ba1596a20f735d4c4750fe0386d07/coolname-2.2.0.tar.gz", hash = "sha256:6c5d5731759104479e7ca195a9b64f7900ac5bead40183c09323c7d0be9e75c7", size = 59006, upload-time = "2023-01-09T14:50:41.724Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/b1/5745d7523d8ce53b87779f46ef6cf5c5c342997939c2fe967e607b944e43/coolname-2.2.0-py2.py3-none-any.whl", hash = "sha256:4d1563186cfaf71b394d5df4c744f8c41303b6846413645e31d31915cdeb13e8", size = 37849, upload-time = "2023-01-09T14:50:39.897Z" },
+]
+
 [[package]]
 name = "coverage"
 version = "7.13.0"
@@ -1208,6 +1288,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/53/ee/e97f37023938022e38d3abb28058191025c7a2cb240210e7e016f21fee72/datalad_osf-0.3.0-py2.py3-none-any.whl", hash = "sha256:2cdc42ac3015d0734ac1f386a2f09fe2bfd2bad56e2035ebcce87a378b0ec209", size = 26384, upload-time = "2023-06-09T09:45:40.014Z" },
 ]
 
+[[package]]
+name = "dateparser"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "regex" },
+    { name = "tzlocal" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/30/064144f0df1749e7bb5faaa7f52b007d7c2d08ec08fed8411aba87207f68/dateparser-1.2.2.tar.gz", hash = "sha256:986316f17cb8cdc23ea8ce563027c5ef12fc725b6fb1d137c14ca08777c5ecf7", size = 329840, upload-time = "2025-06-26T09:29:23.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/22/f020c047ae1346613db9322638186468238bcfa8849b4668a22b97faad65/dateparser-1.2.2-py3-none-any.whl", hash = "sha256:5a5d7211a09013499867547023a2a0c91d5a27d15dd4dbcea676ea9fe66f2482", size = 315453, upload-time = "2025-06-26T09:29:21.412Z" },
+]
+
 [[package]]
 name = "debugpy"
 version = "1.8.19"
@@ -1371,6 +1466,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/26/b5/d343da782460999bd3e7c3c367b91d7b77f2eaf424bff7b315ce72bb4e54/eutils-0.6.1-py3-none-any.whl", hash = "sha256:6916efd10f397f20ba0e6bd5b84d4e868e077161509e240d7c4ab1d98fb2d3b1", size = 40910, upload-time = "2025-12-07T23:33:43.053Z" },
 ]
 
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
 [[package]]
 name = "executing"
 version = "2.2.1"
@@ -1720,6 +1827,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6c/79/3912a94cf27ec503e51ba493692d6db1e3cd8ac7ac52b0b47c8e33d7f4f9/greenlet-3.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a7a34b13d43a6b78abf828a6d0e87d3385680eaf830cd60d20d52f249faabf39", size = 301964, upload-time = "2025-12-04T14:36:58.316Z" },
 ]
 
+[[package]]
+name = "griffe"
+version = "1.15.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0d/0c/3a471b6e31951dce2360477420d0a8d1e00dea6cf33b70f3e8c3ab6e28e1/griffe-1.15.0.tar.gz", hash = "sha256:7726e3afd6f298fbc3696e67958803e7ac843c1cfe59734b6251a40cdbfb5eea", size = 424112, upload-time = "2025-11-10T15:03:15.52Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/83/3b1d03d36f224edded98e9affd0467630fc09d766c0e56fb1498cbb04a9b/griffe-1.15.0-py3-none-any.whl", hash = "sha256:6f6762661949411031f5fcda9593f586e6ce8340f0ba88921a0f2ef7a81eb9a3", size = 150705, upload-time = "2025-11-10T15:03:13.549Z" },
+]
+
 [[package]]
 name = "grpcio"
 version = "1.76.0"
@@ -1782,6 +1901,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
 ]
 
+[[package]]
+name = "h2"
+version = "4.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "hpack" },
+    { name = "hyperframe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026, upload-time = "2025-08-23T18:12:19.778Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/b2/119f6e6dcbd96f9069ce9a2665e0146588dc9f88f29549711853645e736a/h2-4.3.0-py3-none-any.whl", hash = "sha256:c438f029a25f7945c69e0ccf0fb951dc3f73a5f6412981daee861431b70e2bdd", size = 61779, upload-time = "2025-08-23T18:12:17.779Z" },
+]
+
 [[package]]
 name = "h5py"
 version = "3.15.1"
@@ -1857,6 +1989,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735, upload-time = "2025-10-24T19:04:35.928Z" },
 ]
 
+[[package]]
+name = "hpack"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/48/71de9ed269fdae9c8057e5a4c0aa7402e8bb16f2c6e90b3aa53327b113f8/hpack-4.1.0.tar.gz", hash = "sha256:ec5eca154f7056aa06f196a557655c5b009b382873ac8d1e66e79e87535f1dca", size = 51276, upload-time = "2025-01-22T21:44:58.347Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/c6/80c95b1b2b94682a72cbdbfb85b81ae2daffa4291fbfa1b1464502ede10d/hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496", size = 34357, upload-time = "2025-01-22T21:44:56.92Z" },
+]
+
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -1900,6 +2041,11 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
+[package.optional-dependencies]
+http2 = [
+    { name = "h2" },
+]
+
 [[package]]
 name = "huggingface-hub"
 version = "0.36.0"
@@ -1940,6 +2086,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c5/7b/bca5613a0c3b542420cf92bd5e5fb8ebd5435ce1011a091f66bb7693285e/humanize-4.15.0-py3-none-any.whl", hash = "sha256:b1186eb9f5a9749cd9cb8565aee77919dd7c8d076161cf44d70e59e3301e1769", size = 132203, upload-time = "2025-12-20T20:16:11.67Z" },
 ]
 
+[[package]]
+name = "hyperframe"
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566, upload-time = "2025-01-22T21:41:49.302Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007, upload-time = "2025-01-22T21:41:47.295Z" },
+]
+
 [[package]]
 name = "hypothesis"
 version = "6.148.7"
@@ -2254,6 +2409,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
 ]
 
+[[package]]
+name = "jinja2-humanize-extension"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "humanize" },
+    { name = "jinja2" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/77/0bba383819dd4e67566487c11c49479ced87e77c3285d8e7f7a3401cf882/jinja2_humanize_extension-0.4.0.tar.gz", hash = "sha256:e7d69b1c20f32815bbec722330ee8af14b1287bb1c2b0afa590dbf031cadeaa0", size = 4746, upload-time = "2023-09-01T12:52:42.781Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/b4/08c9d297edd5e1182506edecccbb88a92e1122a057953068cadac420ca5d/jinja2_humanize_extension-0.4.0-py3-none-any.whl", hash = "sha256:b6326e2da0f7d425338bebf58848e830421defbce785f12ae812e65128518156", size = 4769, upload-time = "2023-09-01T12:52:41.098Z" },
+]
+
 [[package]]
 name = "jiter"
 version = "0.12.0"
@@ -2352,6 +2520,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", hash = "sha256:185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55", size = 8701, upload-time = "2023-09-01T12:34:42.563Z" },
 ]
 
+[[package]]
+name = "jsonpatch"
+version = "1.33"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonpointer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699, upload-time = "2023-06-26T12:07:29.144Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/07/02e16ed01e04a374e644b575638ec7987ae846d25ad97bcc9945a3ee4b0e/jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade", size = 12898, upload-time = "2023-06-16T21:01:28.466Z" },
+]
+
 [[package]]
 name = "jsonpointer"
 version = "3.0.0"
@@ -2943,6 +3123,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ea/7b/93c73c67db235931527301ed3785f849c78991e2e34f3fd9a6663ffda4c5/lxml-6.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:61cb10eeb95570153e0c0e554f58df92ecf5109f75eacad4a95baa709e26c3d6", size = 3672836, upload-time = "2025-09-22T04:01:52.145Z" },
 ]
 
+[[package]]
+name = "mako"
+version = "1.3.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/7dd27d9d863b3376fcf23a5a13cb5d024aed1db46f963f1b5735ae43b3be/markdown-3.10.tar.gz", hash = "sha256:37062d4f2aa4b2b6b32aefb80faa300f82cc790cb949a35b8caede34f2b68c0e", size = 364931, upload-time = "2025-11-03T19:51:15.007Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/70/81/54e3ce63502cd085a0c556652a4e1b919c45a446bd1e5300e10c44c8c521/markdown-3.10-py3-none-any.whl", hash = "sha256:b5b99d6951e2e4948d939255596523444c0e677c669700b1d17aa4a8a464cb7c", size = 107678, upload-time = "2025-11-03T19:51:13.887Z" },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "4.0.0"
@@ -3927,11 +4128,11 @@ wheels = [
 
 [[package]]
 name = "packaging"
-version = "25.0"
+version = "24.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950, upload-time = "2024-11-08T09:47:47.202Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451, upload-time = "2024-11-08T09:47:44.722Z" },
 ]
 
 [[package]]
@@ -4034,6 +4235,29 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl", hash = "sha256:37bfddbc58fcf0362febb5f54f10743f8b21dd2aa73dec7e7ef59d1b02ae668a", size = 233301, upload-time = "2025-10-20T16:17:36.563Z" },
 ]
 
+[[package]]
+name = "pendulum"
+version = "3.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "python-dateutil" },
+    { name = "tzdata" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/7c/009c12b86c7cc6c403aec80f8a4308598dfc5995e5c523a5491faaa3952e/pendulum-3.1.0.tar.gz", hash = "sha256:66f96303560f41d097bee7d2dc98ffca716fbb3a832c4b3062034c2d45865015", size = 85930, upload-time = "2025-04-19T14:30:01.675Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/d7/b1bfe15a742f2c2713acb1fdc7dc3594ff46ef9418ac6a96fcb12a6ba60b/pendulum-3.1.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4dfd53e7583ccae138be86d6c0a0b324c7547df2afcec1876943c4d481cf9608", size = 336209, upload-time = "2025-04-19T14:01:27.815Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/87/0392da0c603c828b926d9f7097fbdddaafc01388cb8a00888635d04758c3/pendulum-3.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6a6e06a28f3a7d696546347805536f6f38be458cb79de4f80754430696bea9e6", size = 323130, upload-time = "2025-04-19T14:01:29.336Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/61/95f1eec25796be6dddf71440ee16ec1fd0c573fc61a73bd1ef6daacd529a/pendulum-3.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e68d6a51880708084afd8958af42dc8c5e819a70a6c6ae903b1c4bfc61e0f25", size = 341509, upload-time = "2025-04-19T14:01:31.1Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/7b/eb0f5e6aa87d5e1b467a1611009dbdc92f0f72425ebf07669bfadd8885a6/pendulum-3.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e3f1e5da39a7ea7119efda1dd96b529748c1566f8a983412d0908455d606942", size = 378674, upload-time = "2025-04-19T14:01:32.974Z" },
+    { url = "https://files.pythonhosted.org/packages/29/68/5a4c1b5de3e54e16cab21d2ec88f9cd3f18599e96cc90a441c0b0ab6b03f/pendulum-3.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e9af1e5eeddb4ebbe1b1c9afb9fd8077d73416ade42dd61264b3f3b87742e0bb", size = 436133, upload-time = "2025-04-19T14:01:34.349Z" },
+    { url = "https://files.pythonhosted.org/packages/87/5d/f7a1d693e5c0f789185117d5c1d5bee104f5b0d9fbf061d715fb61c840a8/pendulum-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20f74aa8029a42e327bfc150472e0e4d2358fa5d795f70460160ba81b94b6945", size = 351232, upload-time = "2025-04-19T14:01:35.669Z" },
+    { url = "https://files.pythonhosted.org/packages/30/77/c97617eb31f1d0554edb073201a294019b9e0a9bd2f73c68e6d8d048cd6b/pendulum-3.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:cf6229e5ee70c2660148523f46c472e677654d0097bec010d6730f08312a4931", size = 521562, upload-time = "2025-04-19T14:01:37.05Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/0d0ef3393303877e757b848ecef8a9a8c7627e17e7590af82d14633b2cd1/pendulum-3.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:350cabb23bf1aec7c7694b915d3030bff53a2ad4aeabc8c8c0d807c8194113d6", size = 523221, upload-time = "2025-04-19T14:01:38.444Z" },
+    { url = "https://files.pythonhosted.org/packages/99/f3/aefb579aa3cebd6f2866b205fc7a60d33e9a696e9e629024752107dc3cf5/pendulum-3.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:42959341e843077c41d47420f28c3631de054abd64da83f9b956519b5c7a06a7", size = 260502, upload-time = "2025-04-19T14:01:39.814Z" },
+    { url = "https://files.pythonhosted.org/packages/02/74/4332b5d6e34c63d4df8e8eab2249e74c05513b1477757463f7fdca99e9be/pendulum-3.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:006758e2125da2e624493324dfd5d7d1b02b0c44bc39358e18bf0f66d0767f5f", size = 253089, upload-time = "2025-04-19T14:01:41.171Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/23/e98758924d1b3aac11a626268eabf7f3cf177e7837c28d47bf84c64532d0/pendulum-3.1.0-py3-none-any.whl", hash = "sha256:f9178c2a8e291758ade1e8dd6371b1d26d08371b4c7730a6e9a3ef8b16ebae0f", size = 111799, upload-time = "2025-04-19T14:02:34.739Z" },
+]
+
 [[package]]
 name = "pexpect"
 version = "4.9.0"
@@ -4138,6 +4362,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" },
 ]
 
+[[package]]
+name = "prefect"
+version = "3.2.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiosqlite" },
+    { name = "alembic" },
+    { name = "anyio" },
+    { name = "apprise" },
+    { name = "asgi-lifespan" },
+    { name = "asyncpg" },
+    { name = "cachetools" },
+    { name = "click" },
+    { name = "cloudpickle" },
+    { name = "coolname" },
+    { name = "cryptography" },
+    { name = "dateparser" },
+    { name = "docker" },
+    { name = "exceptiongroup" },
+    { name = "fastapi" },
+    { name = "fsspec" },
+    { name = "graphviz" },
+    { name = "griffe" },
+    { name = "httpcore" },
+    { name = "httpx", extra = ["http2"] },
+    { name = "humanize" },
+    { name = "jinja2" },
+    { name = "jinja2-humanize-extension" },
+    { name = "jsonpatch" },
+    { name = "jsonschema" },
+    { name = "opentelemetry-api" },
+    { name = "orjson" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "pendulum" },
+    { name = "prometheus-client" },
+    { name = "pydantic" },
+    { name = "pydantic-core" },
+    { name = "pydantic-extra-types" },
+    { name = "pydantic-settings" },
+    { name = "python-dateutil" },
+    { name = "python-slugify" },
+    { name = "python-socks" },
+    { name = "pytz" },
+    { name = "pyyaml" },
+    { name = "readchar" },
+    { name = "rfc3339-validator" },
+    { name = "rich" },
+    { name = "ruamel-yaml" },
+    { name = "sniffio" },
+    { name = "sqlalchemy", extra = ["asyncio"] },
+    { name = "toml" },
+    { name = "typer" },
+    { name = "typing-extensions" },
+    { name = "ujson" },
+    { name = "uvicorn" },
+    { name = "websockets" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/9e/7009c09d4e6a09ff4ad35afa93d5dba901635dd2c8f8e09e1eca597b884d/prefect-3.2.7.tar.gz", hash = "sha256:e24c06acabc38a1062e8672f71fea8a61348e8619df8ce2a4749e7bbf0142b54", size = 5780087, upload-time = "2025-02-21T19:40:28.984Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/70/13eb4bb6a9224d07fb7893d2d970488a607445d9868aa2acaa034148cdd0/prefect-3.2.7-py3-none-any.whl", hash = "sha256:7c91097e1de68fd6bd6f22bdf883866b757a6b661437b3ba68727936187f1842", size = 6264722, upload-time = "2025-02-21T19:40:25.936Z" },
+]
+
 [[package]]
 name = "prefixcommons"
 version = "0.1.12"
@@ -4463,6 +4750,33 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
 ]
 
+[[package]]
+name = "pydantic-extra-types"
+version = "2.10.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/10/fb64987804cde41bcc39d9cd757cd5f2bb5d97b389d81aa70238b14b8a7e/pydantic_extra_types-2.10.6.tar.gz", hash = "sha256:c63d70bf684366e6bbe1f4ee3957952ebe6973d41e7802aea0b770d06b116aeb", size = 141858, upload-time = "2025-10-08T13:47:49.483Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/04/5c918669096da8d1c9ec7bb716bd72e755526103a61bc5e76a3e4fb23b53/pydantic_extra_types-2.10.6-py3-none-any.whl", hash = "sha256:6106c448316d30abf721b5b9fecc65e983ef2614399a24142d689c7546cc246a", size = 40949, upload-time = "2025-10-08T13:47:48.268Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.12.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" },
+]
+
 [[package]]
 name = "pydeseq2"
 version = "0.5.3"
@@ -4824,6 +5138,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548, upload-time = "2025-10-06T04:15:17.553Z" },
 ]
 
+[[package]]
+name = "python-slugify"
+version = "8.0.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "text-unidecode" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/87/c7/5e1547c44e31da50a460df93af11a535ace568ef89d7a811069ead340c4a/python-slugify-8.0.4.tar.gz", hash = "sha256:59202371d1d05b54a9e7720c5e038f928f45daaffe41dd10822f3907b937c856", size = 10921, upload-time = "2024-02-08T18:32:45.488Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl", hash = "sha256:276540b79961052b66b7d116620b36518847f52d5fd9e3a70164fc8c50faa6b8", size = 10051, upload-time = "2024-02-08T18:32:43.911Z" },
+]
+
+[[package]]
+name = "python-socks"
+version = "2.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/07/cfdd6a846ac859e513b4e68bb6c669a90a74d89d8d405516fba7fc9c6f0c/python_socks-2.8.0.tar.gz", hash = "sha256:340f82778b20a290bdd538ee47492978d603dff7826aaf2ce362d21ad9ee6f1b", size = 273130, upload-time = "2025-12-09T12:17:05.433Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/10/e2b575faa32d1d32e5e6041fc64794fa9f09526852a06b25353b66f52cae/python_socks-2.8.0-py3-none-any.whl", hash = "sha256:57c24b416569ccea493a101d38b0c82ed54be603aa50b6afbe64c46e4a4e4315", size = 55075, upload-time = "2025-12-09T12:17:03.269Z" },
+]
+
 [[package]]
 name = "pytz"
 version = "2025.2"
@@ -4943,6 +5278,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5f/97/d8a785d2c7131c731c90cb0e65af9400081af4380bea4ec04868dc21aa92/rdflib_shim-1.0.3-py3-none-any.whl", hash = "sha256:7a853e7750ef1e9bf4e35dea27d54e02d4ed087de5a9e0c329c4a6d82d647081", size = 5190, upload-time = "2021-12-21T16:31:05.719Z" },
 ]
 
+[[package]]
+name = "readchar"
+version = "4.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dd/f8/8657b8cbb4ebeabfbdf991ac40eca8a1d1bd012011bd44ad1ed10f5cb494/readchar-4.2.1.tar.gz", hash = "sha256:91ce3faf07688de14d800592951e5575e9c7a3213738ed01d394dcc949b79adb", size = 9685, upload-time = "2024-11-04T18:28:07.757Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/10/e4b1e0e5b6b6745c8098c275b69bc9d73e9542d5c7da4f137542b499ed44/readchar-4.2.1-py3-none-any.whl", hash = "sha256:a769305cd3994bb5fa2764aa4073452dc105a4ec39068ffe6efd3c20c60acc77", size = 9350, upload-time = "2024-11-04T18:28:02.859Z" },
+]
+
 [[package]]
 name = "referencing"
 version = "0.37.0"
@@ -5080,15 +5424,15 @@ wheels = [
 
 [[package]]
 name = "rich"
-version = "14.2.0"
+version = "13.9.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149, upload-time = "2024-11-01T16:43:57.873Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" },
+    { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424, upload-time = "2024-11-01T16:43:55.817Z" },
 ]
 
 [[package]]
@@ -5169,6 +5513,36 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload-time = "2025-04-16T09:51:17.142Z" },
 ]
 
+[[package]]
+name = "ruamel-yaml"
+version = "0.18.17"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ruamel-yaml-clib", marker = "platform_python_implementation == 'CPython'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/2b/7a1f1ebcd6b3f14febdc003e658778d81e76b40df2267904ee6b13f0c5c6/ruamel_yaml-0.18.17.tar.gz", hash = "sha256:9091cd6e2d93a3a4b157ddb8fabf348c3de7f1fb1381346d985b6b247dcd8d3c", size = 149602, upload-time = "2025-12-17T20:02:55.757Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/fe/b6045c782f1fd1ae317d2a6ca1884857ce5c20f59befe6ab25a8603c43a7/ruamel_yaml-0.18.17-py3-none-any.whl", hash = "sha256:9c8ba9eb3e793efdf924b60d521820869d5bf0cb9c6f1b82d82de8295e290b9d", size = 121594, upload-time = "2025-12-17T20:02:07.657Z" },
+]
+
+[[package]]
+name = "ruamel-yaml-clib"
+version = "0.2.15"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/97/60fda20e2fb54b83a61ae14648b0817c8f5d84a3821e40bfbdae1437026a/ruamel_yaml_clib-0.2.15.tar.gz", hash = "sha256:46e4cc8c43ef6a94885f72512094e482114a8a706d3c555a34ed4b0d20200600", size = 225794, upload-time = "2025-11-16T16:12:59.761Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/72/4b/5fde11a0722d676e469d3d6f78c6a17591b9c7e0072ca359801c4bd17eee/ruamel_yaml_clib-0.2.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb15a2e2a90c8475df45c0949793af1ff413acfb0a716b8b94e488ea95ce7cff", size = 149088, upload-time = "2025-11-16T16:13:22.836Z" },
+    { url = "https://files.pythonhosted.org/packages/85/82/4d08ac65ecf0ef3b046421985e66301a242804eb9a62c93ca3437dc94ee0/ruamel_yaml_clib-0.2.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:64da03cbe93c1e91af133f5bec37fd24d0d4ba2418eaf970d7166b0a26a148a2", size = 134553, upload-time = "2025-11-16T16:13:24.151Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/cb/22366d68b280e281a932403b76da7a988108287adff2bfa5ce881200107a/ruamel_yaml_clib-0.2.15-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f6d3655e95a80325b84c4e14c080b2470fe4f33b6846f288379ce36154993fb1", size = 737468, upload-time = "2025-11-16T20:22:47.335Z" },
+    { url = "https://files.pythonhosted.org/packages/71/73/81230babf8c9e33770d43ed9056f603f6f5f9665aea4177a2c30ae48e3f3/ruamel_yaml_clib-0.2.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71845d377c7a47afc6592aacfea738cc8a7e876d586dfba814501d8c53c1ba60", size = 753349, upload-time = "2025-11-16T16:13:26.269Z" },
+    { url = "https://files.pythonhosted.org/packages/61/62/150c841f24cda9e30f588ef396ed83f64cfdc13b92d2f925bb96df337ba9/ruamel_yaml_clib-0.2.15-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e5499db1ccbc7f4b41f0565e4f799d863ea720e01d3e99fa0b7b5fcd7802c9", size = 788211, upload-time = "2025-11-16T16:13:27.441Z" },
+    { url = "https://files.pythonhosted.org/packages/30/93/e79bd9cbecc3267499d9ead919bd61f7ddf55d793fb5ef2b1d7d92444f35/ruamel_yaml_clib-0.2.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4b293a37dc97e2b1e8a1aec62792d1e52027087c8eea4fc7b5abd2bdafdd6642", size = 743203, upload-time = "2025-11-16T16:13:28.671Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/06/1eb640065c3a27ce92d76157f8efddb184bd484ed2639b712396a20d6dce/ruamel_yaml_clib-0.2.15-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:512571ad41bba04eac7268fe33f7f4742210ca26a81fe0c75357fa682636c690", size = 747292, upload-time = "2025-11-16T20:22:48.584Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/21/ee353e882350beab65fcc47a91b6bdc512cace4358ee327af2962892ff16/ruamel_yaml_clib-0.2.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5e9f630c73a490b758bf14d859a39f375e6999aea5ddd2e2e9da89b9953486a", size = 771624, upload-time = "2025-11-16T16:13:29.853Z" },
+    { url = "https://files.pythonhosted.org/packages/57/34/cc1b94057aa867c963ecf9ea92ac59198ec2ee3a8d22a126af0b4d4be712/ruamel_yaml_clib-0.2.15-cp312-cp312-win32.whl", hash = "sha256:f4421ab780c37210a07d138e56dd4b51f8642187cdfb433eb687fe8c11de0144", size = 100342, upload-time = "2025-11-16T16:13:31.067Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/e5/8925a4208f131b218f9a7e459c0d6fcac8324ae35da269cb437894576366/ruamel_yaml_clib-0.2.15-cp312-cp312-win_amd64.whl", hash = "sha256:2b216904750889133d9222b7b873c199d48ecbb12912aca78970f84a5aa1a4bc", size = 119013, upload-time = "2025-11-16T16:13:32.164Z" },
+]
+
 [[package]]
 name = "ruff"
 version = "0.14.10"
@@ -5725,6 +6099,11 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/bf/e1/3ccb13c643399d22289c6a9786c1a91e3dcbb68bce4beb44926ac2c557bf/sqlalchemy-2.0.45-py3-none-any.whl", hash = "sha256:5225a288e4c8cc2308dbdd874edad6e7d0fd38eac1e9e5f23503425c8eee20d0", size = 1936672, upload-time = "2025-12-09T21:54:52.608Z" },
 ]
 
+[package.optional-dependencies]
+asyncio = [
+    { name = "greenlet" },
+]
+
 [[package]]
 name = "sqlalchemy-utils"
 version = "0.38.3"
@@ -5897,6 +6276,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" },
 ]
 
+[[package]]
+name = "text-unidecode"
+version = "1.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ab/e2/e9a00f0ccb71718418230718b3d900e71a5d16e701a3dae079a21e9cd8f8/text-unidecode-1.3.tar.gz", hash = "sha256:bad6603bb14d279193107714b288be206cac565dfa49aa5b105294dd5c4aab93", size = 76885, upload-time = "2019-08-30T21:36:45.405Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8", size = 78154, upload-time = "2019-08-30T21:37:03.543Z" },
+]
+
 [[package]]
 name = "texttable"
 version = "1.7.0"
@@ -5994,6 +6382,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/46/e33a8c93907b631a99377ef4c5f817ab453d0b34f93529421f42ff559671/tokenizers-0.22.1-cp39-abi3-win_amd64.whl", hash = "sha256:65fd6e3fb11ca1e78a6a93602490f134d1fdeb13bcef99389d5102ea318ed138", size = 2674684, upload-time = "2025-09-19T09:49:24.953Z" },
 ]
 
+[[package]]
+name = "toml"
+version = "0.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" },
+]
+
 [[package]]
 name = "tomli"
 version = "2.3.0"
@@ -6127,7 +6524,7 @@ wheels = [
 
 [[package]]
 name = "typer"
-version = "0.20.1"
+version = "0.15.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
@@ -6135,9 +6532,9 @@ dependencies = [
     { name = "shellingham" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6d/c1/933d30fd7a123ed981e2a1eedafceab63cb379db0402e438a13bc51bbb15/typer-0.20.1.tar.gz", hash = "sha256:68585eb1b01203689c4199bc440d6be616f0851e9f0eb41e4a778845c5a0fd5b", size = 105968, upload-time = "2025-12-19T16:48:56.302Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/89/c527e6c848739be8ceb5c44eb8208c52ea3515c6cf6406aa61932887bf58/typer-0.15.4.tar.gz", hash = "sha256:89507b104f9b6a0730354f27c39fae5b63ccd0c95b1ce1f1a6ba0cfd329997c3", size = 101559, upload-time = "2025-05-14T16:34:57.704Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/52/1f2df7e7d1be3d65ddc2936d820d4a3d9777a54f4204f5ca46b8513eff77/typer-0.20.1-py3-none-any.whl", hash = "sha256:4b3bde918a67c8e03d861aa02deca90a95bbac572e71b1b9be56ff49affdb5a8", size = 47381, upload-time = "2025-12-19T16:48:53.679Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/62/d4ba7afe2096d5659ec3db8b15d8665bdcb92a3c6ff0b95e99895b335a9c/typer-0.15.4-py3-none-any.whl", hash = "sha256:eb0651654dcdea706780c466cf06d8f174405a659ffff8f163cfbfee98c0e173", size = 45258, upload-time = "2025-05-14T16:34:55.583Z" },
 ]
 
 [[package]]
@@ -6195,6 +6592,25 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" },
 ]
 
+[[package]]
+name = "ujson"
+version = "5.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/d9/3f17e3c5773fb4941c68d9a37a47b1a79c9649d6c56aefbed87cc409d18a/ujson-5.11.0.tar.gz", hash = "sha256:e204ae6f909f099ba6b6b942131cee359ddda2b6e4ea39c12eb8b991fe2010e0", size = 7156583, upload-time = "2025-08-20T11:57:02.452Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/ef/a9cb1fce38f699123ff012161599fb9f2ff3f8d482b4b18c43a2dc35073f/ujson-5.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7895f0d2d53bd6aea11743bd56e3cb82d729980636cd0ed9b89418bf66591702", size = 55434, upload-time = "2025-08-20T11:55:34.987Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/05/dba51a00eb30bd947791b173766cbed3492269c150a7771d2750000c965f/ujson-5.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12b5e7e22a1fe01058000d1b317d3b65cc3daf61bd2ea7a2b76721fe160fa74d", size = 53190, upload-time = "2025-08-20T11:55:36.384Z" },
+    { url = "https://files.pythonhosted.org/packages/03/3c/fd11a224f73fbffa299fb9644e425f38b38b30231f7923a088dd513aabb4/ujson-5.11.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0180a480a7d099082501cad1fe85252e4d4bf926b40960fb3d9e87a3a6fbbc80", size = 57600, upload-time = "2025-08-20T11:55:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/55/b9/405103cae24899df688a3431c776e00528bd4799e7d68820e7ebcf824f92/ujson-5.11.0-cp312-cp312-manylinux_2_24_i686.manylinux_2_28_i686.whl", hash = "sha256:fa79fdb47701942c2132a9dd2297a1a85941d966d8c87bfd9e29b0cf423f26cc", size = 59791, upload-time = "2025-08-20T11:55:38.877Z" },
+    { url = "https://files.pythonhosted.org/packages/17/7b/2dcbc2bbfdbf68f2368fb21ab0f6735e872290bb604c75f6e06b81edcb3f/ujson-5.11.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8254e858437c00f17cb72e7a644fc42dad0ebb21ea981b71df6e84b1072aaa7c", size = 57356, upload-time = "2025-08-20T11:55:40.036Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/71/fea2ca18986a366c750767b694430d5ded6b20b6985fddca72f74af38a4c/ujson-5.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1aa8a2ab482f09f6c10fba37112af5f957689a79ea598399c85009f2f29898b5", size = 1036313, upload-time = "2025-08-20T11:55:41.408Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/bb/d4220bd7532eac6288d8115db51710fa2d7d271250797b0bfba9f1e755af/ujson-5.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a638425d3c6eed0318df663df44480f4a40dc87cc7c6da44d221418312f6413b", size = 1195782, upload-time = "2025-08-20T11:55:43.357Z" },
+    { url = "https://files.pythonhosted.org/packages/80/47/226e540aa38878ce1194454385701d82df538ccb5ff8db2cf1641dde849a/ujson-5.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7e3cff632c1d78023b15f7e3a81c3745cd3f94c044d1e8fa8efbd6b161997bbc", size = 1088817, upload-time = "2025-08-20T11:55:45.262Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/81/546042f0b23c9040d61d46ea5ca76f0cc5e0d399180ddfb2ae976ebff5b5/ujson-5.11.0-cp312-cp312-win32.whl", hash = "sha256:be6b0eaf92cae8cdee4d4c9e074bde43ef1c590ed5ba037ea26c9632fb479c88", size = 39757, upload-time = "2025-08-20T11:55:46.522Z" },
+    { url = "https://files.pythonhosted.org/packages/44/1b/27c05dc8c9728f44875d74b5bfa948ce91f6c33349232619279f35c6e817/ujson-5.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:b7b136cc6abc7619124fd897ef75f8e63105298b5ca9bdf43ebd0e1fa0ee105f", size = 43859, upload-time = "2025-08-20T11:55:47.987Z" },
+    { url = "https://files.pythonhosted.org/packages/22/2d/37b6557c97c3409c202c838aa9c960ca3896843b4295c4b7bb2bbd260664/ujson-5.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:6cd2df62f24c506a0ba322d5e4fe4466d47a9467b57e881ee15a31f7ecf68ff6", size = 38361, upload-time = "2025-08-20T11:55:49.122Z" },
+]
+
 [[package]]
 name = "umap-learn"
 version = "0.5.9.post2"

From def34e76500db8c3e26c93681548034d649e663b Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 09:44:17 -0800
Subject: [PATCH 45/87] Remove parallelization from Prefect workflow to reduce
 memory usage
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

All cell types are now processed sequentially:
- Steps 8-11 run one cell type at a time instead of in parallel
- analyze_single_cell_type also runs tasks sequentially
- Restored n_cpus=8 for DE since we're no longer parallelizing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/prefect_workflow/flows.py          | 144 +++++++++---------
 1 file changed, 68 insertions(+), 76 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
index a0b06f0..7f54095 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
@@ -37,8 +37,7 @@ def run_workflow(
 ) -> dict[str, Any]:
     """Run the complete immune aging scRNA-seq workflow with Prefect.
 
-    Steps 1-7 run sequentially (shared preprocessing).
-    Steps 8-11 run in parallel for each cell type.
+    All steps run sequentially to minimize memory usage.
 
     Parameters
     ----------
@@ -204,10 +203,10 @@ def run_workflow(
     )
 
     # =========================================================================
-    # STEPS 8-11: Per-Cell-Type Analysis (Parallel)
+    # STEPS 8-11: Per-Cell-Type Analysis (Sequential)
     # =========================================================================
     logger.info("=" * 60)
-    logger.info("STEPS 8-11: PER-CELL-TYPE ANALYSIS")
+    logger.info("STEPS 8-11: PER-CELL-TYPE ANALYSIS (SEQUENTIAL)")
     logger.info("=" * 60)
 
     # Get all cell types from pseudobulk
@@ -227,82 +226,75 @@ def run_workflow(
             f"{skipped_cell_types}"
         )
 
-    logger.info(f"Analyzing {len(valid_cell_types)} cell types")
-
-    # Step 8: Submit all DE tasks in parallel
-    logger.info("Submitting differential expression tasks...")
-    de_futures = {}
-    for cell_type in valid_cell_types:
-        de_futures[cell_type] = differential_expression_task.submit(
-            pb_adata=pb_adata,
-            cell_type=cell_type,
-            var_to_feature=var_to_feature,
-            output_dir=results_dir,
-            design_factors=["age_scaled", "sex"],
-            n_cpus=4,  # Reduced per-task to allow parallelism
-        )
-
-    # Steps 9-11: Submit pathway/enrichment/prediction tasks as DE completes
-    gsea_futures = {}
-    enrichr_futures = {}
-    prediction_futures = {}
-
-    for cell_type in valid_cell_types:
-        # Wait for DE to complete for this cell type
-        de_result = de_futures[cell_type].result()
-
-        # Get metadata for this cell type (for predictive modeling)
-        pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
-        pb_adata_ct.obs["age"] = (
-            pb_adata_ct.obs["development_stage"]
-            .str.extract(r"(\d+)-year-old")[0]
-            .astype(float)
-        )
-        metadata_ct = pb_adata_ct.obs.copy()
-
-        # Submit steps 9, 10, 11 in parallel for this cell type
-        gsea_futures[cell_type] = pathway_analysis_task.submit(
-            de_results=de_result["de_results"],
-            cell_type=cell_type,
-            output_dir=results_dir,
-            gene_sets=["MSigDB_Hallmark_2020"],
-            n_top=10,
-        )
-
-        enrichr_futures[cell_type] = overrepresentation_task.submit(
-            de_results=de_result["de_results"],
-            cell_type=cell_type,
-            output_dir=results_dir,
-            gene_sets=["MSigDB_Hallmark_2020"],
-            padj_threshold=0.05,
-            n_top=10,
-        )
+    logger.info(f"Analyzing {len(valid_cell_types)} cell types sequentially")
 
-        prediction_futures[cell_type] = predictive_modeling_task.submit(
-            counts_df=de_result["counts_df"],
-            metadata=metadata_ct,
-            cell_type=cell_type,
-            output_dir=results_dir,
-            n_splits=5,
-        )
-
-    # Collect all results
-    logger.info("Collecting results...")
+    # Initialize results
     all_results = {
         "adata": adata,
         "pb_adata": pb_adata,
         "per_cell_type": {},
     }
 
-    for cell_type in valid_cell_types:
+    # Process each cell type sequentially
+    for i, cell_type in enumerate(valid_cell_types):
+        logger.info(f"\n[{i + 1}/{len(valid_cell_types)}] Processing: {cell_type}")
+
         try:
+            # Step 8: Differential Expression
+            de_result = differential_expression_task(
+                pb_adata=pb_adata,
+                cell_type=cell_type,
+                var_to_feature=var_to_feature,
+                output_dir=results_dir,
+                design_factors=["age_scaled", "sex"],
+                n_cpus=8,
+            )
+
+            # Get metadata for this cell type (for predictive modeling)
+            pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
+            pb_adata_ct.obs["age"] = (
+                pb_adata_ct.obs["development_stage"]
+                .str.extract(r"(\d+)-year-old")[0]
+                .astype(float)
+            )
+            metadata_ct = pb_adata_ct.obs.copy()
+
+            # Step 9: Pathway Analysis (GSEA)
+            gsea_result = pathway_analysis_task(
+                de_results=de_result["de_results"],
+                cell_type=cell_type,
+                output_dir=results_dir,
+                gene_sets=["MSigDB_Hallmark_2020"],
+                n_top=10,
+            )
+
+            # Step 10: Overrepresentation Analysis (Enrichr)
+            enrichr_result = overrepresentation_task(
+                de_results=de_result["de_results"],
+                cell_type=cell_type,
+                output_dir=results_dir,
+                gene_sets=["MSigDB_Hallmark_2020"],
+                padj_threshold=0.05,
+                n_top=10,
+            )
+
+            # Step 11: Predictive Modeling
+            prediction_result = predictive_modeling_task(
+                counts_df=de_result["counts_df"],
+                metadata=metadata_ct,
+                cell_type=cell_type,
+                output_dir=results_dir,
+                n_splits=5,
+            )
+
             all_results["per_cell_type"][cell_type] = {
-                "de": de_futures[cell_type].result(),
-                "gsea": gsea_futures[cell_type].result(),
-                "enrichment": enrichr_futures[cell_type].result(),
-                "prediction": prediction_futures[cell_type].result(),
+                "de": de_result,
+                "gsea": gsea_result,
+                "enrichment": enrichr_result,
+                "prediction": prediction_result,
             }
             logger.info(f"Completed analysis for: {cell_type}")
+
         except Exception as e:
             logger.error(f"Failed analysis for {cell_type}: {e}")
             all_results["per_cell_type"][cell_type] = {"error": str(e)}
@@ -401,20 +393,20 @@ def analyze_single_cell_type(
     )
     metadata_ct = pb_adata_ct.obs.copy()
 
-    # Run parallel tasks
-    gsea_future = pathway_analysis_task.submit(
+    # Run tasks sequentially
+    gsea_result = pathway_analysis_task(
         de_results=de_result["de_results"],
         cell_type=cell_type,
         output_dir=results_dir,
     )
 
-    enrichr_future = overrepresentation_task.submit(
+    enrichr_result = overrepresentation_task(
         de_results=de_result["de_results"],
         cell_type=cell_type,
         output_dir=results_dir,
     )
 
-    prediction_future = predictive_modeling_task.submit(
+    prediction_result = predictive_modeling_task(
         counts_df=de_result["counts_df"],
         metadata=metadata_ct,
         cell_type=cell_type,
@@ -424,7 +416,7 @@ def analyze_single_cell_type(
     return {
         "cell_type": cell_type,
         "de": de_result,
-        "gsea": gsea_future.result(),
-        "enrichment": enrichr_future.result(),
-        "prediction": prediction_future.result(),
+        "gsea": gsea_result,
+        "enrichment": enrichr_result,
+        "prediction": prediction_result,
     }

From 13e70289507af2823e5b061460bd947ba6d67f88 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 14:30:01 -0800
Subject: [PATCH 46/87] Pin numba<0.63 to fix pynndescent compatibility issue
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

numba 0.63+ has stricter type checking that causes TypingError in
pynndescent's nn_descent function when using print statements in
numba-compiled code.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 2874068..ca205b3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,7 +29,7 @@ dependencies = [
     "icecream>=2.1.4",
     "python-dotenv>=1.0.1",
     "pyyaml>=6.0.2",
-    "numba>=0.61.0",
+    "numba>=0.61,<0.63",
     "codespell>=2.4.1",
     "tomli>=2.2.1",
     "pre-commit>=4.2.0",

From 6fe3ec6cf453c540ae87730c1c405428e873e34c Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 14:30:56 -0800
Subject: [PATCH 47/87] Update uv.lock for numba version constraint
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 uv.lock | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/uv.lock b/uv.lock
index 5ab0f7a..37de7fe 100644
--- a/uv.lock
+++ b/uv.lock
@@ -566,7 +566,7 @@ requires-dist = [
     { name = "networkx", specifier = ">=3.4.2" },
     { name = "nibabel", specifier = ">=5.3.2" },
     { name = "nilearn", specifier = ">=0.12.1" },
-    { name = "numba", specifier = ">=0.61.0" },
+    { name = "numba", specifier = ">=0.61,<0.63" },
     { name = "numpy", specifier = ">=2.1.2" },
     { name = "ols-client", specifier = ">=0.2.1" },
     { name = "openai", specifier = ">=1.51.2" },
@@ -3056,14 +3056,15 @@ wheels = [
 
 [[package]]
 name = "llvmlite"
-version = "0.46.0"
+version = "0.45.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/74/cd/08ae687ba099c7e3d21fe2ea536500563ef1943c5105bf6ab4ee3829f68e/llvmlite-0.46.0.tar.gz", hash = "sha256:227c9fd6d09dce2783c18b754b7cd9d9b3b3515210c46acc2d3c5badd9870ceb", size = 193456, upload-time = "2025-12-08T18:15:36.295Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/99/8d/5baf1cef7f9c084fb35a8afbde88074f0d6a727bc63ef764fe0e7543ba40/llvmlite-0.45.1.tar.gz", hash = "sha256:09430bb9d0bb58fc45a45a57c7eae912850bedc095cd0810a57de109c69e1c32", size = 185600, upload-time = "2025-10-01T17:59:52.046Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2b/f8/4db016a5e547d4e054ff2f3b99203d63a497465f81ab78ec8eb2ff7b2304/llvmlite-0.46.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b9588ad4c63b4f0175a3984b85494f0c927c6b001e3a246a3a7fb3920d9a137", size = 37232767, upload-time = "2025-12-08T18:15:00.737Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/85/4890a7c14b4fa54400945cb52ac3cd88545bbdb973c440f98ca41591cdc5/llvmlite-0.46.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3535bd2bb6a2d7ae4012681ac228e5132cdb75fefb1bcb24e33f2f3e0c865ed4", size = 56275176, upload-time = "2025-12-08T18:15:03.936Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/07/3d31d39c1a1a08cd5337e78299fca77e6aebc07c059fbd0033e3edfab45c/llvmlite-0.46.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cbfd366e60ff87ea6cc62f50bc4cd800ebb13ed4c149466f50cf2163a473d1e", size = 55128630, upload-time = "2025-12-08T18:15:07.196Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/6b/d139535d7590a1bba1ceb68751bef22fadaa5b815bbdf0e858e3875726b2/llvmlite-0.46.0-cp312-cp312-win_amd64.whl", hash = "sha256:398b39db462c39563a97b912d4f2866cd37cba60537975a09679b28fbbc0fb38", size = 38138940, upload-time = "2025-12-08T18:15:10.162Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/7c/82cbd5c656e8991bcc110c69d05913be2229302a92acb96109e166ae31fb/llvmlite-0.45.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:28e763aba92fe9c72296911e040231d486447c01d4f90027c8e893d89d49b20e", size = 43043524, upload-time = "2025-10-01T18:03:30.666Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/bc/5314005bb2c7ee9f33102c6456c18cc81745d7055155d1218f1624463774/llvmlite-0.45.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1a53f4b74ee9fd30cb3d27d904dadece67a7575198bd80e687ee76474620735f", size = 37253123, upload-time = "2025-10-01T18:04:18.177Z" },
+    { url = "https://files.pythonhosted.org/packages/96/76/0f7154952f037cb320b83e1c952ec4a19d5d689cf7d27cb8a26887d7bbc1/llvmlite-0.45.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b3796b1b1e1c14dcae34285d2f4ea488402fbd2c400ccf7137603ca3800864f", size = 56288211, upload-time = "2025-10-01T18:01:24.079Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b1/0b581942be2683ceb6862d558979e87387e14ad65a1e4db0e7dd671fa315/llvmlite-0.45.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:779e2f2ceefef0f4368548685f0b4adde34e5f4b457e90391f570a10b348d433", size = 55140958, upload-time = "2025-10-01T18:02:30.482Z" },
+    { url = "https://files.pythonhosted.org/packages/33/94/9ba4ebcf4d541a325fd8098ddc073b663af75cc8b065b6059848f7d4dce7/llvmlite-0.45.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e6c9949baf25d9aa9cd7cf0f6d011b9ca660dd17f5ba2b23bdbdb77cc86b116", size = 38132231, upload-time = "2025-10-01T18:05:03.664Z" },
 ]
 
 [[package]]
@@ -3682,18 +3683,19 @@ wheels = [
 
 [[package]]
 name = "numba"
-version = "0.63.1"
+version = "0.62.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llvmlite" },
     { name = "numpy" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/dc/60/0145d479b2209bd8fdae5f44201eceb8ce5a23e0ed54c71f57db24618665/numba-0.63.1.tar.gz", hash = "sha256:b320aa675d0e3b17b40364935ea52a7b1c670c9037c39cf92c49502a75902f4b", size = 2761666, upload-time = "2025-12-10T02:57:39.002Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/20/33dbdbfe60e5fd8e3dbfde299d106279a33d9f8308346022316781368591/numba-0.62.1.tar.gz", hash = "sha256:7b774242aa890e34c21200a1fc62e5b5757d5286267e71103257f4e2af0d5161", size = 2749817, upload-time = "2025-09-29T10:46:31.551Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/9c/c0974cd3d00ff70d30e8ff90522ba5fbb2bcee168a867d2321d8d0457676/numba-0.63.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2819cd52afa5d8d04e057bdfd54367575105f8829350d8fb5e4066fb7591cc71", size = 2680981, upload-time = "2025-12-10T02:57:17.579Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/70/ea2bc45205f206b7a24ee68a159f5097c9ca7e6466806e7c213587e0c2b1/numba-0.63.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5cfd45dbd3d409e713b1ccfdc2ee72ca82006860254429f4ef01867fdba5845f", size = 3801656, upload-time = "2025-12-10T02:57:19.106Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/82/4f4ba4fd0f99825cbf3cdefd682ca3678be1702b63362011de6e5f71f831/numba-0.63.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69a599df6976c03b7ecf15d05302696f79f7e6d10d620367407517943355bcb0", size = 3501857, upload-time = "2025-12-10T02:57:20.721Z" },
-    { url = "https://files.pythonhosted.org/packages/af/fd/6540456efa90b5f6604a86ff50dabefb187e43557e9081adcad3be44f048/numba-0.63.1-cp312-cp312-win_amd64.whl", hash = "sha256:bbad8c63e4fc7eb3cdb2c2da52178e180419f7969f9a685f283b313a70b92af3", size = 2750282, upload-time = "2025-12-10T02:57:22.474Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/fa/30fa6873e9f821c0ae755915a3ca444e6ff8d6a7b6860b669a3d33377ac7/numba-0.62.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:1b743b32f8fa5fff22e19c2e906db2f0a340782caf024477b97801b918cf0494", size = 2685346, upload-time = "2025-09-29T10:43:43.677Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/d5/504ce8dc46e0dba2790c77e6b878ee65b60fe3e7d6d0006483ef6fde5a97/numba-0.62.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90fa21b0142bcf08ad8e32a97d25d0b84b1e921bc9423f8dda07d3652860eef6", size = 2688139, upload-time = "2025-09-29T10:44:04.894Z" },
+    { url = "https://files.pythonhosted.org/packages/50/5f/6a802741176c93f2ebe97ad90751894c7b0c922b52ba99a4395e79492205/numba-0.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6ef84d0ac19f1bf80431347b6f4ce3c39b7ec13f48f233a48c01e2ec06ecbc59", size = 3796453, upload-time = "2025-09-29T10:42:52.771Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/df/efd21527d25150c4544eccc9d0b7260a5dec4b7e98b5a581990e05a133c0/numba-0.62.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9315cc5e441300e0ca07c828a627d92a6802bcbf27c5487f31ae73783c58da53", size = 3496451, upload-time = "2025-09-29T10:43:19.279Z" },
+    { url = "https://files.pythonhosted.org/packages/80/44/79bfdab12a02796bf4f1841630355c82b5a69933b1d50eb15c7fa37dabe8/numba-0.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:44e3aa6228039992f058f5ebfcfd372c83798e9464297bdad8cc79febcf7891e", size = 2745552, upload-time = "2025-09-29T10:44:26.399Z" },
 ]
 
 [[package]]

From 2154feb2babfb9c89b37064078f49d9f3fce676b Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 14:38:42 -0800
Subject: [PATCH 48/87] Add execution logging to Prefect workflow
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Set up file-based logging that captures all Prefect logs to workflow/logs/
- Integrate with existing ExecutionLog system for structured JSON logs
- Track timing, parameters, and cache status for each workflow step
- Log files saved as: prefect_workflow_YYYYMMDD_HHMMSS.log
- Execution logs saved as: execution_log_YYYYMMDD_HHMMSS.json
- Both logs are saved in the finally block to capture errors

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/prefect_workflow/flows.py          | 661 +++++++++++-------
 1 file changed, 423 insertions(+), 238 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
index 7f54095..d349cdd 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
@@ -3,6 +3,8 @@
 Main workflow flow that orchestrates all tasks.
 """
 
+import logging
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -25,6 +27,47 @@
     bids_checkpoint_name,
     load_checkpoint,
 )
+from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import (
+    create_execution_log,
+    serialize_parameters,
+)
+
+
+def setup_file_logging(log_dir: Path) -> tuple[Path, logging.FileHandler]:
+    """Set up file-based logging for the workflow.
+
+    Parameters
+    ----------
+    log_dir : Path
+        Directory to save log files
+
+    Returns
+    -------
+    tuple[Path, logging.FileHandler]
+        Path to log file and the file handler (for cleanup)
+    """
+    log_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_file = log_dir / f"prefect_workflow_{timestamp}.log"
+
+    # Create file handler
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setLevel(logging.INFO)
+    formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)-8s | %(name)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    file_handler.setFormatter(formatter)
+
+    # Add handler to root logger to capture all logs
+    root_logger = logging.getLogger()
+    root_logger.addHandler(file_handler)
+
+    # Also add to prefect logger
+    prefect_logger = logging.getLogger("prefect")
+    prefect_logger.addHandler(file_handler)
+
+    return log_file, file_handler
 
 
 @flow(name="immune_aging_scrna_workflow", log_prints=True)
@@ -69,259 +112,401 @@ def run_workflow(
     results_dir = datadir / "workflow/results/per_cell_type"
     results_dir.mkdir(parents=True, exist_ok=True)
 
+    log_dir = datadir / "workflow/logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    # Set up file logging
+    log_file, file_handler = setup_file_logging(log_dir)
+    logger.info(f"Logging to file: {log_file}")
+
+    # Initialize execution log for structured tracking
+    execution_log = create_execution_log(
+        workflow_name="immune_aging_scrnaseq_prefect",
+        workflow_parameters=serialize_parameters(
+            datadir=datadir,
+            dataset_name=dataset_name,
+            url=url,
+            force_from_step=force_from_step,
+            min_samples_per_cell_type=min_samples_per_cell_type,
+        ),
+    )
+
     # Determine which steps to force re-run
     force = {i: False for i in range(1, 12)}
     if force_from_step is not None:
         for i in range(force_from_step, 12):
             force[i] = True
 
-    # =========================================================================
-    # STEP 1: Data Download
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEP 1: DATA DOWNLOAD")
-    logger.info("=" * 60)
-
-    datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad"
-    download_data_task(datafile, url)
-
-    # =========================================================================
-    # STEP 2: Data Filtering
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEP 2: DATA FILTERING")
-    logger.info("=" * 60)
-
-    adata = load_and_filter_task(
-        datafile=datafile,
-        checkpoint_file=checkpoint_dir
-        / bids_checkpoint_name(dataset_name, 2, "filtered"),
-        cutoff_percentile=1.0,
-        min_cells_per_celltype=10,
-        percent_donors=0.95,
-        figure_dir=figure_dir,
-        force=force[2],
-    )
-
-    # Build var_to_feature mapping
-    var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"]))
-
-    # =========================================================================
-    # STEP 3: Quality Control
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEP 3: QUALITY CONTROL")
-    logger.info("=" * 60)
-
-    adata = quality_control_task(
-        adata=adata,
-        checkpoint_file=checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc"),
-        min_genes=200,
-        max_genes=6000,
-        min_counts=500,
-        max_counts=30000,
-        max_hb_pct=5.0,
-        expected_doublet_rate=0.06,
-        figure_dir=figure_dir,
-        force=force[3],
-    )
-
-    # =========================================================================
-    # STEP 4: Preprocessing
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEP 4: PREPROCESSING")
-    logger.info("=" * 60)
-
-    adata = preprocessing_task(
-        adata=adata,
-        checkpoint_file=checkpoint_dir
-        / bids_checkpoint_name(dataset_name, 4, "preprocessed"),
-        target_sum=1e4,
-        n_top_genes=3000,
-        batch_key="donor_id",
-        force=force[4],
-    )
-
-    # =========================================================================
-    # STEP 5: Dimensionality Reduction
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEP 5: DIMENSIONALITY REDUCTION")
-    logger.info("=" * 60)
-
-    adata = dimensionality_reduction_task(
-        adata=adata,
-        checkpoint_file=checkpoint_dir
-        / bids_checkpoint_name(dataset_name, 5, "dimreduced"),
-        batch_key="donor_id",
-        n_neighbors=30,
-        n_pcs=40,
-        figure_dir=figure_dir,
-        force=force[5],
-    )
+    error_occurred = None
 
-    # =========================================================================
-    # STEP 6: Clustering
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEP 6: CLUSTERING")
-    logger.info("=" * 60)
-
-    adata = clustering_task(
-        adata=adata,
-        checkpoint_file=checkpoint_dir
-        / bids_checkpoint_name(dataset_name, 6, "clustered"),
-        resolution=1.0,
-        figure_dir=figure_dir,
-        force=force[6],
-    )
+    try:
+        # =====================================================================
+        # STEP 1: Data Download
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEP 1: DATA DOWNLOAD")
+        logger.info("=" * 60)
 
-    # =========================================================================
-    # STEP 7: Pseudobulking
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEP 7: PSEUDOBULKING")
-    logger.info("=" * 60)
-
-    # Load step 3 checkpoint for raw counts
-    step3_checkpoint = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc")
-    adata_raw_counts = load_checkpoint(step3_checkpoint)
-    logger.info(f"Loaded raw counts from step 3: {adata_raw_counts.shape}")
-
-    pb_adata = pseudobulk_task(
-        adata=adata_raw_counts,
-        checkpoint_file=checkpoint_dir
-        / bids_checkpoint_name(dataset_name, 7, "pseudobulk"),
-        group_col="cell_type",
-        donor_col="donor_id",
-        metadata_cols=["development_stage", "sex"],
-        min_cells=10,
-        figure_dir=figure_dir,
-        layer=None,  # Use .X directly (raw counts)
-        force=force[7],
-    )
-
-    # =========================================================================
-    # STEPS 8-11: Per-Cell-Type Analysis (Sequential)
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("STEPS 8-11: PER-CELL-TYPE ANALYSIS (SEQUENTIAL)")
-    logger.info("=" * 60)
-
-    # Get all cell types from pseudobulk
-    cell_types = pb_adata.obs["cell_type"].unique().tolist()
-    logger.info(f"Found {len(cell_types)} cell types to analyze")
-
-    # Filter cell types with insufficient samples
-    cell_type_counts = pb_adata.obs["cell_type"].value_counts()
-    valid_cell_types = [
-        ct for ct in cell_types if cell_type_counts[ct] >= min_samples_per_cell_type
-    ]
-    skipped_cell_types = [ct for ct in cell_types if ct not in valid_cell_types]
-
-    if skipped_cell_types:
-        logger.warning(
-            f"Skipping {len(skipped_cell_types)} cell types with < {min_samples_per_cell_type} samples: "
-            f"{skipped_cell_types}"
+        step_record = execution_log.add_step(
+            step_number=1,
+            step_name="data_download",
+            parameters=serialize_parameters(url=url),
         )
+        datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad"
+        download_data_task(datafile, url)
+        execution_log.complete_step(step_record, from_cache=datafile.exists())
+
+        # =====================================================================
+        # STEP 2: Data Filtering
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEP 2: DATA FILTERING")
+        logger.info("=" * 60)
+
+        step2_params = {
+            "cutoff_percentile": 1.0,
+            "min_cells_per_celltype": 10,
+            "percent_donors": 0.95,
+        }
+        step_record = execution_log.add_step(
+            step_number=2,
+            step_name="data_filtering",
+            parameters=step2_params,
+        )
+        checkpoint_file = checkpoint_dir / bids_checkpoint_name(
+            dataset_name, 2, "filtered"
+        )
+        from_cache = checkpoint_file.exists() and not force[2]
+        adata = load_and_filter_task(
+            datafile=datafile,
+            checkpoint_file=checkpoint_file,
+            cutoff_percentile=step2_params["cutoff_percentile"],
+            min_cells_per_celltype=step2_params["min_cells_per_celltype"],
+            percent_donors=step2_params["percent_donors"],
+            figure_dir=figure_dir,
+            force=force[2],
+        )
+        execution_log.complete_step(step_record, from_cache=from_cache)
+
+        # Build var_to_feature mapping
+        var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"]))
+
+        # =====================================================================
+        # STEP 3: Quality Control
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEP 3: QUALITY CONTROL")
+        logger.info("=" * 60)
+
+        step3_params = {
+            "min_genes": 200,
+            "max_genes": 6000,
+            "min_counts": 500,
+            "max_counts": 30000,
+            "max_hb_pct": 5.0,
+            "expected_doublet_rate": 0.06,
+        }
+        step_record = execution_log.add_step(
+            step_number=3,
+            step_name="quality_control",
+            parameters=step3_params,
+        )
+        checkpoint_file = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc")
+        from_cache = checkpoint_file.exists() and not force[3]
+        adata = quality_control_task(
+            adata=adata,
+            checkpoint_file=checkpoint_file,
+            min_genes=step3_params["min_genes"],
+            max_genes=step3_params["max_genes"],
+            min_counts=step3_params["min_counts"],
+            max_counts=step3_params["max_counts"],
+            max_hb_pct=step3_params["max_hb_pct"],
+            expected_doublet_rate=step3_params["expected_doublet_rate"],
+            figure_dir=figure_dir,
+            force=force[3],
+        )
+        execution_log.complete_step(step_record, from_cache=from_cache)
+
+        # =====================================================================
+        # STEP 4: Preprocessing
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEP 4: PREPROCESSING")
+        logger.info("=" * 60)
+
+        step4_params = {
+            "target_sum": 1e4,
+            "n_top_genes": 3000,
+            "batch_key": "donor_id",
+        }
+        step_record = execution_log.add_step(
+            step_number=4,
+            step_name="preprocessing",
+            parameters=step4_params,
+        )
+        checkpoint_file = checkpoint_dir / bids_checkpoint_name(
+            dataset_name, 4, "preprocessed"
+        )
+        from_cache = checkpoint_file.exists() and not force[4]
+        adata = preprocessing_task(
+            adata=adata,
+            checkpoint_file=checkpoint_file,
+            target_sum=step4_params["target_sum"],
+            n_top_genes=step4_params["n_top_genes"],
+            batch_key=step4_params["batch_key"],
+            force=force[4],
+        )
+        execution_log.complete_step(step_record, from_cache=from_cache)
+
+        # =====================================================================
+        # STEP 5: Dimensionality Reduction
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEP 5: DIMENSIONALITY REDUCTION")
+        logger.info("=" * 60)
+
+        step5_params = {
+            "batch_key": "donor_id",
+            "n_neighbors": 30,
+            "n_pcs": 40,
+        }
+        step_record = execution_log.add_step(
+            step_number=5,
+            step_name="dimensionality_reduction",
+            parameters=step5_params,
+        )
+        checkpoint_file = checkpoint_dir / bids_checkpoint_name(
+            dataset_name, 5, "dimreduced"
+        )
+        from_cache = checkpoint_file.exists() and not force[5]
+        adata = dimensionality_reduction_task(
+            adata=adata,
+            checkpoint_file=checkpoint_file,
+            batch_key=step5_params["batch_key"],
+            n_neighbors=step5_params["n_neighbors"],
+            n_pcs=step5_params["n_pcs"],
+            figure_dir=figure_dir,
+            force=force[5],
+        )
+        execution_log.complete_step(step_record, from_cache=from_cache)
+
+        # =====================================================================
+        # STEP 6: Clustering
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEP 6: CLUSTERING")
+        logger.info("=" * 60)
+
+        step6_params = {"resolution": 1.0}
+        step_record = execution_log.add_step(
+            step_number=6,
+            step_name="clustering",
+            parameters=step6_params,
+        )
+        checkpoint_file = checkpoint_dir / bids_checkpoint_name(
+            dataset_name, 6, "clustered"
+        )
+        from_cache = checkpoint_file.exists() and not force[6]
+        adata = clustering_task(
+            adata=adata,
+            checkpoint_file=checkpoint_file,
+            resolution=step6_params["resolution"],
+            figure_dir=figure_dir,
+            force=force[6],
+        )
+        execution_log.complete_step(step_record, from_cache=from_cache)
+
+        # =====================================================================
+        # STEP 7: Pseudobulking
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEP 7: PSEUDOBULKING")
+        logger.info("=" * 60)
+
+        step7_params = {
+            "group_col": "cell_type",
+            "donor_col": "donor_id",
+            "metadata_cols": ["development_stage", "sex"],
+            "min_cells": 10,
+        }
+        step_record = execution_log.add_step(
+            step_number=7,
+            step_name="pseudobulking",
+            parameters=step7_params,
+        )
+        # Load step 3 checkpoint for raw counts
+        step3_checkpoint = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc")
+        adata_raw_counts = load_checkpoint(step3_checkpoint)
+        logger.info(f"Loaded raw counts from step 3: {adata_raw_counts.shape}")
 
-    logger.info(f"Analyzing {len(valid_cell_types)} cell types sequentially")
-
-    # Initialize results
-    all_results = {
-        "adata": adata,
-        "pb_adata": pb_adata,
-        "per_cell_type": {},
-    }
-
-    # Process each cell type sequentially
-    for i, cell_type in enumerate(valid_cell_types):
-        logger.info(f"\n[{i + 1}/{len(valid_cell_types)}] Processing: {cell_type}")
-
-        try:
-            # Step 8: Differential Expression
-            de_result = differential_expression_task(
-                pb_adata=pb_adata,
-                cell_type=cell_type,
-                var_to_feature=var_to_feature,
-                output_dir=results_dir,
-                design_factors=["age_scaled", "sex"],
-                n_cpus=8,
-            )
-
-            # Get metadata for this cell type (for predictive modeling)
-            pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
-            pb_adata_ct.obs["age"] = (
-                pb_adata_ct.obs["development_stage"]
-                .str.extract(r"(\d+)-year-old")[0]
-                .astype(float)
-            )
-            metadata_ct = pb_adata_ct.obs.copy()
-
-            # Step 9: Pathway Analysis (GSEA)
-            gsea_result = pathway_analysis_task(
-                de_results=de_result["de_results"],
-                cell_type=cell_type,
-                output_dir=results_dir,
-                gene_sets=["MSigDB_Hallmark_2020"],
-                n_top=10,
-            )
-
-            # Step 10: Overrepresentation Analysis (Enrichr)
-            enrichr_result = overrepresentation_task(
-                de_results=de_result["de_results"],
-                cell_type=cell_type,
-                output_dir=results_dir,
-                gene_sets=["MSigDB_Hallmark_2020"],
-                padj_threshold=0.05,
-                n_top=10,
+        checkpoint_file = checkpoint_dir / bids_checkpoint_name(
+            dataset_name, 7, "pseudobulk"
+        )
+        from_cache = checkpoint_file.exists() and not force[7]
+        pb_adata = pseudobulk_task(
+            adata=adata_raw_counts,
+            checkpoint_file=checkpoint_file,
+            group_col=step7_params["group_col"],
+            donor_col=step7_params["donor_col"],
+            metadata_cols=step7_params["metadata_cols"],
+            min_cells=step7_params["min_cells"],
+            figure_dir=figure_dir,
+            layer=None,  # Use .X directly (raw counts)
+            force=force[7],
+        )
+        execution_log.complete_step(step_record, from_cache=from_cache)
+
+        # =====================================================================
+        # STEPS 8-11: Per-Cell-Type Analysis (Sequential)
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("STEPS 8-11: PER-CELL-TYPE ANALYSIS (SEQUENTIAL)")
+        logger.info("=" * 60)
+
+        # Get all cell types from pseudobulk
+        cell_types = pb_adata.obs["cell_type"].unique().tolist()
+        logger.info(f"Found {len(cell_types)} cell types to analyze")
+
+        # Filter cell types with insufficient samples
+        cell_type_counts = pb_adata.obs["cell_type"].value_counts()
+        valid_cell_types = [
+            ct for ct in cell_types if cell_type_counts[ct] >= min_samples_per_cell_type
+        ]
+        skipped_cell_types = [ct for ct in cell_types if ct not in valid_cell_types]
+
+        if skipped_cell_types:
+            logger.warning(
+                f"Skipping {len(skipped_cell_types)} cell types with "
+                f"< {min_samples_per_cell_type} samples: {skipped_cell_types}"
             )
 
-            # Step 11: Predictive Modeling
-            prediction_result = predictive_modeling_task(
-                counts_df=de_result["counts_df"],
-                metadata=metadata_ct,
-                cell_type=cell_type,
-                output_dir=results_dir,
-                n_splits=5,
+        logger.info(f"Analyzing {len(valid_cell_types)} cell types sequentially")
+
+        # Initialize results
+        all_results = {
+            "adata": adata,
+            "pb_adata": pb_adata,
+            "per_cell_type": {},
+        }
+
+        # Process each cell type sequentially
+        for i, cell_type in enumerate(valid_cell_types):
+            logger.info(f"\n[{i + 1}/{len(valid_cell_types)}] Processing: {cell_type}")
+
+            # Log combined steps 8-11 for this cell type
+            step_record = execution_log.add_step(
+                step_number=8,
+                step_name=f"per_cell_type_analysis ({cell_type})",
+                parameters=serialize_parameters(
+                    cell_type=cell_type,
+                    design_factors=["age_scaled", "sex"],
+                    gene_sets=["MSigDB_Hallmark_2020"],
+                    n_splits=5,
+                ),
             )
 
-            all_results["per_cell_type"][cell_type] = {
-                "de": de_result,
-                "gsea": gsea_result,
-                "enrichment": enrichr_result,
-                "prediction": prediction_result,
-            }
-            logger.info(f"Completed analysis for: {cell_type}")
-
-        except Exception as e:
-            logger.error(f"Failed analysis for {cell_type}: {e}")
-            all_results["per_cell_type"][cell_type] = {"error": str(e)}
-
-    # =========================================================================
-    # Summary
-    # =========================================================================
-    logger.info("=" * 60)
-    logger.info("WORKFLOW COMPLETE")
-    logger.info("=" * 60)
-
-    successful = sum(
-        1
-        for ct_results in all_results["per_cell_type"].values()
-        if "error" not in ct_results
-    )
-    failed = len(valid_cell_types) - successful
-
-    logger.info(
-        f"Successfully analyzed: {successful}/{len(valid_cell_types)} cell types"
-    )
-    if failed > 0:
-        logger.warning(f"Failed: {failed} cell types")
+            try:
+                # Step 8: Differential Expression
+                de_result = differential_expression_task(
+                    pb_adata=pb_adata,
+                    cell_type=cell_type,
+                    var_to_feature=var_to_feature,
+                    output_dir=results_dir,
+                    design_factors=["age_scaled", "sex"],
+                    n_cpus=8,
+                )
+
+                # Get metadata for this cell type (for predictive modeling)
+                pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
+                pb_adata_ct.obs["age"] = (
+                    pb_adata_ct.obs["development_stage"]
+                    .str.extract(r"(\d+)-year-old")[0]
+                    .astype(float)
+                )
+                metadata_ct = pb_adata_ct.obs.copy()
+
+                # Step 9: Pathway Analysis (GSEA)
+                gsea_result = pathway_analysis_task(
+                    de_results=de_result["de_results"],
+                    cell_type=cell_type,
+                    output_dir=results_dir,
+                    gene_sets=["MSigDB_Hallmark_2020"],
+                    n_top=10,
+                )
+
+                # Step 10: Overrepresentation Analysis (Enrichr)
+                enrichr_result = overrepresentation_task(
+                    de_results=de_result["de_results"],
+                    cell_type=cell_type,
+                    output_dir=results_dir,
+                    gene_sets=["MSigDB_Hallmark_2020"],
+                    padj_threshold=0.05,
+                    n_top=10,
+                )
+
+                # Step 11: Predictive Modeling
+                prediction_result = predictive_modeling_task(
+                    counts_df=de_result["counts_df"],
+                    metadata=metadata_ct,
+                    cell_type=cell_type,
+                    output_dir=results_dir,
+                    n_splits=5,
+                )
+
+                all_results["per_cell_type"][cell_type] = {
+                    "de": de_result,
+                    "gsea": gsea_result,
+                    "enrichment": enrichr_result,
+                    "prediction": prediction_result,
+                }
+                logger.info(f"Completed analysis for: {cell_type}")
+                execution_log.complete_step(step_record)
+
+            except Exception as e:
+                logger.error(f"Failed analysis for {cell_type}: {e}")
+                all_results["per_cell_type"][cell_type] = {"error": str(e)}
+                execution_log.complete_step(step_record, error_message=str(e))
+
+        # =====================================================================
+        # Summary
+        # =====================================================================
+        logger.info("=" * 60)
+        logger.info("WORKFLOW COMPLETE")
+        logger.info("=" * 60)
+
+        successful = sum(
+            1
+            for ct_results in all_results["per_cell_type"].values()
+            if "error" not in ct_results
+        )
+        failed = len(valid_cell_types) - successful
 
-    logger.info(f"Figures saved to: {figure_dir}")
-    logger.info(f"Checkpoints saved to: {checkpoint_dir}")
-    logger.info(f"Per-cell-type results saved to: {results_dir}")
+        logger.info(
+            f"Successfully analyzed: {successful}/{len(valid_cell_types)} cell types"
+        )
+        if failed > 0:
+            logger.warning(f"Failed: {failed} cell types")
+
+        logger.info(f"Figures saved to: {figure_dir}")
+        logger.info(f"Checkpoints saved to: {checkpoint_dir}")
+        logger.info(f"Per-cell-type results saved to: {results_dir}")
+
+    except Exception as e:
+        error_occurred = str(e)
+        raise
+
+    finally:
+        # Complete and save execution log
+        execution_log.complete(error_message=error_occurred)
+        execution_log_file = execution_log.save(log_dir)
+        execution_log.print_summary()
+        logger.info(f"Execution log saved to: {execution_log_file}")
+        logger.info(f"Workflow log saved to: {log_file}")
+
+        # Clean up file handler
+        logging.getLogger().removeHandler(file_handler)
+        logging.getLogger("prefect").removeHandler(file_handler)
+        file_handler.close()
 
     return all_results
 

From 532a113f87384154dbc16023cfb9a7e70353865d Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 14:51:24 -0800
Subject: [PATCH 49/87] Disable numba JIT to fix Prefect/pynndescent
 compatibility
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Prefect (like Ray) interferes with numba's JIT compilation, causing
TypingError when pynndescent tries to use print in JIT-compiled code.
Setting NUMBA_DISABLE_JIT=1 before imports avoids this issue.

This makes some operations slower but ensures reliable execution.

See: https://github.com/ray-project/ray/issues/44714

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/prefect_workflow/run_workflow.py                | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
index bc5e8ff..65707a4 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
@@ -7,8 +7,13 @@
     python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --force-from 8
 """
 
-import argparse
+# Disable numba JIT to avoid compatibility issues with Prefect/pynndescent
+# This must be set BEFORE importing any numba-dependent packages
 import os
+
+os.environ["NUMBA_DISABLE_JIT"] = "1"
+
+import argparse
 from pathlib import Path
 
 from dotenv import load_dotenv

From 8b3a383ab1b83d0c71db7accde17e6ebdec16c7a Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 15:03:37 -0800
Subject: [PATCH 50/87] Pre-warm numba before Prefect import to fix JIT
 compatibility
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Instead of disabling numba JIT (which breaks scanpy's normalize_total),
import pynndescent before Prefect to trigger JIT compilation in a
clean Python environment before Prefect modifies the runtime.

This is specific to Prefect/Ray - the stateless workflow doesn't have
this issue because it doesn't use Prefect.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/prefect_workflow/run_workflow.py           | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
index 65707a4..0c9fa75 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
@@ -7,13 +7,14 @@
     python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --force-from 8
 """
 
-# Disable numba JIT to avoid compatibility issues with Prefect/pynndescent
-# This must be set BEFORE importing any numba-dependent packages
-import os
-
-os.environ["NUMBA_DISABLE_JIT"] = "1"
+# Pre-warm numba JIT compilation BEFORE importing Prefect
+# This avoids the Prefect/numba compatibility issue where Prefect's initialization
+# interferes with numba's JIT compilation of pynndescent functions.
+# See: https://github.com/ray-project/ray/issues/44714
+import pynndescent  # noqa: F401 - triggers numba JIT compilation
 
 import argparse
+import os
 from pathlib import Path
 
 from dotenv import load_dotenv

From 6f8e524e29ea3a6df3823ac941656d960965a1bc Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 15:11:12 -0800
Subject: [PATCH 51/87] Set NUMBA_CAPTURED_ERRORS=old_style to fix pynndescent
 print issue
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This environment variable allows print statements in numba nopython
functions, fixing the TypingError with pynndescent/Prefect.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/prefect_workflow/run_workflow.py            | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
index 0c9fa75..9b9dfcd 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
@@ -7,14 +7,14 @@
     python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --force-from 8
 """
 
-# Pre-warm numba JIT compilation BEFORE importing Prefect
-# This avoids the Prefect/numba compatibility issue where Prefect's initialization
-# interferes with numba's JIT compilation of pynndescent functions.
+# Set numba environment variables BEFORE any imports
+# NUMBA_CAPTURED_ERRORS='old_style' allows print in nopython functions
 # See: https://github.com/ray-project/ray/issues/44714
-import pynndescent  # noqa: F401 - triggers numba JIT compilation
+import os
+
+os.environ["NUMBA_CAPTURED_ERRORS"] = "old_style"
 
 import argparse
-import os
 from pathlib import Path
 
 from dotenv import load_dotenv

From 07d5a243c4e297cf5860e5251c0f70f1570add68 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 15:31:54 -0800
Subject: [PATCH 52/87] set log_prints=False to fix numba issue

---
 .../rnaseq/prefect_workflow/flows.py                      | 4 ++--
 .../rnaseq/prefect_workflow/run_workflow.py               | 8 +-------
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
index d349cdd..d57a9f7 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
@@ -70,7 +70,7 @@ def setup_file_logging(log_dir: Path) -> tuple[Path, logging.FileHandler]:
     return log_file, file_handler
 
 
-@flow(name="immune_aging_scrna_workflow", log_prints=True)
+@flow(name="immune_aging_scrna_workflow", log_prints=False)
 def run_workflow(
     datadir: Path,
     dataset_name: str = "OneK1K",
@@ -511,7 +511,7 @@ def run_workflow(
     return all_results
 
 
-@flow(name="analyze_single_cell_type", log_prints=True)
+@flow(name="analyze_single_cell_type", log_prints=False)
 def analyze_single_cell_type(
     datadir: Path,
     cell_type: str,
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
index 9b9dfcd..bc5e8ff 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
@@ -7,14 +7,8 @@
     python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --force-from 8
 """
 
-# Set numba environment variables BEFORE any imports
-# NUMBA_CAPTURED_ERRORS='old_style' allows print in nopython functions
-# See: https://github.com/ray-project/ray/issues/44714
-import os
-
-os.environ["NUMBA_CAPTURED_ERRORS"] = "old_style"
-
 import argparse
+import os
 from pathlib import Path
 
 from dotenv import load_dotenv

From 70764cd0ee8017c6e86dfafe1a5a88b917440191 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Mon, 22 Dec 2025 16:07:01 -0800
Subject: [PATCH 53/87] Add Snakemake workflow for scRNA-seq analysis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Create a Snakemake workflow functionally equivalent to the Prefect
and stateless workflows:

- Snakefile with modular rule files (preprocessing, pseudobulk, per_cell_type)
- Uses Snakemake checkpoint for step 7 to discover cell types dynamically
- Per-cell-type analysis (steps 8-11) triggered for all valid cell types
- Python scripts wrap existing modular workflow functions
- Configuration in config/config.yaml with all workflow parameters
- Added snakemake>=8.0 dependency

Usage: snakemake --cores 8 --config datadir=/path/to/data

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          |  15 +++
 pyproject.toml                                |   1 +
 .../rnaseq/snakemake_workflow/Snakefile       | 100 ++++++++++++++++
 .../rnaseq/snakemake_workflow/__init__.py     |   0
 .../snakemake_workflow/config/config.yaml     |  75 ++++++++++++
 .../snakemake_workflow/rules/common.smk       |  92 +++++++++++++++
 .../rules/per_cell_type.smk                   |  96 +++++++++++++++
 .../rules/preprocessing.smk                   | 107 +++++++++++++++++
 .../snakemake_workflow/rules/pseudobulk.smk   |  37 ++++++
 .../scripts/aggregate_results.py              |  56 +++++++++
 .../snakemake_workflow/scripts/cluster.py     |  43 +++++++
 .../scripts/differential_expression.py        |  79 +++++++++++++
 .../snakemake_workflow/scripts/dimred.py      |  47 ++++++++
 .../snakemake_workflow/scripts/download.py    |  23 ++++
 .../snakemake_workflow/scripts/enrichr.py     |  54 +++++++++
 .../snakemake_workflow/scripts/filter.py      |  48 ++++++++
 .../rnaseq/snakemake_workflow/scripts/gsea.py |  48 ++++++++
 .../snakemake_workflow/scripts/prediction.py  |  79 +++++++++++++
 .../snakemake_workflow/scripts/preprocess.py  |  48 ++++++++
 .../snakemake_workflow/scripts/pseudobulk.py  | 110 ++++++++++++++++++
 .../rnaseq/snakemake_workflow/scripts/qc.py   |  54 +++++++++
 21 files changed, 1212 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/config/config.yaml
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/aggregate_results.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/differential_expression.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/download.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/enrichr.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/gsea.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/prediction.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/preprocess.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py

diff --git a/problems_to_solve.md b/problems_to_solve.md
index f1e6d77..b2d4a7d 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -3,6 +3,21 @@
 Open problems marked with [ ]
 Fixed problems marked with [x]
 
+[x] I would now like to add another workflow, with code saved to src/BetterCodeBetterScience/rnaseq/snakemake_workflow. This workflow will use the Snakemake workflow manager (https://snakemake.readthedocs.io/en/stable/index.html); otherwise it should be functionally equivalent to the other workflows already developed.
+    - Created `snakemake_workflow/` directory with:
+      - `Snakefile`: Main workflow entry point
+      - `config/config.yaml`: All workflow parameters with defaults
+      - `rules/common.smk`: Helper functions (sanitize_cell_type, aggregate functions)
+      - `rules/preprocessing.smk`: Steps 1-6 rules
+      - `rules/pseudobulk.smk`: Step 7 as Snakemake checkpoint (enables dynamic rules)
+      - `rules/per_cell_type.smk`: Steps 8-11 with {cell_type} wildcard
+      - `scripts/*.py`: 12 Python scripts wrapping modular workflow functions
+    - Uses Snakemake checkpoint for step 7 to discover cell types dynamically
+    - Per-cell-type steps (8-11) triggered automatically for all valid cell types
+    - Reuses existing modular workflow functions and checkpoint utilities
+    - Added `snakemake>=8.0` dependency to pyproject.toml
+    - Usage: `snakemake --cores 8 --config datadir=/path/to/data`  
+
 [x] I would like to add a new workflow, with code saved to src/BetterCodeBetterScience/rnaseq/prefect_workflow. This workflow will use the Prefect workflow manager (https://github.com/PrefectHQ/prefect) to manage the workflow that was previously developed in src/BetterCodeBetterScience/rnaseq/stateless_workflow. The one new feature that I would like to add here is to perform steps 8-11 separately on each different cell type that survives the initial filtering.
     - Created `prefect_workflow/` directory with:
       - `tasks.py`: Prefect task definitions wrapping modular workflow functions
diff --git a/pyproject.toml b/pyproject.toml
index ca205b3..f467571 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -80,6 +80,7 @@ dependencies = [
     "harmonypy>=0.0.10",
     "rpy2>=3.6.4",
     "prefect>=3.0",
+    "snakemake>=8.0",
 ]
 
 [build-system]
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
new file mode 100644
index 0000000..87b617b
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
@@ -0,0 +1,100 @@
+"""Main Snakemake workflow for scRNA-seq immune aging analysis.
+
+This workflow is functionally equivalent to the Prefect and stateless workflows.
+It processes scRNA-seq data through 11 steps:
+
+Global Steps (1-7):
+1. Data Download
+2. Data Filtering
+3. Quality Control
+4. Preprocessing
+5. Dimensionality Reduction
+6. Clustering
+7. Pseudobulking (discovers cell types)
+
+Per-Cell-Type Steps (8-11):
+8. Differential Expression
+9. Pathway Analysis (GSEA)
+10. Overrepresentation Analysis (Enrichr)
+11. Predictive Modeling
+
+Usage:
+    # Run full workflow
+    snakemake --cores 8 --config datadir=/path/to/data
+
+    # Dry run (see what would be executed)
+    snakemake -n --config datadir=/path/to/data
+
+    # Force re-run from a specific rule
+    snakemake --cores 8 --forcerun dimensionality_reduction --config datadir=/path/to/data
+
+    # Run only preprocessing (steps 1-6)
+    snakemake --cores 8 clustering --config datadir=/path/to/data
+"""
+
+from pathlib import Path
+
+from snakemake.utils import min_version
+
+# Require Snakemake 8.0 or higher
+min_version("8.0")
+
+
+# Load configuration
+configfile: "config/config.yaml"
+
+
+# Validate required config
+if config.get("datadir") is None:
+    raise ValueError(
+        "datadir must be provided via --config datadir=/path/to/data"
+    )
+
+DATADIR = Path(config["datadir"])
+DATASET = config["dataset_name"]
+
+# Derived paths
+CHECKPOINT_DIR = DATADIR / "workflow" / "checkpoints"
+RESULTS_DIR = DATADIR / "workflow" / "results"
+FIGURE_DIR = DATADIR / "workflow" / "figures"
+LOG_DIR = DATADIR / "workflow" / "logs"
+
+
+# Include modular rule files
+include: "rules/common.smk"
+include: "rules/preprocessing.smk"
+include: "rules/pseudobulk.smk"
+include: "rules/per_cell_type.smk"
+
+
+# Default target: all analyses complete
+rule all:
+    input:
+        # Global preprocessing outputs
+        CHECKPOINT_DIR / f"dataset-{DATASET}_step-06_desc-clustered.h5ad",
+        # Aggregated per-cell-type results (triggers dynamic rules)
+        RESULTS_DIR / "workflow_complete.txt",
+
+
+# Rule to aggregate all per-cell-type results
+rule aggregate_results:
+    input:
+        aggregate_per_cell_type_outputs,
+    output:
+        RESULTS_DIR / "workflow_complete.txt",
+    log:
+        LOG_DIR / "aggregate_results.log",
+    script:
+        "scripts/aggregate_results.py"
+
+
+# Preprocessing-only target (stops at step 6)
+rule preprocessing_only:
+    input:
+        CHECKPOINT_DIR / f"dataset-{DATASET}_step-06_desc-clustered.h5ad",
+
+
+# Pseudobulk-only target (stops at step 7)
+rule pseudobulk_only:
+    input:
+        CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_desc-pseudobulk.h5ad",
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/config/config.yaml b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/config/config.yaml
new file mode 100644
index 0000000..121be0f
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/config/config.yaml
@@ -0,0 +1,75 @@
+# Configuration for Snakemake scRNA-seq immune aging workflow
+#
+# Usage:
+#   snakemake --cores 8 --config datadir=/path/to/data
+#
+# Override any parameter:
+#   snakemake --cores 8 --config datadir=/path/to/data dataset_name=MyDataset
+
+# Dataset configuration
+dataset_name: "OneK1K"
+url: "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad"
+
+# Step 2: Filtering parameters
+filtering:
+  cutoff_percentile: 1.0
+  min_cells_per_celltype: 10
+  percent_donors: 0.95
+
+# Step 3: QC parameters
+qc:
+  min_genes: 200
+  max_genes: 6000
+  min_counts: 500
+  max_counts: 30000
+  max_hb_pct: 5.0
+  expected_doublet_rate: 0.06
+
+# Step 4: Preprocessing parameters
+preprocessing:
+  target_sum: 10000
+  n_top_genes: 3000
+  batch_key: "donor_id"
+
+# Step 5: Dimensionality reduction parameters
+dimred:
+  batch_key: "donor_id"
+  n_neighbors: 30
+  n_pcs: 40
+
+# Step 6: Clustering parameters
+clustering:
+  resolution: 1.0
+
+# Step 7: Pseudobulking parameters
+pseudobulk:
+  group_col: "cell_type"
+  donor_col: "donor_id"
+  metadata_cols:
+    - "development_stage"
+    - "sex"
+  min_cells: 10
+
+# Steps 8-11: Per-cell-type analysis parameters
+differential_expression:
+  design_factors:
+    - "age_scaled"
+    - "sex"
+  n_cpus: 8
+
+pathway_analysis:
+  gene_sets:
+    - "MSigDB_Hallmark_2020"
+  n_top: 10
+
+overrepresentation:
+  gene_sets:
+    - "MSigDB_Hallmark_2020"
+  padj_threshold: 0.05
+  n_top: 10
+
+predictive_modeling:
+  n_splits: 5
+
+# Minimum samples per cell type for per-cell-type analysis
+min_samples_per_cell_type: 10
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk
new file mode 100644
index 0000000..3c11e87
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk
@@ -0,0 +1,92 @@
+"""Common helper functions and wildcards for Snakemake workflow."""
+
+import json
+from pathlib import Path
+
+
+def sanitize_cell_type(cell_type: str) -> str:
+    """Sanitize cell type name for filesystem use.
+
+    Matches the function used in Prefect workflow.
+    """
+    return cell_type.replace(" ", "_").replace(",", "").replace("-", "_")
+
+
+def unsanitize_cell_type(sanitized: str, cell_types_file: Path) -> str:
+    """Convert sanitized cell type back to original name.
+
+    Parameters
+    ----------
+    sanitized : str
+        Sanitized cell type name
+    cell_types_file : Path
+        Path to cell_types.json file from pseudobulk step
+
+    Returns
+    -------
+    str
+        Original cell type name
+    """
+    with open(cell_types_file) as f:
+        data = json.load(f)
+    # Reverse lookup
+    for original, sanitized_name in data["sanitized_names"].items():
+        if sanitized_name == sanitized:
+            return original
+    raise ValueError(f"Unknown sanitized cell type: {sanitized}")
+
+
+def bids_checkpoint_name(
+    dataset_name: str, step_number: int, description: str, extension: str = "h5ad"
+) -> str:
+    """Generate BIDS-compliant checkpoint filename.
+
+    Matches the naming convention used in stateless_workflow.
+    """
+    return f"dataset-{dataset_name}_step-{step_number:02d}_desc-{description}.{extension}"
+
+
+def get_valid_cell_types(wildcards):
+    """Get list of valid cell types from pseudobulk checkpoint.
+
+    This function is used as an input function after the checkpoint
+    to determine which cell types to process.
+    """
+    checkpoint_output = checkpoints.pseudobulk.get(**wildcards)
+    cell_types_file = checkpoint_output.output.cell_types
+
+    with open(cell_types_file) as f:
+        data = json.load(f)
+
+    return data["valid_cell_types"]
+
+
+def aggregate_per_cell_type_outputs(wildcards):
+    """Aggregate function to collect all per-cell-type outputs.
+
+    This is called after the pseudobulk checkpoint is resolved to
+    generate the list of expected outputs for all valid cell types.
+    """
+    checkpoint_output = checkpoints.pseudobulk.get(**wildcards)
+    cell_types_file = checkpoint_output.output.cell_types
+
+    with open(cell_types_file) as f:
+        data = json.load(f)
+
+    valid_cell_types = data["valid_cell_types"]
+
+    outputs = []
+    for ct in valid_cell_types:
+        ct_sanitized = sanitize_cell_type(ct)
+        ct_dir = RESULTS_DIR / "per_cell_type" / ct_sanitized
+        outputs.extend(
+            [
+                ct_dir / "de_results.parquet",
+                ct_dir / "gsea_results.pkl",
+                ct_dir / "enrichr_up.pkl",
+                ct_dir / "enrichr_down.pkl",
+                ct_dir / "prediction_results.pkl",
+            ]
+        )
+
+    return outputs
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
new file mode 100644
index 0000000..9d06fa6
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
@@ -0,0 +1,96 @@
+"""Per-cell-type analysis rules (Steps 8-11).
+
+These rules are triggered dynamically based on the cell types discovered
+in the pseudobulk checkpoint (step 7). Each rule uses the {cell_type}
+wildcard to process all valid cell types.
+
+The workflow is:
+- Step 8: Differential Expression (required first - provides DE results and counts)
+- Step 9: Pathway Analysis (GSEA) - depends on DE results
+- Step 10: Overrepresentation Analysis (Enrichr) - depends on DE results
+- Step 11: Predictive Modeling - depends on counts from DE step
+"""
+
+
+# Step 8: Differential Expression (per cell type)
+rule differential_expression:
+    input:
+        pseudobulk=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 7, "pseudobulk"),
+        var_to_feature=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_var_to_feature.json",
+        cell_types=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_cell_types.json",
+    output:
+        stat_res=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "stat_res.pkl",
+        de_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "de_results.parquet",
+        counts_df=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "counts.parquet",
+    params:
+        cell_type=lambda wildcards: wildcards.cell_type,
+        design_factors=config["differential_expression"]["design_factors"],
+        n_cpus=config["differential_expression"]["n_cpus"],
+    threads: config["differential_expression"]["n_cpus"]
+    log:
+        LOG_DIR / "step08_de_{cell_type}.log",
+    script:
+        "../scripts/differential_expression.py"
+
+
+# Step 9: Pathway Analysis (GSEA) (per cell type)
+rule pathway_analysis:
+    input:
+        de_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "de_results.parquet",
+    output:
+        gsea_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "gsea_results.pkl",
+    params:
+        cell_type=lambda wildcards: wildcards.cell_type,
+        gene_sets=config["pathway_analysis"]["gene_sets"],
+        n_top=config["pathway_analysis"]["n_top"],
+        figure_dir=lambda wildcards: str(
+            RESULTS_DIR / "per_cell_type" / wildcards.cell_type / "figures"
+        ),
+    log:
+        LOG_DIR / "step09_gsea_{cell_type}.log",
+    script:
+        "../scripts/gsea.py"
+
+
+# Step 10: Overrepresentation Analysis (Enrichr) (per cell type)
+rule overrepresentation:
+    input:
+        de_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "de_results.parquet",
+    output:
+        enr_up=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "enrichr_up.pkl",
+        enr_down=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "enrichr_down.pkl",
+    params:
+        cell_type=lambda wildcards: wildcards.cell_type,
+        gene_sets=config["overrepresentation"]["gene_sets"],
+        padj_threshold=config["overrepresentation"]["padj_threshold"],
+        n_top=config["overrepresentation"]["n_top"],
+        figure_dir=lambda wildcards: str(
+            RESULTS_DIR / "per_cell_type" / wildcards.cell_type / "figures"
+        ),
+    log:
+        LOG_DIR / "step10_enrichr_{cell_type}.log",
+    script:
+        "../scripts/enrichr.py"
+
+
+# Step 11: Predictive Modeling (per cell type)
+rule predictive_modeling:
+    input:
+        counts_df=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "counts.parquet",
+        pseudobulk=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 7, "pseudobulk"),
+        cell_types=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_cell_types.json",
+    output:
+        prediction_results=RESULTS_DIR
+        / "per_cell_type"
+        / "{cell_type}"
+        / "prediction_results.pkl",
+    params:
+        cell_type=lambda wildcards: wildcards.cell_type,
+        n_splits=config["predictive_modeling"]["n_splits"],
+        figure_dir=lambda wildcards: str(
+            RESULTS_DIR / "per_cell_type" / wildcards.cell_type / "figures"
+        ),
+    log:
+        LOG_DIR / "step11_prediction_{cell_type}.log",
+    script:
+        "../scripts/prediction.py"
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
new file mode 100644
index 0000000..3545060
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
@@ -0,0 +1,107 @@
+"""Preprocessing rules (Steps 1-6).
+
+These rules handle the initial data processing pipeline:
+1. Data Download
+2. Data Filtering
+3. Quality Control
+4. Preprocessing (normalization, HVG selection)
+5. Dimensionality Reduction (PCA, UMAP)
+6. Clustering
+"""
+
+
+# Step 1: Data Download
+rule download_data:
+    output:
+        DATADIR / f"dataset-{DATASET}_subset-immune_raw.h5ad",
+    params:
+        url=config["url"],
+    log:
+        LOG_DIR / "step01_download.log",
+    script:
+        "../scripts/download.py"
+
+
+# Step 2: Data Filtering
+rule filter_data:
+    input:
+        DATADIR / f"dataset-{DATASET}_subset-immune_raw.h5ad",
+    output:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
+    params:
+        cutoff_percentile=config["filtering"]["cutoff_percentile"],
+        min_cells_per_celltype=config["filtering"]["min_cells_per_celltype"],
+        percent_donors=config["filtering"]["percent_donors"],
+        figure_dir=str(FIGURE_DIR),
+    log:
+        LOG_DIR / "step02_filtering.log",
+    script:
+        "../scripts/filter.py"
+
+
+# Step 3: Quality Control
+rule quality_control:
+    input:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
+    output:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
+    params:
+        min_genes=config["qc"]["min_genes"],
+        max_genes=config["qc"]["max_genes"],
+        min_counts=config["qc"]["min_counts"],
+        max_counts=config["qc"]["max_counts"],
+        max_hb_pct=config["qc"]["max_hb_pct"],
+        expected_doublet_rate=config["qc"]["expected_doublet_rate"],
+        figure_dir=str(FIGURE_DIR),
+    log:
+        LOG_DIR / "step03_qc.log",
+    script:
+        "../scripts/qc.py"
+
+
+# Step 4: Preprocessing
+rule preprocess:
+    input:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
+    output:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 4, "preprocessed"),
+    params:
+        target_sum=config["preprocessing"]["target_sum"],
+        n_top_genes=config["preprocessing"]["n_top_genes"],
+        batch_key=config["preprocessing"]["batch_key"],
+    log:
+        LOG_DIR / "step04_preprocessing.log",
+    script:
+        "../scripts/preprocess.py"
+
+
+# Step 5: Dimensionality Reduction
+rule dimensionality_reduction:
+    input:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 4, "preprocessed"),
+    output:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"),
+    params:
+        batch_key=config["dimred"]["batch_key"],
+        n_neighbors=config["dimred"]["n_neighbors"],
+        n_pcs=config["dimred"]["n_pcs"],
+        figure_dir=str(FIGURE_DIR),
+    log:
+        LOG_DIR / "step05_dimred.log",
+    script:
+        "../scripts/dimred.py"
+
+
+# Step 6: Clustering
+rule clustering:
+    input:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"),
+    output:
+        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"),
+    params:
+        resolution=config["clustering"]["resolution"],
+        figure_dir=str(FIGURE_DIR),
+    log:
+        LOG_DIR / "step06_clustering.log",
+    script:
+        "../scripts/cluster.py"
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
new file mode 100644
index 0000000..ad3be77
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
@@ -0,0 +1,37 @@
+"""Pseudobulking rule (Step 7) - Uses Snakemake checkpoint for dynamic cell types.
+
+This step aggregates single-cell data to pseudobulk samples per cell-type and donor.
+It outputs a JSON file listing valid cell types, which enables dynamic downstream rules.
+
+IMPORTANT: This uses 'checkpoint' instead of 'rule' because:
+- The number of cell types is not known until this step completes
+- Downstream rules (steps 8-11) need to run for each discovered cell type
+- Snakemake's checkpoint mechanism re-evaluates the DAG after this step
+"""
+
+
+# Step 7: Pseudobulking (CHECKPOINT - enables dynamic per-cell-type rules)
+checkpoint pseudobulk:
+    input:
+        # Step 3 provides raw counts in .X
+        qc_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
+        # Step 6 provides clustered data (for var_to_feature mapping)
+        clustered_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"),
+    output:
+        # Main pseudobulk AnnData
+        pseudobulk=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 7, "pseudobulk"),
+        # JSON file listing valid cell types (enables dynamic downstream rules)
+        cell_types=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_cell_types.json",
+        # Gene name mapping (needed for DE analysis)
+        var_to_feature=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_var_to_feature.json",
+    params:
+        group_col=config["pseudobulk"]["group_col"],
+        donor_col=config["pseudobulk"]["donor_col"],
+        metadata_cols=config["pseudobulk"]["metadata_cols"],
+        min_cells=config["pseudobulk"]["min_cells"],
+        min_samples_per_cell_type=config["min_samples_per_cell_type"],
+        figure_dir=str(FIGURE_DIR),
+    log:
+        LOG_DIR / "step07_pseudobulk.log",
+    script:
+        "../scripts/pseudobulk.py"
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/aggregate_results.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/aggregate_results.py
new file mode 100644
index 0000000..4686bea
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/aggregate_results.py
@@ -0,0 +1,56 @@
+"""Snakemake script for aggregating all per-cell-type results.
+
+This script runs after all per-cell-type analyses are complete.
+It creates a summary file indicating successful completion.
+"""
+# ruff: noqa: F821
+
+from datetime import datetime
+from pathlib import Path
+
+
+def main():
+    """Aggregate results and create completion marker."""
+    output_file = Path(snakemake.output[0])
+    input_files = [Path(f) for f in snakemake.input]
+
+    print(f"Aggregating {len(input_files)} result files...")
+
+    # Group files by cell type
+    cell_types = set()
+    for f in input_files:
+        # Extract cell type from path: results/per_cell_type/{cell_type}/...
+        parts = f.parts
+        if "per_cell_type" in parts:
+            idx = parts.index("per_cell_type")
+            if idx + 1 < len(parts):
+                cell_types.add(parts[idx + 1])
+
+    # Create summary
+    summary = {
+        "workflow": "snakemake_scrna_immune_aging",
+        "completed_at": datetime.now().isoformat(),
+        "cell_types_analyzed": sorted(cell_types),
+        "total_cell_types": len(cell_types),
+        "output_files": len(input_files),
+    }
+
+    # Write summary to output file
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_file, "w") as f:
+        f.write("Workflow completed successfully!\n")
+        f.write(f"Completed at: {summary['completed_at']}\n")
+        f.write(f"Cell types analyzed: {summary['total_cell_types']}\n")
+        f.write("\n")
+        f.write("Cell types:\n")
+        for ct in summary["cell_types_analyzed"]:
+            f.write(f"  - {ct}\n")
+        f.write("\n")
+        f.write(f"Total output files: {summary['output_files']}\n")
+
+    print(f"Summary written to: {output_file}")
+    print(f"Analyzed {len(cell_types)} cell types")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
new file mode 100644
index 0000000..243a107
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
@@ -0,0 +1,43 @@
+"""Snakemake script for Step 6: Clustering."""
+
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import (
+    run_clustering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+def main():
+    """Run clustering pipeline."""
+    # ruff: noqa: F821
+    input_file = Path(snakemake.input[0])
+    output_file = Path(snakemake.output[0])
+
+    # Get parameters
+    resolution = snakemake.params.resolution
+    figure_dir = (
+        Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
+    )
+
+    print(f"Loading data from: {input_file}")
+    adata = load_checkpoint(input_file)
+    print(f"Loaded dataset: {adata}")
+
+    print("Running clustering pipeline...")
+    adata = run_clustering_pipeline(
+        adata,
+        resolution=resolution,
+        figure_dir=figure_dir,
+    )
+
+    # Save checkpoint
+    save_checkpoint(adata, output_file)
+    print(f"Saved checkpoint: {output_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/differential_expression.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/differential_expression.py
new file mode 100644
index 0000000..193b423
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/differential_expression.py
@@ -0,0 +1,79 @@
+"""Snakemake script for Step 8: Differential Expression."""
+
+import json
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import (
+    run_differential_expression_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+def unsanitize_cell_type(sanitized: str, cell_types_file: Path) -> str:
+    """Convert sanitized cell type back to original name."""
+    # ruff: noqa: F821
+    with open(cell_types_file) as f:
+        data = json.load(f)
+    # Reverse lookup
+    for original, sanitized_name in data["sanitized_names"].items():
+        if sanitized_name == sanitized:
+            return original
+    raise ValueError(f"Unknown sanitized cell type: {sanitized}")
+
+
+def main():
+    """Run differential expression for a cell type."""
+    pseudobulk_file = Path(snakemake.input.pseudobulk)
+    var_to_feature_file = Path(snakemake.input.var_to_feature)
+    cell_types_file = Path(snakemake.input.cell_types)
+
+    output_stat_res = Path(snakemake.output.stat_res)
+    output_de_results = Path(snakemake.output.de_results)
+    output_counts_df = Path(snakemake.output.counts_df)
+
+    # Get parameters
+    sanitized_cell_type = snakemake.params.cell_type
+    design_factors = snakemake.params.design_factors
+    n_cpus = snakemake.params.n_cpus
+
+    # Get original cell type name
+    cell_type = unsanitize_cell_type(sanitized_cell_type, cell_types_file)
+
+    print(f"Running DE for cell type: {cell_type}")
+    print(f"(sanitized: {sanitized_cell_type})")
+
+    # Create output directory
+    output_stat_res.parent.mkdir(parents=True, exist_ok=True)
+
+    # Load pseudobulk data
+    pb_adata = load_checkpoint(pseudobulk_file)
+
+    # Load var_to_feature mapping
+    with open(var_to_feature_file) as f:
+        var_to_feature = json.load(f)
+
+    # Run differential expression
+    stat_res, de_results, counts_df = run_differential_expression_pipeline(
+        pb_adata,
+        cell_type=cell_type,
+        design_factors=design_factors,
+        var_to_feature=var_to_feature,
+        n_cpus=n_cpus,
+    )
+
+    # Save outputs
+    save_checkpoint(stat_res, output_stat_res)
+    de_results.to_parquet(output_de_results)
+    counts_df.to_parquet(output_counts_df)
+
+    print(f"DE results saved for: {cell_type}")
+    print(f"  - stat_res: {output_stat_res}")
+    print(f"  - de_results: {output_de_results}")
+    print(f"  - counts_df: {output_counts_df}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
new file mode 100644
index 0000000..fc20290
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
@@ -0,0 +1,47 @@
+"""Snakemake script for Step 5: Dimensionality Reduction."""
+
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import (
+    run_dimensionality_reduction_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+def main():
+    """Run dimensionality reduction pipeline."""
+    # ruff: noqa: F821
+    input_file = Path(snakemake.input[0])
+    output_file = Path(snakemake.output[0])
+
+    # Get parameters
+    batch_key = snakemake.params.batch_key
+    n_neighbors = snakemake.params.n_neighbors
+    n_pcs = snakemake.params.n_pcs
+    figure_dir = (
+        Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
+    )
+
+    print(f"Loading data from: {input_file}")
+    adata = load_checkpoint(input_file)
+    print(f"Loaded dataset: {adata}")
+
+    print("Running dimensionality reduction pipeline...")
+    adata = run_dimensionality_reduction_pipeline(
+        adata,
+        batch_key=batch_key,
+        n_neighbors=n_neighbors,
+        n_pcs=n_pcs,
+        figure_dir=figure_dir,
+    )
+
+    # Save checkpoint
+    save_checkpoint(adata, output_file)
+    print(f"Saved checkpoint: {output_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/download.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/download.py
new file mode 100644
index 0000000..659b04d
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/download.py
@@ -0,0 +1,23 @@
+"""Snakemake script for Step 1: Data Download."""
+
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import download_data
+
+
+def main():
+    """Download data file if it doesn't exist."""
+    # ruff: noqa: F821
+    datafile = Path(snakemake.output[0])
+    url = snakemake.params.url
+
+    print(f"Downloading data from: {url}")
+    print(f"Output file: {datafile}")
+
+    download_data(datafile, url)
+
+    print(f"Download complete: {datafile}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/enrichr.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/enrichr.py
new file mode 100644
index 0000000..a076199
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/enrichr.py
@@ -0,0 +1,54 @@
+"""Snakemake script for Step 10: Overrepresentation Analysis (Enrichr)."""
+
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import (
+    run_overrepresentation_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import save_checkpoint
+
+
+def main():
+    """Run Enrichr overrepresentation analysis for a cell type."""
+    # ruff: noqa: F821
+    de_results_file = Path(snakemake.input.de_results)
+    output_enr_up = Path(snakemake.output.enr_up)
+    output_enr_down = Path(snakemake.output.enr_down)
+
+    # Get parameters
+    cell_type = snakemake.params.cell_type
+    gene_sets = snakemake.params.gene_sets
+    padj_threshold = snakemake.params.padj_threshold
+    n_top = snakemake.params.n_top
+    figure_dir = Path(snakemake.params.figure_dir)
+
+    print(f"Running Enrichr for cell type: {cell_type}")
+
+    # Create output directories
+    output_enr_up.parent.mkdir(parents=True, exist_ok=True)
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load DE results
+    de_results = pd.read_parquet(de_results_file)
+
+    # Run overrepresentation analysis
+    enr_up, enr_down = run_overrepresentation_pipeline(
+        de_results,
+        gene_sets=gene_sets,
+        padj_threshold=padj_threshold,
+        n_top=n_top,
+        figure_dir=figure_dir,
+    )
+
+    # Save results
+    save_checkpoint(enr_up, output_enr_up)
+    save_checkpoint(enr_down, output_enr_down)
+    print("Enrichr results saved:")
+    print(f"  - enr_up: {output_enr_up}")
+    print(f"  - enr_down: {output_enr_down}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
new file mode 100644
index 0000000..9a37dd6
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
@@ -0,0 +1,48 @@
+"""Snakemake script for Step 2: Data Filtering."""
+
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import (
+    run_filtering_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import (
+    load_lazy_anndata,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import save_checkpoint
+
+
+def main():
+    """Load data and run filtering pipeline."""
+    # ruff: noqa: F821
+    input_file = Path(snakemake.input[0])
+    output_file = Path(snakemake.output[0])
+
+    # Get parameters
+    cutoff_percentile = snakemake.params.cutoff_percentile
+    min_cells_per_celltype = snakemake.params.min_cells_per_celltype
+    percent_donors = snakemake.params.percent_donors
+    figure_dir = (
+        Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
+    )
+
+    print(f"Loading data from: {input_file}")
+    adata = load_lazy_anndata(input_file)
+    print(f"Loaded dataset: {adata}")
+
+    print("Running filtering pipeline...")
+    adata = run_filtering_pipeline(
+        adata,
+        cutoff_percentile=cutoff_percentile,
+        min_cells_per_celltype=min_cells_per_celltype,
+        percent_donors=percent_donors,
+        figure_dir=figure_dir,
+    )
+    print(f"Dataset after filtering: {adata}")
+
+    # Save checkpoint
+    save_checkpoint(adata, output_file)
+    print(f"Saved checkpoint: {output_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/gsea.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/gsea.py
new file mode 100644
index 0000000..2d956c0
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/gsea.py
@@ -0,0 +1,48 @@
+"""Snakemake script for Step 9: Pathway Analysis (GSEA)."""
+
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import (
+    run_gsea_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import save_checkpoint
+
+
+def main():
+    """Run GSEA pathway analysis for a cell type."""
+    # ruff: noqa: F821
+    de_results_file = Path(snakemake.input.de_results)
+    output_file = Path(snakemake.output.gsea_results)
+
+    # Get parameters
+    cell_type = snakemake.params.cell_type
+    gene_sets = snakemake.params.gene_sets
+    n_top = snakemake.params.n_top
+    figure_dir = Path(snakemake.params.figure_dir)
+
+    print(f"Running GSEA for cell type: {cell_type}")
+
+    # Create output directories
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load DE results
+    de_results = pd.read_parquet(de_results_file)
+
+    # Run GSEA
+    gsea_results = run_gsea_pipeline(
+        de_results,
+        gene_sets=gene_sets,
+        n_top=n_top,
+        figure_dir=figure_dir,
+    )
+
+    # Save results
+    save_checkpoint(gsea_results, output_file)
+    print(f"GSEA results saved: {output_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/prediction.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/prediction.py
new file mode 100644
index 0000000..5ff128b
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/prediction.py
@@ -0,0 +1,79 @@
+"""Snakemake script for Step 11: Predictive Modeling."""
+
+import json
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import (
+    run_predictive_modeling_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+def unsanitize_cell_type(sanitized: str, cell_types_file: Path) -> str:
+    """Convert sanitized cell type back to original name."""
+    # ruff: noqa: F821
+    with open(cell_types_file) as f:
+        data = json.load(f)
+    # Reverse lookup
+    for original, sanitized_name in data["sanitized_names"].items():
+        if sanitized_name == sanitized:
+            return original
+    raise ValueError(f"Unknown sanitized cell type: {sanitized}")
+
+
+def main():
+    """Run predictive modeling for a cell type."""
+    counts_df_file = Path(snakemake.input.counts_df)
+    pseudobulk_file = Path(snakemake.input.pseudobulk)
+    cell_types_file = Path(snakemake.input.cell_types)
+    output_file = Path(snakemake.output.prediction_results)
+
+    # Get parameters
+    sanitized_cell_type = snakemake.params.cell_type
+    n_splits = snakemake.params.n_splits
+    figure_dir = Path(snakemake.params.figure_dir)
+
+    # Get original cell type name
+    cell_type = unsanitize_cell_type(sanitized_cell_type, cell_types_file)
+
+    print(f"Running predictive modeling for cell type: {cell_type}")
+
+    # Create output directories
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    figure_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load counts
+    counts_df = pd.read_parquet(counts_df_file)
+
+    # Load pseudobulk to get metadata
+    pb_adata = load_checkpoint(pseudobulk_file)
+
+    # Get metadata for this cell type
+    pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy()
+    pb_adata_ct.obs["age"] = (
+        pb_adata_ct.obs["development_stage"]
+        .str.extract(r"(\d+)-year-old")[0]
+        .astype(float)
+    )
+    metadata = pb_adata_ct.obs.copy()
+
+    # Run predictive modeling
+    prediction_results = run_predictive_modeling_pipeline(
+        counts_df,
+        metadata,
+        n_splits=n_splits,
+        figure_dir=figure_dir,
+    )
+
+    # Save results
+    save_checkpoint(prediction_results, output_file)
+    print(f"Prediction results saved: {output_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/preprocess.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/preprocess.py
new file mode 100644
index 0000000..dfdee46
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/preprocess.py
@@ -0,0 +1,48 @@
+"""Snakemake script for Step 4: Preprocessing."""
+
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import (
+    run_preprocessing_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+def main():
+    """Run preprocessing pipeline."""
+    # ruff: noqa: F821
+    input_file = Path(snakemake.input[0])
+    output_file = Path(snakemake.output[0])
+
+    # Get parameters
+    target_sum = snakemake.params.target_sum
+    n_top_genes = snakemake.params.n_top_genes
+    batch_key = snakemake.params.batch_key
+
+    print(f"Loading data from: {input_file}")
+    adata = load_checkpoint(input_file)
+    print(f"Loaded dataset: {adata}")
+
+    print("Running preprocessing pipeline...")
+    adata = run_preprocessing_pipeline(
+        adata,
+        target_sum=target_sum,
+        n_top_genes=n_top_genes,
+        batch_key=batch_key,
+    )
+
+    # Remove counts layer after preprocessing to save space
+    if "counts" in adata.layers:
+        del adata.layers["counts"]
+        print("Removed counts layer to save checkpoint space")
+
+    # Save checkpoint
+    save_checkpoint(adata, output_file)
+    print(f"Saved checkpoint: {output_file}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
new file mode 100644
index 0000000..8d19de4
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
@@ -0,0 +1,110 @@
+"""Snakemake script for Step 7: Pseudobulking.
+
+This script creates the pseudobulk data AND outputs a JSON file listing
+all valid cell types, which enables downstream dynamic rules.
+"""
+# ruff: noqa: F821
+
+import json
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import (
+    run_pseudobulk_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+def sanitize_cell_type(cell_type: str) -> str:
+    """Sanitize cell type name for filesystem use."""
+    return cell_type.replace(" ", "_").replace(",", "").replace("-", "_")
+
+
+def main():
+    """Run pseudobulking pipeline and output cell types JSON."""
+    qc_checkpoint = Path(snakemake.input.qc_checkpoint)
+    clustered_checkpoint = Path(snakemake.input.clustered_checkpoint)
+    output_pseudobulk = Path(snakemake.output.pseudobulk)
+    output_cell_types = Path(snakemake.output.cell_types)
+    output_var_to_feature = Path(snakemake.output.var_to_feature)
+
+    # Get parameters
+    group_col = snakemake.params.group_col
+    donor_col = snakemake.params.donor_col
+    metadata_cols = snakemake.params.metadata_cols
+    min_cells = snakemake.params.min_cells
+    min_samples_per_cell_type = snakemake.params.min_samples_per_cell_type
+    figure_dir = (
+        Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
+    )
+
+    # Load step 3 checkpoint (raw counts in .X)
+    print(f"Loading raw counts from: {qc_checkpoint}")
+    adata_raw = load_checkpoint(qc_checkpoint)
+    print(f"Loaded: {adata_raw}")
+
+    # Load clustered data to get var_to_feature mapping
+    print(f"Loading clustered data from: {clustered_checkpoint}")
+    adata_clustered = load_checkpoint(clustered_checkpoint)
+    var_to_feature = dict(
+        zip(adata_clustered.var_names, adata_clustered.var["feature_name"])
+    )
+
+    # Run pseudobulking on raw counts
+    print("Running pseudobulking pipeline...")
+    pb_adata = run_pseudobulk_pipeline(
+        adata_raw,
+        group_col=group_col,
+        donor_col=donor_col,
+        metadata_cols=metadata_cols,
+        min_cells=min_cells,
+        figure_dir=figure_dir,
+        layer=None,  # Use .X directly (raw counts)
+    )
+    print(f"Pseudobulk data: {pb_adata}")
+
+    # Save pseudobulk checkpoint
+    save_checkpoint(pb_adata, output_pseudobulk)
+    print(f"Saved pseudobulk checkpoint: {output_pseudobulk}")
+
+    # Determine valid cell types (with sufficient samples)
+    all_cell_types = pb_adata.obs[group_col].unique().tolist()
+    cell_type_counts = pb_adata.obs[group_col].value_counts()
+
+    valid_cell_types = [
+        ct for ct in all_cell_types if cell_type_counts[ct] >= min_samples_per_cell_type
+    ]
+    skipped_cell_types = [ct for ct in all_cell_types if ct not in valid_cell_types]
+
+    print(f"\nFound {len(all_cell_types)} cell types total")
+    print(
+        f"Valid cell types (>= {min_samples_per_cell_type} samples): {len(valid_cell_types)}"
+    )
+    if skipped_cell_types:
+        print(f"Skipped cell types (insufficient samples): {skipped_cell_types}")
+
+    # Write cell types JSON (enables dynamic rules)
+    cell_types_data = {
+        "all_cell_types": all_cell_types,
+        "valid_cell_types": valid_cell_types,
+        "skipped_cell_types": skipped_cell_types,
+        "cell_type_counts": {str(k): int(v) for k, v in cell_type_counts.items()},
+        "min_samples_threshold": min_samples_per_cell_type,
+        # Include sanitized names for filesystem use
+        "sanitized_names": {ct: sanitize_cell_type(ct) for ct in valid_cell_types},
+    }
+
+    with open(output_cell_types, "w") as f:
+        json.dump(cell_types_data, f, indent=2)
+    print(f"Saved cell types JSON: {output_cell_types}")
+
+    # Write var_to_feature mapping (needed for DE)
+    with open(output_var_to_feature, "w") as f:
+        json.dump(var_to_feature, f)
+    print(f"Saved var_to_feature mapping: {output_var_to_feature}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
new file mode 100644
index 0000000..d66066d
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
@@ -0,0 +1,54 @@
+"""Snakemake script for Step 3: Quality Control."""
+
+from pathlib import Path
+
+from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import (
+    run_qc_pipeline,
+)
+from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import (
+    load_checkpoint,
+    save_checkpoint,
+)
+
+
+def main():
+    """Run quality control pipeline."""
+    # ruff: noqa: F821
+    input_file = Path(snakemake.input[0])
+    output_file = Path(snakemake.output[0])
+
+    # Get parameters
+    min_genes = snakemake.params.min_genes
+    max_genes = snakemake.params.max_genes
+    min_counts = snakemake.params.min_counts
+    max_counts = snakemake.params.max_counts
+    max_hb_pct = snakemake.params.max_hb_pct
+    expected_doublet_rate = snakemake.params.expected_doublet_rate
+    figure_dir = (
+        Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
+    )
+
+    print(f"Loading data from: {input_file}")
+    adata = load_checkpoint(input_file)
+    print(f"Loaded dataset: {adata}")
+
+    print("Running QC pipeline...")
+    adata = run_qc_pipeline(
+        adata,
+        min_genes=min_genes,
+        max_genes=max_genes,
+        min_counts=min_counts,
+        max_counts=max_counts,
+        max_hb_pct=max_hb_pct,
+        expected_doublet_rate=expected_doublet_rate,
+        figure_dir=figure_dir,
+    )
+    print(f"Dataset after QC: {adata}")
+
+    # Save checkpoint
+    save_checkpoint(adata, output_file)
+    print(f"Saved checkpoint: {output_file}")
+
+
+if __name__ == "__main__":
+    main()

From f2052d2ac88878a5976532c5e604c8012a8fefae Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 05:50:16 -0800
Subject: [PATCH 54/87] Fix feature_name KeyError in Snakemake pseudobulk step
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Get var_to_feature mapping from QC checkpoint (step 3) instead of
clustered checkpoint (step 6), since HVG selection during preprocessing
removes the feature_name column.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/snakemake_workflow/rules/pseudobulk.smk  |  4 ++--
 .../rnaseq/snakemake_workflow/scripts/pseudobulk.py | 13 +++++++------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
index ad3be77..ba9e165 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
@@ -13,9 +13,9 @@ IMPORTANT: This uses 'checkpoint' instead of 'rule' because:
 # Step 7: Pseudobulking (CHECKPOINT - enables dynamic per-cell-type rules)
 checkpoint pseudobulk:
     input:
-        # Step 3 provides raw counts in .X
+        # Step 3 provides raw counts in .X and var_to_feature mapping
         qc_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
-        # Step 6 provides clustered data (for var_to_feature mapping)
+        # Step 6 listed for workflow ordering (ensures clustering completes first)
         clustered_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"),
     output:
         # Main pseudobulk AnnData
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
index 8d19de4..6caa564 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
@@ -25,7 +25,8 @@ def sanitize_cell_type(cell_type: str) -> str:
 def main():
     """Run pseudobulking pipeline and output cell types JSON."""
     qc_checkpoint = Path(snakemake.input.qc_checkpoint)
-    clustered_checkpoint = Path(snakemake.input.clustered_checkpoint)
+    # Note: clustered_checkpoint is listed as input for dependency ordering
+    # but not used here - we use QC checkpoint for both counts and gene names
     output_pseudobulk = Path(snakemake.output.pseudobulk)
     output_cell_types = Path(snakemake.output.cell_types)
     output_var_to_feature = Path(snakemake.output.var_to_feature)
@@ -40,17 +41,17 @@ def main():
         Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
     )
 
-    # Load step 3 checkpoint (raw counts in .X)
+    # Load step 3 checkpoint (raw counts in .X, has feature_name annotations)
     print(f"Loading raw counts from: {qc_checkpoint}")
     adata_raw = load_checkpoint(qc_checkpoint)
     print(f"Loaded: {adata_raw}")
 
-    # Load clustered data to get var_to_feature mapping
-    print(f"Loading clustered data from: {clustered_checkpoint}")
-    adata_clustered = load_checkpoint(clustered_checkpoint)
+    # Get var_to_feature mapping from QC checkpoint (before HVG selection)
+    # Step 6 (clustered) may not have feature_name after preprocessing
     var_to_feature = dict(
-        zip(adata_clustered.var_names, adata_clustered.var["feature_name"])
+        zip(adata_raw.var_names, adata_raw.var["feature_name"])
     )
+    print(f"Built var_to_feature mapping with {len(var_to_feature)} genes")
 
     # Run pseudobulking on raw counts
     print("Running pseudobulking pipeline...")

From e7106a7f06d5b8c9bbdfed419f269d24dccc4839 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 05:58:05 -0800
Subject: [PATCH 55/87] Handle missing feature_name column in pseudobulk step
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fall back to using var_names as feature names if the feature_name
column doesn't exist in the checkpoint. This handles datasets where
gene symbols are already stored in the var index.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../snakemake_workflow/scripts/pseudobulk.py      | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
index 6caa564..e090b4e 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
@@ -48,10 +48,17 @@ def main():
 
     # Get var_to_feature mapping from QC checkpoint (before HVG selection)
     # Step 6 (clustered) may not have feature_name after preprocessing
-    var_to_feature = dict(
-        zip(adata_raw.var_names, adata_raw.var["feature_name"])
-    )
-    print(f"Built var_to_feature mapping with {len(var_to_feature)} genes")
+    # Fall back to var_names if feature_name column doesn't exist
+    if "feature_name" in adata_raw.var.columns:
+        var_to_feature = dict(
+            zip(adata_raw.var_names, adata_raw.var["feature_name"])
+        )
+        print("Built var_to_feature mapping from feature_name column")
+    else:
+        # Use var_names as feature names (they may already be gene symbols)
+        var_to_feature = dict(zip(adata_raw.var_names, adata_raw.var_names))
+        print("No feature_name column found, using var_names as feature names")
+    print(f"var_to_feature mapping has {len(var_to_feature)} genes")
 
     # Run pseudobulking on raw counts
     print("Running pseudobulking pipeline...")

From b81dfb625227dc543f91157439524377103aad6b Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 06:07:38 -0800
Subject: [PATCH 56/87] Use step 2 (filtered) checkpoint for var_to_feature
 mapping
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Match Prefect workflow behavior: get feature_name from step 2 (filtered)
checkpoint, not step 3 (QC). The feature_name column is available after
filtering but may not be preserved through QC processing.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../snakemake_workflow/rules/pseudobulk.smk   |  4 ++-
 .../snakemake_workflow/scripts/pseudobulk.py  | 26 +++++++------------
 2 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
index ba9e165..678937e 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
@@ -13,7 +13,9 @@ IMPORTANT: This uses 'checkpoint' instead of 'rule' because:
 # Step 7: Pseudobulking (CHECKPOINT - enables dynamic per-cell-type rules)
 checkpoint pseudobulk:
     input:
-        # Step 3 provides raw counts in .X and var_to_feature mapping
+        # Step 2 provides feature_name column for var_to_feature mapping
+        filtered_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
+        # Step 3 provides raw counts in .X (after QC filtering)
         qc_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
         # Step 6 listed for workflow ordering (ensures clustering completes first)
         clustered_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"),
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
index e090b4e..8273b68 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
@@ -24,9 +24,9 @@ def sanitize_cell_type(cell_type: str) -> str:
 
 def main():
     """Run pseudobulking pipeline and output cell types JSON."""
+    filtered_checkpoint = Path(snakemake.input.filtered_checkpoint)
     qc_checkpoint = Path(snakemake.input.qc_checkpoint)
     # Note: clustered_checkpoint is listed as input for dependency ordering
-    # but not used here - we use QC checkpoint for both counts and gene names
     output_pseudobulk = Path(snakemake.output.pseudobulk)
     output_cell_types = Path(snakemake.output.cell_types)
     output_var_to_feature = Path(snakemake.output.var_to_feature)
@@ -41,25 +41,19 @@ def main():
         Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
     )
 
-    # Load step 3 checkpoint (raw counts in .X, has feature_name annotations)
+    # Load step 2 checkpoint to get var_to_feature mapping (has feature_name)
+    print(f"Loading filtered data for var_to_feature: {filtered_checkpoint}")
+    adata_filtered = load_checkpoint(filtered_checkpoint)
+    var_to_feature = dict(
+        zip(adata_filtered.var_names, adata_filtered.var["feature_name"])
+    )
+    print(f"Built var_to_feature mapping with {len(var_to_feature)} genes")
+
+    # Load step 3 checkpoint for raw counts (after QC filtering)
     print(f"Loading raw counts from: {qc_checkpoint}")
     adata_raw = load_checkpoint(qc_checkpoint)
     print(f"Loaded: {adata_raw}")
 
-    # Get var_to_feature mapping from QC checkpoint (before HVG selection)
-    # Step 6 (clustered) may not have feature_name after preprocessing
-    # Fall back to var_names if feature_name column doesn't exist
-    if "feature_name" in adata_raw.var.columns:
-        var_to_feature = dict(
-            zip(adata_raw.var_names, adata_raw.var["feature_name"])
-        )
-        print("Built var_to_feature mapping from feature_name column")
-    else:
-        # Use var_names as feature names (they may already be gene symbols)
-        var_to_feature = dict(zip(adata_raw.var_names, adata_raw.var_names))
-        print("No feature_name column found, using var_names as feature names")
-    print(f"var_to_feature mapping has {len(var_to_feature)} genes")
-
     # Run pseudobulking on raw counts
     print("Running pseudobulking pipeline...")
     pb_adata = run_pseudobulk_pipeline(

From 32f342856d9933f9eaa226c3fed007a4c48e58cc Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 06:43:36 -0800
Subject: [PATCH 57/87] Add thread specifications to compute-intensive
 Snakemake rules
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Use workflow.cores for QC, preprocessing, and dimensionality reduction
- Set NUMBA_NUM_THREADS and OMP_NUM_THREADS in dimred.py script

This uses the cores specified via --cores on the command line, matching
Prefect behavior where tasks have access to all CPUs by default.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/snakemake_workflow/rules/preprocessing.smk    | 3 +++
 .../rnaseq/snakemake_workflow/scripts/dimred.py          | 9 ++++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
index 3545060..7991264 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
@@ -45,6 +45,7 @@ rule quality_control:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
     output:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
+    threads: workflow.cores
     params:
         min_genes=config["qc"]["min_genes"],
         max_genes=config["qc"]["max_genes"],
@@ -65,6 +66,7 @@ rule preprocess:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
     output:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 4, "preprocessed"),
+    threads: workflow.cores
     params:
         target_sum=config["preprocessing"]["target_sum"],
         n_top_genes=config["preprocessing"]["n_top_genes"],
@@ -81,6 +83,7 @@ rule dimensionality_reduction:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 4, "preprocessed"),
     output:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"),
+    threads: workflow.cores
     params:
         batch_key=config["dimred"]["batch_key"],
         n_neighbors=config["dimred"]["n_neighbors"],
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
index fc20290..7a4c52c 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
@@ -1,7 +1,13 @@
 """Snakemake script for Step 5: Dimensionality Reduction."""
+# ruff: noqa: F821
 
+import os
 from pathlib import Path
 
+# Set thread count for numba/pynndescent before importing scanpy
+os.environ["NUMBA_NUM_THREADS"] = str(snakemake.threads)
+os.environ["OMP_NUM_THREADS"] = str(snakemake.threads)
+
 from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import (
     run_dimensionality_reduction_pipeline,
 )
@@ -13,7 +19,8 @@
 
 def main():
     """Run dimensionality reduction pipeline."""
-    # ruff: noqa: F821
+    print(f"Running with {snakemake.threads} threads")
+
     input_file = Path(snakemake.input[0])
     output_file = Path(snakemake.output[0])
 

From 2ba2d788e97713992e279a31a55ee088cf79119d Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 06:53:03 -0800
Subject: [PATCH 58/87] Create output directories in Snakemake scripts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add directory creation for checkpoint and figure directories in all
scripts that save outputs. This prevents FileNotFoundError when the
workflow runs from a clean state.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/snakemake_workflow/scripts/cluster.py             | 5 +++++
 .../rnaseq/snakemake_workflow/scripts/dimred.py              | 5 +++++
 .../rnaseq/snakemake_workflow/scripts/filter.py              | 5 +++++
 .../rnaseq/snakemake_workflow/scripts/pseudobulk.py          | 5 +++++
 .../rnaseq/snakemake_workflow/scripts/qc.py                  | 5 +++++
 5 files changed, 25 insertions(+)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
index 243a107..4a67cb4 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
@@ -23,6 +23,11 @@ def main():
         Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
     )
 
+    # Create output directories
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    if figure_dir:
+        figure_dir.mkdir(parents=True, exist_ok=True)
+
     print(f"Loading data from: {input_file}")
     adata = load_checkpoint(input_file)
     print(f"Loaded dataset: {adata}")
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
index 7a4c52c..4ce8f1e 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
@@ -32,6 +32,11 @@ def main():
         Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
     )
 
+    # Create output directories
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    if figure_dir:
+        figure_dir.mkdir(parents=True, exist_ok=True)
+
     print(f"Loading data from: {input_file}")
     adata = load_checkpoint(input_file)
     print(f"Loaded dataset: {adata}")
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
index 9a37dd6..4935521 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
@@ -25,6 +25,11 @@ def main():
         Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
     )
 
+    # Create output directories
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    if figure_dir:
+        figure_dir.mkdir(parents=True, exist_ok=True)
+
     print(f"Loading data from: {input_file}")
     adata = load_lazy_anndata(input_file)
     print(f"Loaded dataset: {adata}")
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
index 8273b68..d8a19bb 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py
@@ -41,6 +41,11 @@ def main():
         Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
     )
 
+    # Create output directories
+    output_pseudobulk.parent.mkdir(parents=True, exist_ok=True)
+    if figure_dir:
+        figure_dir.mkdir(parents=True, exist_ok=True)
+
     # Load step 2 checkpoint to get var_to_feature mapping (has feature_name)
     print(f"Loading filtered data for var_to_feature: {filtered_checkpoint}")
     adata_filtered = load_checkpoint(filtered_checkpoint)
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
index d66066d..4839258 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
@@ -28,6 +28,11 @@ def main():
         Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None
     )
 
+    # Create output directories
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    if figure_dir:
+        figure_dir.mkdir(parents=True, exist_ok=True)
+
     print(f"Loading data from: {input_file}")
     adata = load_checkpoint(input_file)
     print(f"Loaded dataset: {adata}")

From a531c9825e18709134e6d65ebeec85329dd081db Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 07:21:53 -0800
Subject: [PATCH 59/87] initial add

---
 .../rnaseq/snakemake_workflow/Makefile                       | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
new file mode 100644
index 0000000..52d3e71
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
@@ -0,0 +1,5 @@
+include ../../../../.env
+export 
+
+rulegraph:
+	snakemake --rulegraph --config datadir=$(DATADIR)/immune_aging/workflow/ --cores 2 | dot -Tpng > rulegraph.png

From 263bdde530ddf60d65dbc32e68d5306110ecff07 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 07:43:37 -0800
Subject: [PATCH 60/87] intermediate progress, full draft of workflow engine
 intro

---
 book/workflows.md | 77 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 50 insertions(+), 27 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index 9f7c432..fd0112c 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -112,6 +112,8 @@ What I found as I developed the workflow is that I increasingly ran into problem
 
 #### Converting from Jupyter notebook to a runnable python script
 
+As we discussed in an earlier chapter, converting a Jupyter notebook to a pure python script is easy using `jupytext`.  This results in a script that can be run from the command line.  However, there can be some commands that will block execution of the script; in particular, plotting commands can open windows that will block execution until they are closed.  To prevent this, and to ensure that the results of the plots are saved for later examination, I replaced all of the `plt.show()` commands that display a figure to the screen with `plt.savefig()` commands that save the figures to a file in the results directory.  (This was an easy job for the Copilot agent to complete.) 
+
 - had to prevent plots from being displayed because this blocked execution
 - used copilot to find and fix all plotting commands to save them to file rather than showing
 
@@ -144,8 +146,6 @@ In addition to a conceptual breakdown, there are also other reasons that one mig
 - There may be sections where one might wish to swap in a new method or different parameterization.
 - There may be points where the output could be reusable elsewhere.
 
-
-
 ## Stateless workflows
 
 I asked Claude Code to help modularize the monolithic workflow, using a prompt that provided the conceptual breakdown described above.  The resulting code (found at XXX - link to commit 678983e1c337b6a23b0f35cfb974a87587cfd13e) ran correctly, but crashed about two hours into the process due to a resource issue that appeared to be due to asking for too many CPU cores in the differential expression analysis.  This left me in the situation of having to rerun the entire two hours of preliminary workflow simply to get to a point where I could test my fix for the differential expression component, which is not a particularly efficient way of coding.  The problem here is that the workflow execution is *stateful*, in the sense that the previous steps need to be rerun prior to performing the current step in order to establish the required objects in memory.  The solution to this problem is to implement the workflow in a *stateless* way, which doesn't require that earlier steps be rerun if they have already been completed.  One way to do this is by implementing a process called *checkpointing*, in which intermediate results are stored for each step.  These can then be used to start the workflow at any point without having to rerun all of the previous steps.  
@@ -263,11 +263,59 @@ Another potentially helpful solution is to compress the checkpoint data if they
 
 Combining these strategies of reducing data duplication, eliminating some intermediate checkpoints, and compressing the stored data, our final pipeline generates about 13 GB worth of checkpoint data, substantially smaller than the initial 64 GB.  With all checkpoints generated, the entire workflow completes in less than four minutes, with only three time-consuming steps being rerun each time.   The initial execution of the workflow is a few minutes longer due to the extra time needed to read and write compressed checkpoint files, but these few minutes are hardly noticeable for a workflow that takes more than two hours to complete.
 
+The use of a modular architecture for our stateless workflow helps to separate the actual workflow components from the execution logic of the workflow.  One important benefit of this is that it allows us to plug those modules into any other workflow system, and as long as the inputs are correct it should work. We will see that next when we create new versions of this workflow using two common workflow engines.
 
 ### Using a workflow engine
 
+There is a wide variety of workflow engines available for data analysis workflows, most of which are centered around the concept of an "execution graph."  This is a graph in the sense described by graph theory, which refers to a set of nodes that are connected by lines (known as "edges").  Workflow execution graphs are a particular kind of graph known as a *directed acyclic graph*, or *DAG* for short. Each node in the graph represents a single step in the workflow, and each edge represents the dependency relationships that exist between nodes.  DAGs have two important features.  First, the edges are directed, which means that they move in one direction that is represented graphically as an arrow.  These represent the dependencies within the workflow.  For example, in our workflow step 1 (obtaining the data) must occur before step 2 (filtering the data), so the graph would have an edge from step 1 with an arrow pointing at step 2.  Second, the graph is *acyclic*, which means that it doesn't have any cycles, that is, it never circles back on itself.  Cycles would be problematic, since they could result in workflows that executed in an infinite loop as the cycle repeated itself.  
+
+Most workflow engines provide tools to visualize a workflow as a DAG. #DAG-fig shows our example workflow visualized using the Snakemake tool that we will introduce below:
+
+```{figure} images/snakemake-DAG.png
+:label: DAG-fig
+:align: center
+:width: 300px
+
+The execution graph for the RNA-seq analysis workflow visualized as a DAG.
+```
+
+The use of DAGs to represent workflows provides a number of important benefits:
+
+- The engine can identify independent pathways through the graph, which can then be executed in parallel
+- If one node of the graph changes, the engine can identify which downstream nodes need to be rerun
+- If a node fails, the engine can continue with executing the nodes that don't depend on the failed node either directly or indirectly
+
+Another benefit of using a workflow engine is that they generally deal automatically with checkpointing and caching of intermediate results.  
+
+#### General-purpose versus domain-specific workflow engines
+
+With the growth of data science within industry and research, there has been an explosion of new workflow management systems that aim to solve particular problems; a list of these can be found at [awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines).  One important distinction between engines is the degree to which the workflow definition is built into the code, or whether it is defined in a *domain-specific language* (DSL).  We will look at two examples below, one of which (Prefect) builds the workflow details in the code, and the other (Snakemake) uses a specialized syntax built on Python to define the workflow.
+
+It's also worth noting that there are a number of domain-specific workflow engines that are specialized for particular kinds of data and workflows.  Examples include [Galaxy](https://galaxyproject.org/) which is specialized for bioinformatics and genomics, and [Nipype](https://nipype.readthedocs.io/en/latest/index.html) which is specialized for neuroimaging analysis workflows. If your research community uses one of these then it's worth exploring that engine as your first option, since it will probably be well supported within the community. However, a benefit of using a general-purpose engine is that they will often be better maintained and supported, and AI tools will likely have more examples to work from in generating workflows.
+
+#### A language-specific workflow management example: Prefect
+
+
+
+
+#### A general-purpose workflow management example: Snakemake
 
 
+The first time that I ran my workflow using snakemake, I noticed that it was substantially slower than when I ran it with Prefect.  When I asked Claude about this, it gave me a reasonable answer:
+
+> The Snakemake rules don't specify a threads directive. By default, Snakemake runs each job with 1 thread, which limits parallelization of computationally intensive operations like neighbor computation and UMAP (which use numba internally).
+
+I asked Claude to fix this, and it returned the following change:
+
+
+>   Fixes applied:
+>  1. Added threads: 8 to dimensionality_reduction rule
+>  2. Added threads: 8 to quality_control rule (Scrublet)
+>  3. Added threads: 4 to preprocess rule
+>  4. Set NUMBA_NUM_THREADS and OMP_NUM_THREADS environment variables in dimred.py
+>   In contrast, Prefect tasks run in the main process with access to all CPUs by default, which is why it was faster.
+
+This solves the problem but it's an odd choice: in particular, it will probably fail if there are fewer than 8 threads available on the system. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might fail if the requested number of cores are not available.
 
 
 ## Modularity and reusability
@@ -326,14 +374,6 @@ also look at arrow for columnar data - look into arrow immutability
 
 - dask, xarray
 
-## Checkpointing
-
-- pipeline state should be files on disk, not in memory
-- functions don't pass large objects in memory, they simply pass file names
-- for modern formats like parquet (others?) reading is very fast so the penalty is minimal
-
-## Precomputing expensive/common operations
-
 
 ## Tracking provenance
 
@@ -354,8 +394,6 @@ also look at arrow for columnar data - look into arrow immutability
 https://workflowhub.eu/
 
 
- - use narps as the working example 
-
 
 ## Error handling and robustness
 
@@ -374,21 +412,6 @@ https://workflowhub.eu/
 
 
  
-## Simple workflow management with Makefiles
-
-
-
-## Python workflow management with checkpoints
-
-
-
-## Workflow management systems for complex workflows
-
-- introduce DAGs
-
-- general purpose vs domain specific
-    - overview various engines
-
 
 
 

From af0ce0b7ee0db50924a533098c00bb546112e99a Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 08:30:47 -0800
Subject: [PATCH 61/87] clean up immutability section

---
 book/workflows.md | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index fd0112c..0646b96 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -108,14 +108,17 @@ I developed the initial version of this workflow as many researchers would: by c
 
 #### The problem of in-place operations
 
-What I found as I developed the workflow is that I increasingly ran into problems that arose because the state of particular objects had changed.  This occurred for two reasons at different points.  In some cases it occurred because I saved a new version of the object to the same name, resulting in an object with different structure than before.  
+What I found as I developed the workflow is that I increasingly ran into problems that arose because the state of particular objects had changed.  This occurred for two reasons at different points.  In some cases it occurred because I saved a new version of the object to the same name, resulting in an object with different structure than before.  Second, and more insidiously, it occurred when an object passed into a function is modified by the function internally.  This is known as an *in-place* operation, in which a function modifies an object directly rather than returning a new object that can be assigned to a variable.  
 
-#### Converting from Jupyter notebook to a runnable python script
+In-place operations can make code particularly difficult to debug in the context of a Jupyter notebook, because it's a case where out-of-order execution can result in very confusing results or errors, since the changes that were made in-place may not be obvious.  For this reason, I generally avoid any kind of in-place operations if possible.  Rather, any functions should immediately create a copy of the object that was passed in, and then do its work on that copy, which is returned at the end of the function for assignment to a new variable.  One can then re-assign it to the same variable name if desired, which is more transparent than an in-place operation but still makes the workflow dependent on the exact state of execution and can lead to confusion when debugging.  Some packages allow a feature called "copy-on-write" which defers actually copying the data in memory until it is actually modified, which can make copying more efficient. 
+
+If one must modify objects in-place, then it is good practice to announce this loudly.  The loudest way to do this would be to put "inplace" in the function name. Another cleaner but less loud way is through conventions regarding function naming; for example, in PyTorch it is a convention that any function that ends with an underscore (e.g. `tensor.mul_(x)`) performs an in-place operation whereas the same function without the underscore (`tensor.mul(x)`) returns a new object. Another way that some packages enable explicit in-place operations is through a function argument (e.g. `inplace=True` in pandas), though this is being phased out from many functions in Pandas because "It is generally seen (at least by several pandas maintainers and educators) as bad practice and often unnecessary" ([PDEP-8](https://pandas.pydata.org/pdeps/0008-inplace-methods-in-pandas.html)). 
 
-As we discussed in an earlier chapter, converting a Jupyter notebook to a pure python script is easy using `jupytext`.  This results in a script that can be run from the command line.  However, there can be some commands that will block execution of the script; in particular, plotting commands can open windows that will block execution until they are closed.  To prevent this, and to ensure that the results of the plots are saved for later examination, I replaced all of the `plt.show()` commands that display a figure to the screen with `plt.savefig()` commands that save the figures to a file in the results directory.  (This was an easy job for the Copilot agent to complete.) 
+One way to prevent in-place operations altogether is to use data types that are *immutable*, meaning that they can't be changed once created.  This is one of the central principles in *functional programming* languages (such as Haskell), where all data types are immutable, such that one is required to create a new object any time data are modified.  Some native data types in Python are immutable (such as tuples and frozensets), and some data science packages also provide immutable data types; in particular, the Polars package (which is meant to be a high-performance alternative to pandas) implements its version of a data frame as an immutable object, and the JAX package (for high-performance numerical computation and machine learning) implements immutable numerical arrays.
 
-- had to prevent plots from being displayed because this blocked execution
-- used copilot to find and fix all plotting commands to save them to file rather than showing
+#### Converting from Jupyter notebook to a runnable python script
+
+As we discussed in an earlier chapter, converting a Jupyter notebook to a pure Python script is easy using `jupytext`.  This results in a script that can be run from the command line.  However, there can be some commands that will block execution of the script; in particular, plotting commands can open windows that will block execution until they are closed.  To prevent this, and to ensure that the results of the plots are saved for later examination, I replaced all of the `plt.show()` commands that display a figure to the screen with `plt.savefig()` commands that save the figures to a file in the results directory.  (This was an easy job for the Copilot agent to complete.) 
 
 ## Decomposing a complex workflow
 
@@ -301,6 +304,7 @@ It's also worth noting that there are a number of domain-specific workflow engin
 #### A general-purpose workflow management example: Snakemake
 
 
+
 The first time that I ran my workflow using snakemake, I noticed that it was substantially slower than when I ran it with Prefect.  When I asked Claude about this, it gave me a reasonable answer:
 
 > The Snakemake rules don't specify a threads directive. By default, Snakemake runs each job with 1 thread, which limits parallelization of computationally intensive operations like neighbor computation and UMAP (which use numba internally).
@@ -315,7 +319,7 @@ I asked Claude to fix this, and it returned the following change:
 >  4. Set NUMBA_NUM_THREADS and OMP_NUM_THREADS environment variables in dimred.py
 >   In contrast, Prefect tasks run in the main process with access to all CPUs by default, which is why it was faster.
 
-This solves the problem but it's an odd choice: in particular, it will probably fail if there are fewer than 8 threads available on the system. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might fail if the requested number of cores are not available.
+This solves the problem but it's an odd choice: in particular, it will probably fail if there are fewer than 8 threads available on the system. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might fail if the requested number of cores are not available. We will discuss optimization further in a later chapter.
 
 
 ## Modularity and reusability

From 67c95e6e179e75c9307f122291e9bc012eaf1b7f Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 08:31:01 -0800
Subject: [PATCH 62/87] initial add

---
 book/images/snakemake-DAG.png | Bin 0 -> 38256 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 book/images/snakemake-DAG.png

diff --git a/book/images/snakemake-DAG.png b/book/images/snakemake-DAG.png
new file mode 100644
index 0000000000000000000000000000000000000000..231ddf5467603b62dd95813fdb2cf178e2eee67f
GIT binary patch
literal 38256
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
G2~7Z$*KrX5

literal 0
HcmV?d00001


From 09b3ff936878db0b487e8f8c847781bbe037c264 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 08:31:23 -0800
Subject: [PATCH 63/87] Add comprehensive workflow overview documentation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Document all 11 steps of the scRNA-seq analysis pipeline with:
- Parameters and default values
- Algorithms used (DESeq2, Harmony, GSEA, etc.)
- Input/output specifications
- Workflow diagram
- Output directory structure

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          |   1 +
 .../snakemake_workflow/WORKFLOW_OVERVIEW.md   | 380 ++++++++++++++++++
 2 files changed, 381 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md

diff --git a/problems_to_solve.md b/problems_to_solve.md
index b2d4a7d..cca966d 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -3,6 +3,7 @@
 Open problems marked with [ ]
 Fixed problems marked with [x]
 
+
 [x] I would now like to add another workflow, with code saved to src/BetterCodeBetterScience/rnaseq/snakemake_workflow. This workflow will use the Snakemake workflow manager (https://snakemake.readthedocs.io/en/stable/index.html); otherwise it should be functionally equivalent to the other workflows already developed.
     - Created `snakemake_workflow/` directory with:
       - `Snakefile`: Main workflow entry point
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
new file mode 100644
index 0000000..ec4f27a
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
@@ -0,0 +1,380 @@
+# Snakemake scRNA-seq Immune Aging Workflow
+
+## Overview
+
+This workflow analyzes single-cell RNA sequencing (scRNA-seq) data to investigate gene expression changes associated with aging in immune cells. It processes data from the OneK1K dataset (peripheral blood mononuclear cells from 982 donors) through quality control, normalization, dimensionality reduction, and per-cell-type differential expression analysis.
+
+The workflow is divided into two phases:
+- **Global Steps (1-7)**: Process the entire dataset
+- **Per-Cell-Type Steps (8-11)**: Run independently for each cell type discovered in Step 7
+
+---
+
+## Workflow Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                         GLOBAL STEPS (1-7)                              │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                         │
+│  Step 1: Download ──► Step 2: Filter ──► Step 3: QC ──► Step 4: Preprocess
+│                                                               │         │
+│                                                               ▼         │
+│                       Step 7: Pseudobulk ◄── Step 6: Cluster ◄── Step 5: DimRed
+│                              │                                          │
+└──────────────────────────────┼──────────────────────────────────────────┘
+                               │
+                               ▼ (discovers N cell types)
+┌──────────────────────────────────────────────────────────────────────────┐
+│                    PER-CELL-TYPE STEPS (8-11)                           │
+│                    Runs in parallel for each cell type                   │
+├──────────────────────────────────────────────────────────────────────────┤
+│                                                                          │
+│  For each cell type:                                                     │
+│                                                                          │
+│    Step 8: Differential Expression                                       │
+│         │                                                                │
+│         ├──► Step 9: GSEA (Pathway Analysis)                            │
+│         │                                                                │
+│         ├──► Step 10: Enrichr (Overrepresentation)                      │
+│         │                                                                │
+│         └──► Step 11: Predictive Modeling (Age Prediction)              │
+│                                                                          │
+└──────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Step Details
+
+### Step 1: Data Download
+
+**Purpose**: Download the raw scRNA-seq dataset from CELLxGENE.
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `url` | CELLxGENE URL | Source URL for the h5ad file |
+| `dataset_name` | "OneK1K" | Dataset identifier |
+
+**Input**: None (downloads from URL)
+**Output**: Raw h5ad file (~1.2M cells × 35K genes)
+
+---
+
+### Step 2: Data Filtering
+
+**Purpose**: Remove low-quality donors and rare cell types to ensure robust downstream analysis.
+
+**Operations**:
+1. **Donor filtering**: Remove donors with abnormally low cell counts
+   - Uses percentile-based cutoff to identify outliers
+2. **Cell type filtering**: Keep only cell types present in sufficient donors
+   - Requires minimum cells per cell type in a threshold percentage of donors
+3. **Zero-count gene removal**: Remove genes with no expression across retained cells
+4. **Memory loading**: Convert lazy-loaded data to in-memory representation
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `cutoff_percentile` | 1.0 | Percentile for donor cell count cutoff |
+| `min_cells_per_celltype` | 10 | Minimum cells per cell type per donor |
+| `percent_donors` | 0.95 | Fraction of donors that must have the cell type |
+
+**Input**: Raw h5ad file
+**Output**: Filtered h5ad checkpoint
+
+---
+
+### Step 3: Quality Control (QC)
+
+**Purpose**: Identify and remove low-quality cells, dying cells, and doublets.
+
+**Operations**:
+1. **Gene annotation**: Identify mitochondrial (MT-), ribosomal (RPS/RPL), and hemoglobin (HB) genes
+2. **QC metric calculation**: Compute per-cell metrics using scanpy
+   - Total counts, genes detected, % mitochondrial, % ribosomal, % hemoglobin
+3. **Cell filtering**: Remove cells outside quality thresholds
+4. **Doublet detection**: Run Scrublet per-donor to identify and remove doublets
+5. **Raw count preservation**: Store raw counts in a layer for pseudobulking
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `min_genes` | 200 | Minimum genes per cell |
+| `max_genes` | 6000 | Maximum genes per cell (doublet filter) |
+| `min_counts` | 500 | Minimum UMIs per cell |
+| `max_counts` | 30000 | Maximum UMIs per cell (doublet filter) |
+| `max_hb_pct` | 5.0 | Maximum hemoglobin % (RBC contamination) |
+| `expected_doublet_rate` | 0.06 | Expected doublet rate for Scrublet |
+
+**Algorithm**: Scrublet (doublet detection)
+**Input**: Filtered h5ad
+**Output**: QC-filtered h5ad checkpoint
+
+---
+
+### Step 4: Preprocessing
+
+**Purpose**: Normalize expression values and select informative genes for downstream analysis.
+
+**Operations**:
+1. **Normalization**: Scale counts to target sum per cell (CPM-like)
+2. **Log transformation**: Apply log1p transformation for variance stabilization
+3. **HVG selection**: Identify highly variable genes using Seurat v3 method
+   - Accounts for batch effects using donor as batch key
+4. **Nuisance gene removal**: Exclude from HVG list:
+   - TCR/BCR variable region genes (IG[HKL]V, TR[ABDG]V patterns)
+   - Mitochondrial genes (MT-*)
+   - Ribosomal genes (RPS*, RPL*)
+5. **PCA**: Compute principal components on HVG subset
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `target_sum` | 10000 | Target sum for normalization |
+| `n_top_genes` | 3000 | Number of highly variable genes |
+| `batch_key` | "donor_id" | Column for batch correction in HVG selection |
+
+**Algorithms**:
+- Normalization: scanpy `normalize_total`
+- HVG: Seurat v3 method (`flavor="seurat_v3"`)
+- PCA: ARPACK solver
+
+**Input**: QC-filtered h5ad
+**Output**: Preprocessed h5ad checkpoint
+
+---
+
+### Step 5: Dimensionality Reduction
+
+**Purpose**: Reduce dimensionality and correct for batch effects for visualization and clustering.
+
+**Operations**:
+1. **Batch correction**: Run Harmony integration on PCA coordinates
+   - Corrects for donor-specific technical effects
+2. **Neighbor graph**: Compute k-nearest neighbor graph in corrected PCA space
+3. **UMAP**: Generate 2D embedding for visualization
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `batch_key` | "donor_id" | Column for batch correction |
+| `n_neighbors` | 30 | Number of neighbors for graph |
+| `n_pcs` | 40 | Number of PCs to use |
+
+**Algorithms**:
+- Batch correction: Harmony (harmony-pytorch)
+- Neighbor graph: scanpy `pp.neighbors` (uses pynndescent/numba)
+- UMAP: scanpy `tl.umap`
+
+**Input**: Preprocessed h5ad
+**Output**: Dimensionality-reduced h5ad checkpoint
+
+---
+
+### Step 6: Clustering
+
+**Purpose**: Cluster cells for visualization and validation (uses pre-existing cell type annotations).
+
+**Operations**:
+1. **Leiden clustering**: Community detection on neighbor graph
+2. **UMAP visualization**: Plot clusters colored by cell type
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `resolution` | 1.0 | Leiden clustering resolution |
+
+**Algorithm**: Leiden clustering (scanpy `tl.leiden`)
+
+**Input**: Dimensionality-reduced h5ad
+**Output**: Clustered h5ad checkpoint
+
+---
+
+### Step 7: Pseudobulking (Checkpoint)
+
+**Purpose**: Aggregate single-cell counts to donor-level pseudobulk samples for differential expression analysis.
+
+**Operations**:
+1. **Count aggregation**: Sum raw counts per (cell_type, donor) combination
+   - Uses one-hot encoding for efficient sparse matrix multiplication
+2. **Metadata preservation**: Retain donor-level metadata (age, sex, etc.)
+3. **Sample filtering**: Remove pseudobulk samples with too few contributing cells
+4. **Cell type discovery**: Identify cell types with sufficient samples for analysis
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `group_col` | "cell_type" | Column for grouping cells |
+| `donor_col` | "donor_id" | Column for donor identity |
+| `metadata_cols` | ["development_stage", "sex"] | Metadata to preserve |
+| `min_cells` | 10 | Minimum cells per pseudobulk sample |
+| `min_samples_per_cell_type` | 10 | Minimum samples to include cell type |
+
+**Note**: This step uses Snakemake's `checkpoint` mechanism to dynamically determine which cell types to analyze in subsequent steps.
+
+**Input**: QC checkpoint (raw counts), filtered checkpoint (gene names)
+**Output**: Pseudobulk h5ad, cell_types.json, var_to_feature.json
+
+---
+
+### Step 8: Differential Expression (Per-Cell-Type)
+
+**Purpose**: Identify genes associated with aging within each cell type.
+
+**Operations**:
+1. **Age extraction**: Parse numeric age from development_stage field
+2. **Age scaling**: Z-score normalize age for stable model fitting
+3. **DESeq2 analysis**: Fit negative binomial GLM with design `~ age_scaled + sex`
+4. **Wald test**: Test for age effect (contrast on age_scaled coefficient)
+5. **Multiple testing**: Apply Benjamini-Hochberg FDR correction
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `design_factors` | ["age_scaled", "sex"] | Model covariates |
+| `n_cpus` | 8 | CPUs for DESeq2 |
+
+**Algorithm**: DESeq2 (via PyDESeq2)
+- Dispersion estimation with shrinkage
+- Wald test for coefficient significance
+- Cook's distance for outlier detection
+
+**Input**: Pseudobulk h5ad, var_to_feature mapping
+**Output**: DESeq2 statistics (pkl), results table (parquet), counts (parquet)
+
+---
+
+### Step 9: Pathway Analysis - GSEA (Per-Cell-Type)
+
+**Purpose**: Identify biological pathways enriched in aging-associated genes using ranked gene set enrichment.
+
+**Operations**:
+1. **Gene ranking**: Rank genes by DESeq2 test statistic
+2. **Preranked GSEA**: Run against MSigDB Hallmark gene sets
+3. **NES calculation**: Compute normalized enrichment scores
+4. **Visualization**: Generate pathway enrichment plots
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `gene_sets` | ["MSigDB_Hallmark_2020"] | Gene set databases |
+| `n_top` | 10 | Number of top pathways to display |
+
+**Algorithm**: GSEA prerank (via gseapy)
+- 1000 permutations for p-value estimation
+- Min pathway size: 10 genes, Max: 1000 genes
+
+**Input**: DE results (parquet)
+**Output**: GSEA results (pkl)
+
+---
+
+### Step 10: Overrepresentation Analysis - Enrichr (Per-Cell-Type)
+
+**Purpose**: Test for pathway enrichment in significantly up/down-regulated gene sets.
+
+**Operations**:
+1. **Gene set extraction**: Separate significant genes (padj < 0.05) by direction
+2. **Enrichr analysis**: Query Enrichr web service for pathway enrichment
+3. **Visualization**: Generate dot plots for enriched pathways
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `gene_sets` | ["MSigDB_Hallmark_2020"] | Gene set databases |
+| `padj_threshold` | 0.05 | Significance threshold for gene selection |
+| `n_top` | 10 | Number of top pathways to display |
+
+**Algorithm**: Enrichr (via gseapy)
+- Fisher's exact test with FDR correction
+
+**Input**: DE results (parquet)
+**Output**: Enrichr results for up/down genes (pkl)
+
+---
+
+### Step 11: Predictive Modeling (Per-Cell-Type)
+
+**Purpose**: Assess whether gene expression in each cell type can predict donor age.
+
+**Operations**:
+1. **Feature preparation**: Combine gene expression with sex as features
+2. **Cross-validation**: 5-fold shuffle split
+3. **Model training**: Linear Support Vector Regression with scaling
+4. **Baseline comparison**: Compare full model (genes + sex) vs. baseline (sex only)
+5. **Metrics**: R² score and Mean Absolute Error (MAE)
+
+| Parameter | Default Value | Description |
+|-----------|--------------|-------------|
+| `n_splits` | 5 | Number of CV folds |
+
+**Algorithm**: Linear SVR (scikit-learn)
+- StandardScaler for feature normalization
+- C=1.0 regularization
+- Max 10,000 iterations
+
+**Input**: Counts (parquet), pseudobulk metadata
+**Output**: Prediction results with CV metrics (pkl)
+
+---
+
+## Output Structure
+
+```
+{datadir}/workflow/
+├── checkpoints/
+│   ├── dataset-{name}_step-02_desc-filtered.h5ad
+│   ├── dataset-{name}_step-03_desc-qc.h5ad
+│   ├── dataset-{name}_step-04_desc-preprocessed.h5ad
+│   ├── dataset-{name}_step-05_desc-dimreduced.h5ad
+│   ├── dataset-{name}_step-06_desc-clustered.h5ad
+│   ├── dataset-{name}_step-07_desc-pseudobulk.h5ad
+│   ├── dataset-{name}_step-07_cell_types.json
+│   └── dataset-{name}_step-07_var_to_feature.json
+├── results/
+│   └── per_cell_type/
+│       └── {cell_type}/
+│           ├── stat_res.pkl
+│           ├── de_results.parquet
+│           ├── counts.parquet
+│           ├── gsea_results.pkl
+│           ├── enrichr_up.pkl
+│           ├── enrichr_down.pkl
+│           └── prediction_results.pkl
+├── figures/
+│   ├── donor_cell_counts_distribution.png
+│   ├── qc_violin_plots.png
+│   ├── hemoglobin_distribution.png
+│   ├── pca_cell_type.png
+│   ├── umap_total_counts.png
+│   └── per_cell_type/{cell_type}/
+│       ├── gsea_pathways.png
+│       └── enrichr_*.png
+└── logs/
+    └── step*.log
+```
+
+---
+
+## Usage
+
+```bash
+# Run full workflow
+snakemake --cores 16 --config datadir=/path/to/data
+
+# Dry run (see what would be executed)
+snakemake -n --config datadir=/path/to/data
+
+# Run only preprocessing (steps 1-6)
+snakemake --cores 16 preprocessing_only --config datadir=/path/to/data
+
+# Force re-run from a specific step
+snakemake --cores 16 --forcerun dimensionality_reduction --config datadir=/path/to/data
+```
+
+---
+
+## Key Dependencies
+
+| Package | Purpose |
+|---------|---------|
+| scanpy | scRNA-seq analysis framework |
+| anndata | Data structure for scRNA-seq |
+| harmony-pytorch | Batch correction |
+| pydeseq2 | Differential expression |
+| gseapy | GSEA and Enrichr analysis |
+| scikit-learn | Predictive modeling |
+| snakemake | Workflow management |

From 9461cda9fe022870bfa136d23b80eaa4fa3cddc2 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 08:31:42 -0800
Subject: [PATCH 64/87] update deps

---
 uv.lock | 266 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 266 insertions(+)

diff --git a/uv.lock b/uv.lock
index 37de7fe..bc7755a 100644
--- a/uv.lock
+++ b/uv.lock
@@ -286,6 +286,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" },
 ]
 
+[[package]]
+name = "argparse-dataclass"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/ff/a2e4e328075ddef2ac3c9431eb12247e4ba707a70324894f1e6b4f43c286/argparse_dataclass-2.0.0.tar.gz", hash = "sha256:09ab641c914a2f12882337b9c3e5086196dbf2ee6bf0ef67895c74002cc9297f", size = 6395, upload-time = "2023-06-11T20:32:54.465Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/66/e6c0a808950ba5a4042e2fcedd577fc7401536c7db063de4d7c36be06f84/argparse_dataclass-2.0.0-py3-none-any.whl", hash = "sha256:3ffc8852a88d9d98d1364b4441a712491320afb91fb56049afd8a51d74bb52d2", size = 8762, upload-time = "2023-06-11T20:32:52.724Z" },
+]
+
 [[package]]
 name = "array-api-compat"
 version = "1.12.0"
@@ -513,6 +522,7 @@ dependencies = [
     { name = "scipy" },
     { name = "scrublet" },
     { name = "seaborn" },
+    { name = "snakemake" },
     { name = "statsmodels" },
     { name = "templateflow" },
     { name = "tomli" },
@@ -592,6 +602,7 @@ requires-dist = [
     { name = "scipy", specifier = ">=1.14.1" },
     { name = "scrublet", specifier = ">=0.2.3" },
     { name = "seaborn", specifier = ">=0.13.2" },
+    { name = "snakemake", specifier = ">=8.0" },
     { name = "statsmodels", specifier = ">=0.14.5" },
     { name = "templateflow", specifier = ">=25.1.1" },
     { name = "tomli", specifier = ">=2.2.1" },
@@ -1021,6 +1032,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" },
 ]
 
+[[package]]
+name = "conda-inject"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/a8/8dc86113c65c949cc72d651461d6e4c544b3302a85ed14a5298829e6a419/conda_inject-1.3.2.tar.gz", hash = "sha256:0b8cde8c47998c118d8ff285a04977a3abcf734caf579c520fca469df1cd0aac", size = 3635, upload-time = "2024-05-27T12:20:58.873Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/4c/fc30b69fb4062aee57e3ab7ff493647c4220144908f0839c619f912045bf/conda_inject-1.3.2-py3-none-any.whl", hash = "sha256:6e641b408980c2814e3e527008c30749117909a21ff47392f07ef807da93a564", size = 4133, upload-time = "2024-05-27T12:20:57.332Z" },
+]
+
 [[package]]
 name = "confection"
 version = "0.1.5"
@@ -1034,6 +1057,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0c/00/3106b1854b45bd0474ced037dfe6b73b90fe68a68968cef47c23de3d43d2/confection-0.1.5-py3-none-any.whl", hash = "sha256:e29d3c3f8eac06b3f77eb9dfb4bf2fc6bcc9622a98ca00a698e3d019c6430b14", size = 35451, upload-time = "2024-05-31T16:16:59.075Z" },
 ]
 
+[[package]]
+name = "configargparse"
+version = "1.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/4d/6c9ef746dfcc2a32e26f3860bb4a011c008c392b83eabdfb598d1a8bbe5d/configargparse-1.7.1.tar.gz", hash = "sha256:79c2ddae836a1e5914b71d58e4b9adbd9f7779d4e6351a637b7d2d9b6c46d3d9", size = 43958, upload-time = "2025-05-23T14:26:17.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/28/d28211d29bcc3620b1fece85a65ce5bb22f18670a03cd28ea4b75ede270c/configargparse-1.7.1-py3-none-any.whl", hash = "sha256:8b586a31f9d873abd1ca527ffbe58863c99f36d896e2829779803125e83be4b6", size = 25607, upload-time = "2025-05-23T14:26:15.923Z" },
+]
+
+[[package]]
+name = "connection-pool"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/df/c9b4e25dce00f6349fd28aadba7b6c3f7431cc8bd4308a158fbe57b6a22e/connection_pool-0.0.3.tar.gz", hash = "sha256:bf429e7aef65921c69b4ed48f3d48d3eac1383b05d2df91884705842d974d0dc", size = 3795, upload-time = "2020-09-17T02:48:28.824Z" }
+
 [[package]]
 name = "contourpy"
 version = "1.3.3"
@@ -1435,6 +1473,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0c/d5/c5db1ea3394c6e1732fb3286b3bd878b59507a8f77d32a2cebda7d7b7cd4/donfig-0.8.1.post1-py3-none-any.whl", hash = "sha256:2a3175ce74a06109ff9307d90a230f81215cbac9a751f4d1c6194644b8204f9d", size = 21592, upload-time = "2024-05-23T14:13:55.283Z" },
 ]
 
+[[package]]
+name = "dpath"
+version = "2.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/ce/e1fd64d36e4a5717bd5e6b2ad188f5eaa2e902fde871ea73a79875793fc9/dpath-2.2.0.tar.gz", hash = "sha256:34f7e630dc55ea3f219e555726f5da4b4b25f2200319c8e6902c394258dd6a3e", size = 28266, upload-time = "2024-06-12T22:08:03.686Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/05/d1/8952806fbf9583004ab479d8f58a9496c3d35f6b6009ddd458bdd9978eaf/dpath-2.2.0-py3-none-any.whl", hash = "sha256:b330a375ded0a0d2ed404440f6c6a715deae5313af40bbb01c8a41d891900576", size = 17618, upload-time = "2024-06-12T22:08:01.881Z" },
+]
+
 [[package]]
 name = "durationpy"
 version = "0.10"
@@ -1751,6 +1798,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/36/93/f7d93f394eaa5f96d8249fb582034dfb5a7d1eb4007ad4a1cc65c2e17463/funowl-0.2.3-py3-none-any.whl", hash = "sha256:4c4328d03c7815cd61d6691f0fafc78dc9a78ec3dcab4c83afb64d125ad3660e", size = 51376, upload-time = "2023-08-08T17:38:14.735Z" },
 ]
 
+[[package]]
+name = "gitdb"
+version = "4.0.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "smmap" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" },
+]
+
+[[package]]
+name = "gitpython"
+version = "3.1.45"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "gitdb" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9a/c8/dd58967d119baab745caec2f9d853297cec1989ec1d63f677d3880632b88/gitpython-3.1.45.tar.gz", hash = "sha256:85b0ee964ceddf211c41b9f27a49086010a190fd8132a24e21f362a4b36a791c", size = 215076, upload-time = "2025-07-24T03:45:54.871Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/61/d4b89fec821f72385526e1b9d9a3a0385dda4a72b206d28049e2c7cd39b8/gitpython-3.1.45-py3-none-any.whl", hash = "sha256:8908cb2e02fb3b93b7eb0f2827125cb699869470432cc885f019b8fd0fccff77", size = 208168, upload-time = "2025-07-24T03:45:52.517Z" },
+]
+
 [[package]]
 name = "google-auth"
 version = "2.45.0"
@@ -2201,6 +2272,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" },
 ]
 
+[[package]]
+name = "immutables"
+version = "0.21"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/69/41/0ccaa6ef9943c0609ec5aa663a3b3e681c1712c1007147b84590cec706a0/immutables-0.21.tar.gz", hash = "sha256:b55ffaf0449790242feb4c56ab799ea7af92801a0a43f9e2f4f8af2ab24dfc4a", size = 89008, upload-time = "2024-10-10T00:55:01.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/f9/0c46f600702b815182212453f5514c0070ee168b817cdf7c3767554c8489/immutables-0.21-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef1ed262094b755903122c3c3a83ad0e0d5c3ab7887cda12b2fe878769d1ee0d", size = 31885, upload-time = "2024-10-10T00:54:19.406Z" },
+    { url = "https://files.pythonhosted.org/packages/29/34/7608d2eab6179aa47e8f59ab0fbd5b3eeb2333d78c9dc2da0de8de4ed322/immutables-0.21-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce604f81d9d8f26e60b52ebcb56bb5c0462c8ea50fb17868487d15f048a2f13e", size = 31537, upload-time = "2024-10-10T00:54:20.998Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/52/cb9e2bb7a69338155ffabbd2f993c968c750dd2d5c6c6eaa6ebb7bfcbdfa/immutables-0.21-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b48b116aaca4500398058b5a87814857a60c4cb09417fecc12d7da0f5639b73d", size = 104270, upload-time = "2024-10-10T00:54:21.912Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/a4/25df835a9b9b372a4a869a8a1ac30a32199f2b3f581ad0e249f7e3d19eed/immutables-0.21-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dad7c0c74b285cc0e555ec0e97acbdc6f1862fcd16b99abd612df3243732e741", size = 104864, upload-time = "2024-10-10T00:54:22.956Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/51/b548fbc657134d658e179ee8d201ae82d9049aba5c3cb2d858ed2ecb7e3f/immutables-0.21-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e44346e2221a5a676c880ca8e0e6429fa24d1a4ae562573f5c04d7f2e759b030", size = 99733, upload-time = "2024-10-10T00:54:23.99Z" },
+    { url = "https://files.pythonhosted.org/packages/47/db/d7b1e0e88faf07fe9a88579a86f58078a9a37fff871f4b3dbcf28cad9a12/immutables-0.21-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8b10139b529a460e53fe8be699ebd848c54c8a33ebe67763bcfcc809a475a26f", size = 101698, upload-time = "2024-10-10T00:54:25.734Z" },
+    { url = "https://files.pythonhosted.org/packages/69/2d/6fe42a1a053dd8cfb9f45e91d5246522637c7287dc6bd347f67aedf7aedb/immutables-0.21-cp312-cp312-win32.whl", hash = "sha256:fc512d808662614feb17d2d92e98f611d69669a98c7af15910acf1dc72737038", size = 30977, upload-time = "2024-10-10T00:54:27.436Z" },
+    { url = "https://files.pythonhosted.org/packages/63/45/d062aca6971e99454ce3ae42a7430037227fee961644ed1f8b6c9b99e0a5/immutables-0.21-cp312-cp312-win_amd64.whl", hash = "sha256:461dcb0f58a131045155e52a2c43de6ec2fe5ba19bdced6858a3abb63cee5111", size = 35088, upload-time = "2024-10-10T00:54:28.388Z" },
+]
+
 [[package]]
 name = "importlib-metadata"
 version = "8.7.1"
@@ -4573,6 +4660,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" },
 ]
 
+[[package]]
+name = "pulp"
+version = "3.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/16/1c/d880b739b841a8aa81143091c9bdda5e72e226a660aa13178cb312d4b27f/pulp-3.3.0.tar.gz", hash = "sha256:7eb99b9ce7beeb8bbb7ea9d1c919f02f003ab7867e0d1e322f2f2c26dd31c8ba", size = 16301847, upload-time = "2025-09-18T08:14:57.552Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/99/6c/64cafaceea3f99927e84b38a362ec6a8f24f33061c90bda77dfe1cd4c3c6/pulp-3.3.0-py3-none-any.whl", hash = "sha256:dd6ad2d63f196d1254eddf9dcff5cd224912c1f046120cb7c143c5b0eda63fae", size = 16387700, upload-time = "2025-09-18T08:14:53.368Z" },
+]
+
 [[package]]
 name = "pure-eval"
 version = "0.2.3"
@@ -5382,6 +5478,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
 ]
 
+[[package]]
+name = "reretry"
+version = "0.11.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/40/1d/25d562a62b7471616bccd7c15a7533062eb383927e68667bf331db990415/reretry-0.11.8.tar.gz", hash = "sha256:f2791fcebe512ea2f1d153a2874778523a8064860b591cd90afc21a8bed432e3", size = 4836, upload-time = "2022-12-18T11:08:50.641Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/66/11/e295e07d4ae500144177f875a8de11daa4d86b8246ab41c76a98ce9280ca/reretry-0.11.8-py2.py3-none-any.whl", hash = "sha256:5ec1084cd9644271ee386d34cd5dd24bdb3e91d55961b076d1a31d585ad68a79", size = 5609, upload-time = "2022-12-18T11:08:49.1Z" },
+]
+
 [[package]]
 name = "rfc3339-validator"
 version = "0.1.4"
@@ -5871,6 +5976,135 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ad/95/bc978be7ea0babf2fb48a414b6afaad414c6a9e8b1eafc5b8a53c030381a/smart_open-7.5.0-py3-none-any.whl", hash = "sha256:87e695c5148bbb988f15cec00971602765874163be85acb1c9fb8abc012e6599", size = 63940, upload-time = "2025-11-08T21:38:39.024Z" },
 ]
 
+[[package]]
+name = "smmap"
+version = "5.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329, upload-time = "2025-01-02T07:14:40.909Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303, upload-time = "2025-01-02T07:14:38.724Z" },
+]
+
+[[package]]
+name = "snakemake"
+version = "9.14.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "appdirs" },
+    { name = "conda-inject" },
+    { name = "configargparse" },
+    { name = "connection-pool" },
+    { name = "docutils" },
+    { name = "dpath" },
+    { name = "gitpython" },
+    { name = "humanfriendly" },
+    { name = "immutables" },
+    { name = "jinja2" },
+    { name = "jsonschema" },
+    { name = "nbformat" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pulp" },
+    { name = "pyyaml" },
+    { name = "referencing" },
+    { name = "requests" },
+    { name = "reretry" },
+    { name = "smart-open" },
+    { name = "snakemake-interface-common" },
+    { name = "snakemake-interface-executor-plugins" },
+    { name = "snakemake-interface-logger-plugins" },
+    { name = "snakemake-interface-report-plugins" },
+    { name = "snakemake-interface-scheduler-plugins" },
+    { name = "snakemake-interface-storage-plugins" },
+    { name = "tabulate" },
+    { name = "throttler" },
+    { name = "wrapt" },
+    { name = "yte" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0c/28/b6ad097922b45a85f792bdf9b4f823ee6f37e72d80d471d0b13262309398/snakemake-9.14.5.tar.gz", hash = "sha256:f66b181806f02f9d7f43542bd85091a2e65ab126dfcb7bd869a622917d786bfb", size = 6745401, upload-time = "2025-12-15T13:55:25.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/a7/a13ec64b15cbd3dd0797847cb529e118e939d46968e80d0cdf7f5c638374/snakemake-9.14.5-py3-none-any.whl", hash = "sha256:a0f23d2250918553d283675051486f75c14f9fc33217a65810fefd52e292d390", size = 1132670, upload-time = "2025-12-15T13:55:23.721Z" },
+]
+
+[[package]]
+name = "snakemake-interface-common"
+version = "1.22.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "argparse-dataclass" },
+    { name = "configargparse" },
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fd/be/cbd3f30c24eecb0e7d48f7025c770b7dc664124a01c8d9df6da73eb4fbd1/snakemake_interface_common-1.22.0.tar.gz", hash = "sha256:ef1fa710a15629be4cc352b938596ab5235ecf0b615c5845f086d6c5da10cb88", size = 13859, upload-time = "2025-09-30T17:11:00.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/c4/2da11760cebae7cfc66304ce5dccbabf9f1323e3e0ab8091960b84ad2bd6/snakemake_interface_common-1.22.0-py3-none-any.whl", hash = "sha256:a68c57cba8569536195fc9b7db07bc2a91b56ad811636585dae0313b2ca2e1ce", size = 16840, upload-time = "2025-09-30T17:10:59.594Z" },
+]
+
+[[package]]
+name = "snakemake-interface-executor-plugins"
+version = "9.3.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "argparse-dataclass" },
+    { name = "snakemake-interface-common" },
+    { name = "throttler" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/51/e62e14090393d6688e7d4026a574f0a9de14ffb678bc4c6993306fc3e62a/snakemake_interface_executor_plugins-9.3.9.tar.gz", hash = "sha256:988ab388d48522fac84107867ae3f3398312b93b55df6ed7b99afc225468ca26", size = 16530, upload-time = "2025-07-29T15:34:21.993Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/8b/fec4419acedfa5924549f40664cb2134f2ea5fae3d8a39df5e24035df06a/snakemake_interface_executor_plugins-9.3.9-py3-none-any.whl", hash = "sha256:bae310d5e258d5504731cca69d73051cd5ae1702d46fa66c03ef947be27fe09a", size = 22511, upload-time = "2025-07-29T15:34:20.472Z" },
+]
+
+[[package]]
+name = "snakemake-interface-logger-plugins"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "snakemake-interface-common" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/92/2fe4fa879a5d4408cad6db5330cd4ebd352e47529cb0fdfdf8ebf73f2920/snakemake_interface_logger_plugins-2.0.0.tar.gz", hash = "sha256:0e8ff2af4c55ca140d6ea1c1540e733a4b3944abae48fe0eaf6a707e5797cd17", size = 13767, upload-time = "2025-09-28T19:51:55.094Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c3/1f/f0848d750e7ca675e2cc0ea5e14135f432db498e8ad8cf746a19108e9d55/snakemake_interface_logger_plugins-2.0.0-py3-none-any.whl", hash = "sha256:c06a6779528a60f0362049c3adfb558e64d071769691718c810ef3057fdb9ff3", size = 12293, upload-time = "2025-09-28T19:51:53.556Z" },
+]
+
+[[package]]
+name = "snakemake-interface-report-plugins"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "snakemake-interface-common" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/d6/6160ed98de665d6871dd356597dbf726688cc786e88668359ca37b7d9f54/snakemake_interface_report_plugins-1.3.0.tar.gz", hash = "sha256:fc9495298bec4e69721ab8afe6d6d88a86966fda2eeb003db56b9a88b86d5934", size = 4283, upload-time = "2025-10-31T10:52:36.55Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f0/f0/df73f6abc9b5910e43612ae28c7b6f666af80c4edd46a216ef47599ab6cb/snakemake_interface_report_plugins-1.3.0-py3-none-any.whl", hash = "sha256:78da3931f70e79eef51e5645a40b172929e555fe4d86ff45d6b856e521a379db", size = 7251, upload-time = "2025-10-31T10:52:35.474Z" },
+]
+
+[[package]]
+name = "snakemake-interface-scheduler-plugins"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "snakemake-interface-common" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/88/d9/d480807d2cfc2d132bc760d877d45ec8fbe620a24200ec4d2697c4a26031/snakemake_interface_scheduler_plugins-2.0.2.tar.gz", hash = "sha256:2797e8fa9019d983132c2b403f14d6fcd3c5ad4c8d8a66b984b4740a71cacc46", size = 8642, upload-time = "2025-10-20T13:58:12.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/d0/f4e9894c8aaf37efe3bf1afe15ee3cf0546d82b2713a589e266ee47bf2ef/snakemake_interface_scheduler_plugins-2.0.2-py3-none-any.whl", hash = "sha256:b9ddfa508bd480711de1770dfb24f3b813cfa3cd0f862f0127ef721ae5346915", size = 10766, upload-time = "2025-10-20T13:58:11.898Z" },
+]
+
+[[package]]
+name = "snakemake-interface-storage-plugins"
+version = "4.3.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "reretry" },
+    { name = "snakemake-interface-common" },
+    { name = "throttler" },
+    { name = "wrapt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d4/0c/906d09e4e99733b605a5b24b03fcdbe40c47787c770aea42421f225f9171/snakemake_interface_storage_plugins-4.3.2.tar.gz", hash = "sha256:2f45c6b784e2af5b6e7102d3cb700d597b7cf7515fcf02d7d1153065e90a7895", size = 14543, upload-time = "2025-12-01T13:30:30.754Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/80/7e/51e4d50494725c77116fc3978879babe1a15336d9b144bba061ec968e02a/snakemake_interface_storage_plugins-4.3.2-py3-none-any.whl", hash = "sha256:bd185233cb7882a58d79294ad2f8d1cead535744fe3c9d42d9ef51bc8f1744b1", size = 17800, upload-time = "2025-12-01T13:30:29.699Z" },
+]
+
 [[package]]
 name = "sniffio"
 version = "1.3.1"
@@ -6239,6 +6473,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
 ]
 
+[[package]]
+name = "tabulate"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" },
+]
+
 [[package]]
 name = "templateflow"
 version = "25.1.1"
@@ -6335,6 +6578,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },
 ]
 
+[[package]]
+name = "throttler"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b4/22/638451122136d5280bc477c8075ea448b9ebdfbd319f0f120edaecea2038/throttler-1.2.2.tar.gz", hash = "sha256:d54db406d98e1b54d18a9ba2b31ab9f093ac64a0a59d730c1cf7bb1cdfc94a58", size = 7970, upload-time = "2022-11-22T19:08:57.847Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/d4/36bf6010b184286000b2334622bfb3446a40c22c1d2a9776bff025cb0fe5/throttler-1.2.2-py3-none-any.whl", hash = "sha256:fc6ae612a2529e01110b32335af40375258b98e3b81232ec77cd07f51bf71392", size = 7609, upload-time = "2022-11-22T19:08:55.699Z" },
+]
+
 [[package]]
 name = "tifffile"
 version = "2025.12.20"
@@ -6936,6 +7188,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" },
 ]
 
+[[package]]
+name = "yte"
+version = "1.9.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "argparse-dataclass" },
+    { name = "dpath" },
+    { name = "pyyaml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/44/f5/7e44620e6e077bfe624b9a17c329b8e0d0159e176e1f1a93c2790428ab2c/yte-1.9.4.tar.gz", hash = "sha256:86a47e6d722cec9419a7ac88be57d0d6c4ce28f02860393b71a66f2c674069f6", size = 8101, upload-time = "2025-11-27T12:55:00.85Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/63/6a44729fdc60eb255a7b156a84e7552290174a9bf151e3b6c18e83d6fbfa/yte-1.9.4-py3-none-any.whl", hash = "sha256:5dac63303d3e6bc2ebadc36ece3c3fb09343772fe6e25e9356d9baf8f9dfaf6d", size = 10618, upload-time = "2025-11-27T12:55:01.685Z" },
+]
+
 [[package]]
 name = "zarr"
 version = "3.1.5"

From 4e455a28a673a1414776b0f15d3b3e73047f433a Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 09:05:45 -0800
Subject: [PATCH 65/87] Extract Prefect workflow params to config file, update
 output folders
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Create prefect_workflow/config/config.yaml with all workflow parameters
- Add load_config() function to flows.py for YAML config loading
- Update run_workflow() and analyze_single_cell_type() to accept config_path
- Add --config CLI argument to run_workflow.py
- Change Prefect output folder from "workflow" to "wf_prefect"
- Change Snakemake output folder from "workflow" to "wf_snakemake"
- Update WORKFLOW_OVERVIEW.md to reflect new output structure

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          |  12 ++
 .../prefect_workflow/config/config.yaml       |  75 +++++++++
 .../rnaseq/prefect_workflow/flows.py          | 144 ++++++++++--------
 .../rnaseq/prefect_workflow/run_workflow.py   |  43 +++---
 .../rnaseq/snakemake_workflow/Snakefile       |  10 +-
 .../snakemake_workflow/WORKFLOW_OVERVIEW.md   |  12 +-
 6 files changed, 206 insertions(+), 90 deletions(-)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/prefect_workflow/config/config.yaml

diff --git a/problems_to_solve.md b/problems_to_solve.md
index cca966d..ee73576 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -3,6 +3,18 @@
 Open problems marked with [ ]
 Fixed problems marked with [x]
 
+[x] For the Prefect workflow, the default parameters for each workflow module are embedded in the python code for the workflow. I would rather that they be defined using a configuration file.  Please extract all of the parameters into a configuration file (using whatever format you think is most appropriate) and read those in during workflow execution rather than hard-coding.
+    - Created `prefect_workflow/config/config.yaml` with all workflow parameters
+    - Parameters organized by step: filtering, qc, preprocessing, dimred, clustering, pseudobulk, differential_expression, pathway_analysis, overrepresentation, predictive_modeling
+    - Added `load_config()` function to flows.py that loads from YAML file
+    - Updated `run_workflow()` and `analyze_single_cell_type()` to accept `config_path` parameter
+    - Added `--config` CLI argument to run_workflow.py
+    - Default config bundled with package; custom configs can be specified via CLI
+[x] For the Prefect workflow, please save the output to a folder called "wf_prefect" (rather than "workflow")
+    - Updated all output directories in flows.py and run_workflow.py to use `wf_prefect/` instead of `workflow/`
+[x] For the Snakemake workflow, please save the output to a folder called "wf_snakemake" (rather than "workflow")
+    - Updated Snakefile to use `wf_snakemake/` for CHECKPOINT_DIR, RESULTS_DIR, FIGURE_DIR, LOG_DIR
+    - Updated WORKFLOW_OVERVIEW.md to reflect new output structure
 
 [x] I would now like to add another workflow, with code saved to src/BetterCodeBetterScience/rnaseq/snakemake_workflow. This workflow will use the Snakemake workflow manager (https://snakemake.readthedocs.io/en/stable/index.html); otherwise it should be functionally equivalent to the other workflows already developed.
     - Created `snakemake_workflow/` directory with:
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/config/config.yaml b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/config/config.yaml
new file mode 100644
index 0000000..e4043e2
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/config/config.yaml
@@ -0,0 +1,75 @@
+# Configuration for Prefect scRNA-seq immune aging workflow
+#
+# Usage:
+#   python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --config /path/to/config.yaml
+#
+# Override any parameter via CLI:
+#   python ... --dataset-name MyDataset --force-from 5
+
+# Dataset configuration
+dataset_name: "OneK1K"
+url: "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad"
+
+# Step 2: Filtering parameters
+filtering:
+  cutoff_percentile: 1.0
+  min_cells_per_celltype: 10
+  percent_donors: 0.95
+
+# Step 3: QC parameters
+qc:
+  min_genes: 200
+  max_genes: 6000
+  min_counts: 500
+  max_counts: 30000
+  max_hb_pct: 5.0
+  expected_doublet_rate: 0.06
+
+# Step 4: Preprocessing parameters
+preprocessing:
+  target_sum: 10000
+  n_top_genes: 3000
+  batch_key: "donor_id"
+
+# Step 5: Dimensionality reduction parameters
+dimred:
+  batch_key: "donor_id"
+  n_neighbors: 30
+  n_pcs: 40
+
+# Step 6: Clustering parameters
+clustering:
+  resolution: 1.0
+
+# Step 7: Pseudobulking parameters
+pseudobulk:
+  group_col: "cell_type"
+  donor_col: "donor_id"
+  metadata_cols:
+    - "development_stage"
+    - "sex"
+  min_cells: 10
+
+# Steps 8-11: Per-cell-type analysis parameters
+differential_expression:
+  design_factors:
+    - "age_scaled"
+    - "sex"
+  n_cpus: 8
+
+pathway_analysis:
+  gene_sets:
+    - "MSigDB_Hallmark_2020"
+  n_top: 10
+
+overrepresentation:
+  gene_sets:
+    - "MSigDB_Hallmark_2020"
+  padj_threshold: 0.05
+  n_top: 10
+
+predictive_modeling:
+  n_splits: 5
+
+# Minimum samples per cell type for per-cell-type analysis
+min_samples_per_cell_type: 10
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
index d57a9f7..ef40fdc 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py
@@ -8,6 +8,7 @@
 from pathlib import Path
 from typing import Any
 
+import yaml
 from prefect import flow, get_run_logger
 
 from BetterCodeBetterScience.rnaseq.prefect_workflow.tasks import (
@@ -33,6 +34,31 @@
 )
 
 
+def get_default_config_path() -> Path:
+    """Get the path to the default config file bundled with the package."""
+    return Path(__file__).parent / "config" / "config.yaml"
+
+
+def load_config(config_path: Path | None = None) -> dict[str, Any]:
+    """Load workflow configuration from YAML file.
+
+    Parameters
+    ----------
+    config_path : Path, optional
+        Path to config file. If None, uses the default config bundled with the package.
+
+    Returns
+    -------
+    dict
+        Configuration dictionary
+    """
+    if config_path is None:
+        config_path = get_default_config_path()
+
+    with open(config_path) as f:
+        return yaml.safe_load(f)
+
+
 def setup_file_logging(log_dir: Path) -> tuple[Path, logging.FileHandler]:
     """Set up file-based logging for the workflow.
 
@@ -73,10 +99,8 @@ def setup_file_logging(log_dir: Path) -> tuple[Path, logging.FileHandler]:
 @flow(name="immune_aging_scrna_workflow", log_prints=False)
 def run_workflow(
     datadir: Path,
-    dataset_name: str = "OneK1K",
-    url: str = "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad",
+    config_path: Path | None = None,
     force_from_step: int | None = None,
-    min_samples_per_cell_type: int = 10,
 ) -> dict[str, Any]:
     """Run the complete immune aging scRNA-seq workflow with Prefect.
 
@@ -86,14 +110,10 @@ def run_workflow(
     ----------
     datadir : Path
         Base directory for data files
-    dataset_name : str
-        Name of the dataset
-    url : str
-        URL to download data from
+    config_path : Path, optional
+        Path to config file. If None, uses the default config bundled with the package.
     force_from_step : int, optional
         If provided, forces re-run from this step onwards
-    min_samples_per_cell_type : int
-        Minimum samples required per cell type to run steps 8-11
 
     Returns
     -------
@@ -102,17 +122,23 @@ def run_workflow(
     """
     logger = get_run_logger()
 
-    # Setup directories
-    figure_dir = datadir / "workflow/figures"
+    # Load configuration
+    config = load_config(config_path)
+    dataset_name = config["dataset_name"]
+    url = config["url"]
+    min_samples_per_cell_type = config["min_samples_per_cell_type"]
+
+    # Setup directories (using wf_prefect folder)
+    figure_dir = datadir / "wf_prefect/figures"
     figure_dir.mkdir(parents=True, exist_ok=True)
 
-    checkpoint_dir = datadir / "workflow/checkpoints"
+    checkpoint_dir = datadir / "wf_prefect/checkpoints"
     checkpoint_dir.mkdir(parents=True, exist_ok=True)
 
-    results_dir = datadir / "workflow/results/per_cell_type"
+    results_dir = datadir / "wf_prefect/results/per_cell_type"
     results_dir.mkdir(parents=True, exist_ok=True)
 
-    log_dir = datadir / "workflow/logs"
+    log_dir = datadir / "wf_prefect/logs"
     log_dir.mkdir(parents=True, exist_ok=True)
 
     # Set up file logging
@@ -163,11 +189,7 @@ def run_workflow(
         logger.info("STEP 2: DATA FILTERING")
         logger.info("=" * 60)
 
-        step2_params = {
-            "cutoff_percentile": 1.0,
-            "min_cells_per_celltype": 10,
-            "percent_donors": 0.95,
-        }
+        step2_params = config["filtering"]
         step_record = execution_log.add_step(
             step_number=2,
             step_name="data_filtering",
@@ -198,14 +220,7 @@ def run_workflow(
         logger.info("STEP 3: QUALITY CONTROL")
         logger.info("=" * 60)
 
-        step3_params = {
-            "min_genes": 200,
-            "max_genes": 6000,
-            "min_counts": 500,
-            "max_counts": 30000,
-            "max_hb_pct": 5.0,
-            "expected_doublet_rate": 0.06,
-        }
+        step3_params = config["qc"]
         step_record = execution_log.add_step(
             step_number=3,
             step_name="quality_control",
@@ -234,11 +249,7 @@ def run_workflow(
         logger.info("STEP 4: PREPROCESSING")
         logger.info("=" * 60)
 
-        step4_params = {
-            "target_sum": 1e4,
-            "n_top_genes": 3000,
-            "batch_key": "donor_id",
-        }
+        step4_params = config["preprocessing"]
         step_record = execution_log.add_step(
             step_number=4,
             step_name="preprocessing",
@@ -265,11 +276,7 @@ def run_workflow(
         logger.info("STEP 5: DIMENSIONALITY REDUCTION")
         logger.info("=" * 60)
 
-        step5_params = {
-            "batch_key": "donor_id",
-            "n_neighbors": 30,
-            "n_pcs": 40,
-        }
+        step5_params = config["dimred"]
         step_record = execution_log.add_step(
             step_number=5,
             step_name="dimensionality_reduction",
@@ -297,7 +304,7 @@ def run_workflow(
         logger.info("STEP 6: CLUSTERING")
         logger.info("=" * 60)
 
-        step6_params = {"resolution": 1.0}
+        step6_params = config["clustering"]
         step_record = execution_log.add_step(
             step_number=6,
             step_name="clustering",
@@ -323,12 +330,7 @@ def run_workflow(
         logger.info("STEP 7: PSEUDOBULKING")
         logger.info("=" * 60)
 
-        step7_params = {
-            "group_col": "cell_type",
-            "donor_col": "donor_id",
-            "metadata_cols": ["development_stage", "sex"],
-            "min_cells": 10,
-        }
+        step7_params = config["pseudobulk"]
         step_record = execution_log.add_step(
             step_number=7,
             step_name="pseudobulking",
@@ -393,15 +395,21 @@ def run_workflow(
         for i, cell_type in enumerate(valid_cell_types):
             logger.info(f"\n[{i + 1}/{len(valid_cell_types)}] Processing: {cell_type}")
 
+            # Get config for per-cell-type steps
+            de_config = config["differential_expression"]
+            gsea_config = config["pathway_analysis"]
+            enrichr_config = config["overrepresentation"]
+            pred_config = config["predictive_modeling"]
+
             # Log combined steps 8-11 for this cell type
             step_record = execution_log.add_step(
                 step_number=8,
                 step_name=f"per_cell_type_analysis ({cell_type})",
                 parameters=serialize_parameters(
                     cell_type=cell_type,
-                    design_factors=["age_scaled", "sex"],
-                    gene_sets=["MSigDB_Hallmark_2020"],
-                    n_splits=5,
+                    design_factors=de_config["design_factors"],
+                    gene_sets=gsea_config["gene_sets"],
+                    n_splits=pred_config["n_splits"],
                 ),
             )
 
@@ -412,8 +420,8 @@ def run_workflow(
                     cell_type=cell_type,
                     var_to_feature=var_to_feature,
                     output_dir=results_dir,
-                    design_factors=["age_scaled", "sex"],
-                    n_cpus=8,
+                    design_factors=de_config["design_factors"],
+                    n_cpus=de_config["n_cpus"],
                 )
 
                 # Get metadata for this cell type (for predictive modeling)
@@ -430,8 +438,8 @@ def run_workflow(
                     de_results=de_result["de_results"],
                     cell_type=cell_type,
                     output_dir=results_dir,
-                    gene_sets=["MSigDB_Hallmark_2020"],
-                    n_top=10,
+                    gene_sets=gsea_config["gene_sets"],
+                    n_top=gsea_config["n_top"],
                 )
 
                 # Step 10: Overrepresentation Analysis (Enrichr)
@@ -439,9 +447,9 @@ def run_workflow(
                     de_results=de_result["de_results"],
                     cell_type=cell_type,
                     output_dir=results_dir,
-                    gene_sets=["MSigDB_Hallmark_2020"],
-                    padj_threshold=0.05,
-                    n_top=10,
+                    gene_sets=enrichr_config["gene_sets"],
+                    padj_threshold=enrichr_config["padj_threshold"],
+                    n_top=enrichr_config["n_top"],
                 )
 
                 # Step 11: Predictive Modeling
@@ -450,7 +458,7 @@ def run_workflow(
                     metadata=metadata_ct,
                     cell_type=cell_type,
                     output_dir=results_dir,
-                    n_splits=5,
+                    n_splits=pred_config["n_splits"],
                 )
 
                 all_results["per_cell_type"][cell_type] = {
@@ -515,7 +523,7 @@ def run_workflow(
 def analyze_single_cell_type(
     datadir: Path,
     cell_type: str,
-    dataset_name: str = "OneK1K",
+    config_path: Path | None = None,
 ) -> dict[str, Any]:
     """Run analysis for a single cell type (useful for debugging/testing).
 
@@ -527,8 +535,8 @@ def analyze_single_cell_type(
         Base directory for data files
     cell_type : str
         Cell type to analyze
-    dataset_name : str
-        Name of the dataset
+    config_path : Path, optional
+        Path to config file. If None, uses the default config bundled with the package.
 
     Returns
     -------
@@ -537,8 +545,16 @@ def analyze_single_cell_type(
     """
     logger = get_run_logger()
 
-    checkpoint_dir = datadir / "workflow/checkpoints"
-    results_dir = datadir / "workflow/results/per_cell_type"
+    # Load configuration
+    config = load_config(config_path)
+    dataset_name = config["dataset_name"]
+    de_config = config["differential_expression"]
+    gsea_config = config["pathway_analysis"]
+    enrichr_config = config["overrepresentation"]
+    pred_config = config["predictive_modeling"]
+
+    checkpoint_dir = datadir / "wf_prefect/checkpoints"
+    results_dir = datadir / "wf_prefect/results/per_cell_type"
     results_dir.mkdir(parents=True, exist_ok=True)
 
     # Load required checkpoints
@@ -567,6 +583,8 @@ def analyze_single_cell_type(
         cell_type=cell_type,
         var_to_feature=var_to_feature,
         output_dir=results_dir,
+        design_factors=de_config["design_factors"],
+        n_cpus=de_config["n_cpus"],
     )
 
     # Get metadata
@@ -583,12 +601,17 @@ def analyze_single_cell_type(
         de_results=de_result["de_results"],
         cell_type=cell_type,
         output_dir=results_dir,
+        gene_sets=gsea_config["gene_sets"],
+        n_top=gsea_config["n_top"],
     )
 
     enrichr_result = overrepresentation_task(
         de_results=de_result["de_results"],
         cell_type=cell_type,
         output_dir=results_dir,
+        gene_sets=enrichr_config["gene_sets"],
+        padj_threshold=enrichr_config["padj_threshold"],
+        n_top=enrichr_config["n_top"],
     )
 
     prediction_result = predictive_modeling_task(
@@ -596,6 +619,7 @@ def analyze_single_cell_type(
         metadata=metadata_ct,
         cell_type=cell_type,
         output_dir=results_dir,
+        n_splits=pred_config["n_splits"],
     )
 
     return {
diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
index bc5e8ff..6247b55 100644
--- a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
+++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py
@@ -5,6 +5,9 @@
 
 Or with arguments:
     python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --force-from 8
+
+With custom config:
+    python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --config /path/to/config.yaml
 """
 
 import argparse
@@ -15,6 +18,7 @@
 
 from BetterCodeBetterScience.rnaseq.prefect_workflow.flows import (
     analyze_single_cell_type,
+    load_config,
     run_workflow,
 )
 
@@ -31,10 +35,11 @@ def main():
         help="Base directory for data files (default: from DATADIR env var)",
     )
     parser.add_argument(
-        "--dataset-name",
-        type=str,
-        default="OneK1K",
-        help="Name of the dataset (default: OneK1K)",
+        "--config",
+        type=Path,
+        default=None,
+        dest="config_path",
+        help="Path to config file (default: uses bundled config/config.yaml)",
     )
     parser.add_argument(
         "--force-from",
@@ -43,13 +48,6 @@ def main():
         dest="force_from_step",
         help="Force re-run from this step onwards (1-11)",
     )
-    parser.add_argument(
-        "--min-samples",
-        type=int,
-        default=10,
-        dest="min_samples",
-        help="Minimum samples per cell type for steps 8-11 (default: 10)",
-    )
     parser.add_argument(
         "--cell-type",
         type=str,
@@ -69,6 +67,16 @@ def main():
     # Load environment variables
     load_dotenv()
 
+    # Load configuration
+    config = load_config(args.config_path)
+    dataset_name = config["dataset_name"]
+    min_samples = config["min_samples_per_cell_type"]
+
+    if args.config_path:
+        print(f"Using config file: {args.config_path}")
+    else:
+        print("Using default bundled config")
+
     # Get data directory
     if args.datadir is not None:
         datadir = args.datadir
@@ -90,9 +98,9 @@ def main():
             load_checkpoint,
         )
 
-        checkpoint_dir = datadir / "workflow/checkpoints"
+        checkpoint_dir = datadir / "wf_prefect/checkpoints"
         pb_checkpoint = checkpoint_dir / bids_checkpoint_name(
-            args.dataset_name, 7, "pseudobulk"
+            dataset_name, 7, "pseudobulk"
         )
 
         if not pb_checkpoint.exists():
@@ -108,9 +116,7 @@ def main():
         print("-" * 60)
         for ct in sorted(cell_types):
             count = cell_type_counts[ct]
-            status = (
-                "OK" if count >= args.min_samples else f"< {args.min_samples} samples"
-            )
+            status = "OK" if count >= min_samples else f"< {min_samples} samples"
             print(f"  {ct}: {count} samples ({status})")
         return
 
@@ -120,7 +126,7 @@ def main():
         results = analyze_single_cell_type(
             datadir=datadir,
             cell_type=args.cell_type,
-            dataset_name=args.dataset_name,
+            config_path=args.config_path,
         )
         print("\nResults:")
         print(f"  DE genes: {len(results['de']['de_results'])}")
@@ -141,9 +147,8 @@ def main():
 
     results = run_workflow(
         datadir=datadir,
-        dataset_name=args.dataset_name,
+        config_path=args.config_path,
         force_from_step=args.force_from_step,
-        min_samples_per_cell_type=args.min_samples,
     )
 
     # Print summary
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
index 87b617b..7dcda81 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
@@ -53,11 +53,11 @@ if config.get("datadir") is None:
 DATADIR = Path(config["datadir"])
 DATASET = config["dataset_name"]
 
-# Derived paths
-CHECKPOINT_DIR = DATADIR / "workflow" / "checkpoints"
-RESULTS_DIR = DATADIR / "workflow" / "results"
-FIGURE_DIR = DATADIR / "workflow" / "figures"
-LOG_DIR = DATADIR / "workflow" / "logs"
+# Derived paths (using wf_snakemake folder)
+CHECKPOINT_DIR = DATADIR / "wf_snakemake" / "checkpoints"
+RESULTS_DIR = DATADIR / "wf_snakemake" / "results"
+FIGURE_DIR = DATADIR / "wf_snakemake" / "figures"
+LOG_DIR = DATADIR / "wf_snakemake" / "logs"
 
 
 # Include modular rule files
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
index ec4f27a..ab08ea9 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
@@ -20,13 +20,13 @@ The workflow is divided into two phases:
 │  Step 1: Download ──► Step 2: Filter ──► Step 3: QC ──► Step 4: Preprocess
 │                                                               │         │
 │                                                               ▼         │
-│                       Step 7: Pseudobulk ◄── Step 6: Cluster ◄── Step 5: DimRed
+│             Step 7: Pseudobulk ◄── Step 6: Cluster ◄── Step 5: DimRed.  |
 │                              │                                          │
 └──────────────────────────────┼──────────────────────────────────────────┘
                                │
                                ▼ (discovers N cell types)
 ┌──────────────────────────────────────────────────────────────────────────┐
-│                    PER-CELL-TYPE STEPS (8-11)                           │
+│                    PER-CELL-TYPE STEPS (8-11)                            │
 │                    Runs in parallel for each cell type                   │
 ├──────────────────────────────────────────────────────────────────────────┤
 │                                                                          │
@@ -34,11 +34,11 @@ The workflow is divided into two phases:
 │                                                                          │
 │    Step 8: Differential Expression                                       │
 │         │                                                                │
-│         ├──► Step 9: GSEA (Pathway Analysis)                            │
+│         ├──► Step 9: GSEA (Pathway Analysis)                             │
 │         │                                                                │
-│         ├──► Step 10: Enrichr (Overrepresentation)                      │
+│         ├──► Step 10: Enrichr (Overrepresentation)                       │
 │         │                                                                │
-│         └──► Step 11: Predictive Modeling (Age Prediction)              │
+│         └──► Step 11: Predictive Modeling (Age Prediction)               │
 │                                                                          │
 └──────────────────────────────────────────────────────────────────────────┘
 ```
@@ -314,7 +314,7 @@ The workflow is divided into two phases:
 ## Output Structure
 
 ```
-{datadir}/workflow/
+{datadir}/wf_snakemake/
 ├── checkpoints/
 │   ├── dataset-{name}_step-02_desc-filtered.h5ad
 │   ├── dataset-{name}_step-03_desc-qc.h5ad

From bb87992178aa979bb826180e6d47923a5496b57b Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 09:10:55 -0800
Subject: [PATCH 66/87] Add workflow documentation with usage examples
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Create RUNNING_WORKFLOWS.md covering all four workflow implementations:
- Monolithic: single script, no checkpointing
- Modular: reusable functions, basic skip functionality
- Stateless: BIDS checkpointing, execution logging
- Prefect: config file, all cell types, orchestration
- Snakemake: dynamic rules, parallel execution

Includes prerequisites, CLI options, configuration examples,
output locations, and comparison table.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/RUNNING_WORKFLOWS.md               | 441 ++++++++++++++++++
 1 file changed, 441 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/RUNNING_WORKFLOWS.md

diff --git a/src/BetterCodeBetterScience/rnaseq/RUNNING_WORKFLOWS.md b/src/BetterCodeBetterScience/rnaseq/RUNNING_WORKFLOWS.md
new file mode 100644
index 0000000..64b9c96
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/RUNNING_WORKFLOWS.md
@@ -0,0 +1,441 @@
+# Running the scRNA-seq Immune Aging Workflows
+
+This document provides examples of how to run each of the four workflow implementations for the immune aging scRNA-seq analysis.
+
+All workflows perform the same 11-step analysis pipeline:
+1. Data Download
+2. Data Filtering
+3. Quality Control
+4. Preprocessing
+5. Dimensionality Reduction
+6. Clustering
+7. Pseudobulking
+8. Differential Expression (per cell type)
+9. Pathway Analysis / GSEA (per cell type)
+10. Overrepresentation Analysis / Enrichr (per cell type)
+11. Predictive Modeling (per cell type)
+
+---
+
+## Prerequisites
+
+### Environment Setup
+
+All workflows require the `DATADIR` environment variable to be set, pointing to the base data directory. The workflows will create an `immune_aging/` subdirectory within this path.
+
+```bash
+# Option 1: Set environment variable directly
+export DATADIR=/path/to/your/data
+
+# Option 2: Create a .env file in your working directory
+echo "DATADIR=/path/to/your/data" > .env
+```
+
+### Install Dependencies
+
+```bash
+# From the repository root
+uv pip install -e .
+```
+
+---
+
+## 1. Monolithic Workflow
+
+The monolithic workflow is a single Python script that runs all analysis steps sequentially. It's the simplest implementation but lacks checkpointing and resumability.
+
+**Location:** `immune_scrnaseq_monolithic.py`
+
+### Running as a Script
+
+```bash
+# Edit the datadir path in the script first, then run:
+python src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
+```
+
+### Running as a Jupyter Notebook
+
+The script uses jupytext format and can be opened directly in Jupyter:
+
+```bash
+jupyter notebook src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py
+```
+
+### Output Location
+
+```
+{datadir}/workflow/figures/
+```
+
+### Notes
+
+- No checkpointing - must run from start each time
+- Analyzes only one cell type (hardcoded in script)
+- Best for understanding the analysis pipeline
+
+---
+
+## 2. Modular Workflow
+
+The modular workflow uses reusable pipeline functions organized by analysis step. It provides better code organization than the monolithic version but still lacks robust checkpointing.
+
+**Location:** `modular_workflow/run_workflow.py`
+
+### Running the Workflow
+
+```bash
+# Using environment variable
+export DATADIR=/path/to/your/data
+python -m BetterCodeBetterScience.rnaseq.modular_workflow.run_workflow
+
+# Or import and run programmatically
+python -c "
+from pathlib import Path
+from BetterCodeBetterScience.rnaseq.modular_workflow.run_workflow import run_full_workflow
+
+datadir = Path('/path/to/your/data/immune_aging')
+results = run_full_workflow(datadir)
+"
+```
+
+### Available Options
+
+The `run_full_workflow()` function accepts these parameters:
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `datadir` | Required | Base directory for data files |
+| `dataset_name` | "OneK1K" | Name of the dataset |
+| `url` | CELLxGENE URL | Source URL for the h5ad file |
+| `cell_type_for_de` | "central memory CD4-positive, alpha-beta T cell" | Cell type for differential expression |
+| `skip_download` | False | Skip data download if file exists |
+| `skip_filtering` | False | Load pre-filtered data |
+| `skip_qc` | False | Load post-QC data |
+
+### Output Location
+
+```
+{datadir}/workflow/figures/
+```
+
+### Notes
+
+- Basic skip functionality for early steps
+- Analyzes only one cell type
+- Outputs figures only (no result files saved)
+
+---
+
+## 3. Stateless Workflow (with Checkpointing)
+
+The stateless workflow adds robust checkpointing using BIDS-compliant naming. It can resume from any step and tracks execution history.
+
+**Location:** `stateless_workflow/run_workflow.py`
+
+### Running the Workflow
+
+```bash
+# Basic run (resumes from last checkpoint automatically)
+export DATADIR=/path/to/your/data
+python -m BetterCodeBetterScience.rnaseq.stateless_workflow.run_workflow
+```
+
+### Force Re-run from a Specific Step
+
+```python
+from pathlib import Path
+from BetterCodeBetterScience.rnaseq.stateless_workflow.run_workflow import (
+    run_stateless_workflow,
+    print_checkpoint_status,
+)
+
+datadir = Path('/path/to/your/data/immune_aging')
+
+# Check current checkpoint status
+print_checkpoint_status(datadir)
+
+# Force re-run from step 5 onwards
+results = run_stateless_workflow(datadir, force_from_step=5)
+```
+
+### Available Options
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `datadir` | Required | Base directory for data files |
+| `dataset_name` | "OneK1K" | Name of the dataset |
+| `url` | CELLxGENE URL | Source URL for the h5ad file |
+| `cell_type_for_de` | "central memory CD4-positive, alpha-beta T cell" | Cell type for differential expression |
+| `force_from_step` | None | Clear checkpoints from this step onwards |
+| `checkpoint_steps` | {2,3,5,8,9,10,11} | Which steps to save checkpoints for |
+
+### Utility Functions
+
+```python
+from BetterCodeBetterScience.rnaseq.stateless_workflow.run_workflow import (
+    list_checkpoints,
+    print_checkpoint_status,
+    list_execution_logs,
+    load_execution_log,
+)
+
+# List all checkpoints
+checkpoints = list_checkpoints(datadir)
+
+# Print checkpoint status with file sizes
+print_checkpoint_status(datadir)
+
+# View execution history
+logs = list_execution_logs(datadir)
+if logs:
+    log = load_execution_log(logs[0])  # Load most recent
+    log.print_summary()
+```
+
+### Output Location
+
+```
+{datadir}/workflow/
+├── checkpoints/    # BIDS-named checkpoint files
+├── figures/        # Visualization outputs
+└── logs/           # Execution logs (JSON)
+```
+
+### Notes
+
+- Automatic checkpointing and resumption
+- Execution logging with timing information
+- Analyzes only one cell type
+- Step 3 checkpoint required for pseudobulking
+
+---
+
+## 4. Prefect Workflow
+
+The Prefect workflow uses the Prefect orchestration framework and analyzes all cell types in parallel.
+
+**Location:** `prefect_workflow/run_workflow.py`
+
+### Running the Workflow
+
+```bash
+# Basic run with default config
+python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --datadir /path/to/data/immune_aging
+
+# With custom config file
+python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \
+    --datadir /path/to/data/immune_aging \
+    --config /path/to/custom_config.yaml
+
+# Force re-run from step 8
+python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \
+    --datadir /path/to/data/immune_aging \
+    --force-from 8
+```
+
+### List Available Cell Types
+
+```bash
+python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \
+    --datadir /path/to/data/immune_aging \
+    --list-cell-types
+```
+
+### Analyze a Single Cell Type
+
+```bash
+python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \
+    --datadir /path/to/data/immune_aging \
+    --cell-type "central memory CD4-positive, alpha-beta T cell"
+```
+
+### CLI Options
+
+| Option | Description |
+|--------|-------------|
+| `--datadir` | Base directory for data files |
+| `--config` | Path to custom config YAML file |
+| `--force-from` | Force re-run from this step onwards (1-11) |
+| `--cell-type` | Analyze a single cell type only |
+| `--list-cell-types` | List available cell types and exit |
+
+### Configuration File
+
+The default configuration is in `prefect_workflow/config/config.yaml`. You can create a custom config to override any parameters:
+
+```yaml
+# Custom config example
+dataset_name: "MyDataset"
+
+filtering:
+  cutoff_percentile: 2.0
+  min_cells_per_celltype: 20
+
+qc:
+  min_genes: 300
+  max_genes: 5000
+
+differential_expression:
+  n_cpus: 16
+
+min_samples_per_cell_type: 20
+```
+
+### Output Location
+
+```
+{datadir}/wf_prefect/
+├── checkpoints/           # BIDS-named checkpoint files
+├── figures/               # Visualization outputs
+├── results/per_cell_type/ # Per-cell-type analysis results
+│   └── {cell_type}/
+│       ├── stat_res.pkl
+│       ├── de_results.parquet
+│       ├── counts.parquet
+│       ├── gsea_results.pkl
+│       ├── enrichr_up.pkl
+│       ├── enrichr_down.pkl
+│       └── prediction_results.pkl
+└── logs/                  # Execution logs
+```
+
+### Notes
+
+- Analyzes ALL cell types (not just one)
+- Configuration via YAML file
+- Results saved per cell type
+- Uses Prefect for orchestration and logging
+
+---
+
+## 5. Snakemake Workflow
+
+The Snakemake workflow uses the Snakemake workflow management system with dynamic rule generation for per-cell-type analysis.
+
+**Location:** `snakemake_workflow/Snakefile`
+
+### Running the Workflow
+
+```bash
+cd src/BetterCodeBetterScience/rnaseq/snakemake_workflow
+
+# Run full workflow
+snakemake --cores 16 --config datadir=/path/to/data/immune_aging
+
+# Dry run (see what would be executed)
+snakemake -n --config datadir=/path/to/data/immune_aging
+
+# Run only preprocessing (steps 1-6)
+snakemake --cores 16 preprocessing_only --config datadir=/path/to/data/immune_aging
+
+# Run only through pseudobulking (steps 1-7)
+snakemake --cores 16 pseudobulk_only --config datadir=/path/to/data/immune_aging
+```
+
+### Force Re-run from a Specific Rule
+
+```bash
+# Force re-run from dimensionality reduction
+snakemake --cores 16 --forcerun dimensionality_reduction \
+    --config datadir=/path/to/data/immune_aging
+
+# Force re-run from a specific cell type's DE
+snakemake --cores 16 --forcerun differential_expression \
+    --config datadir=/path/to/data/immune_aging
+```
+
+### Configuration
+
+Configuration is in `snakemake_workflow/config/config.yaml`. Override any parameter via command line:
+
+```bash
+snakemake --cores 16 --config \
+    datadir=/path/to/data/immune_aging \
+    dataset_name=MyDataset \
+    min_samples_per_cell_type=20
+```
+
+### Generate Workflow Visualization
+
+```bash
+# Generate rule graph
+snakemake --rulegraph --config datadir=/path/to/data/immune_aging | dot -Tpng > rulegraph.png
+
+# Generate DAG for specific run
+snakemake --dag --config datadir=/path/to/data/immune_aging | dot -Tpng > dag.png
+```
+
+### Output Location
+
+```
+{datadir}/wf_snakemake/
+├── checkpoints/           # BIDS-named checkpoint files
+├── figures/               # Visualization outputs
+├── results/
+│   ├── per_cell_type/     # Per-cell-type analysis results
+│   │   └── {cell_type}/
+│   │       ├── stat_res.pkl
+│   │       ├── de_results.parquet
+│   │       ├── counts.parquet
+│   │       ├── gsea_results.pkl
+│   │       ├── enrichr_up.pkl
+│   │       ├── enrichr_down.pkl
+│   │       └── prediction_results.pkl
+│   └── workflow_complete.txt
+└── logs/                  # Step logs
+```
+
+### Notes
+
+- Uses Snakemake checkpoint mechanism for dynamic cell type discovery
+- Analyzes ALL cell types
+- Automatic dependency tracking and parallel execution
+- See `WORKFLOW_OVERVIEW.md` for detailed step documentation
+
+---
+
+## Workflow Comparison
+
+| Feature | Monolithic | Modular | Stateless | Prefect | Snakemake |
+|---------|------------|---------|-----------|---------|-----------|
+| Checkpointing | No | Limited | Yes | Yes | Yes |
+| Resume from step | No | Limited | Yes | Yes | Yes |
+| All cell types | No | No | No | Yes | Yes |
+| Config file | No | No | No | Yes | Yes |
+| Execution logs | No | No | Yes | Yes | Yes |
+| Parallel execution | No | No | No | Sequential | Yes |
+| Output folder | workflow | workflow | workflow | wf_prefect | wf_snakemake |
+
+---
+
+## Troubleshooting
+
+### Memory Issues
+
+The dataset is large (~1.2M cells). If you encounter memory issues:
+
+1. Use a machine with at least 64GB RAM
+2. For Prefect/Snakemake workflows, reduce `--cores` to limit parallel jobs
+3. For the stateless workflow, ensure checkpoints are saved to reduce memory pressure
+
+### Missing Dependencies
+
+```bash
+# Install all dependencies
+uv pip install -e ".[dev]"
+
+# For Snakemake specifically
+uv pip install snakemake>=8.0
+```
+
+### Environment Variable Not Set
+
+If you see "DATADIR environment variable not set":
+
+```bash
+# Set it for your session
+export DATADIR=/path/to/your/data
+
+# Or create .env file
+echo "DATADIR=/path/to/your/data" > .env
+```

From 487262374c6f7b150846188f71a09b41ca8deef5 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 09:33:11 -0800
Subject: [PATCH 67/87] clean up discussion of engines

---
 book/workflows.md | 68 +++++++----------------------------------------
 1 file changed, 9 insertions(+), 59 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index 0646b96..041d1f1 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -288,7 +288,7 @@ The use of DAGs to represent workflows provides a number of important benefits:
 - If one node of the graph changes, the engine can identify which downstream nodes need to be rerun
 - If a node fails, the engine can continue with executing the nodes that don't depend on the failed node either directly or indirectly
 
-Another benefit of using a workflow engine is that they generally deal automatically with checkpointing and caching of intermediate results.  
+There are a couple of additional benefits to using a workflow engine. The first is that they generally deal automatically with checkpointing and caching of intermediate results.  The second is that the workflow engine uses the execution graph to optimize the computation, only performing those operations that are actually needed.  This is similar in spirit to the concept of *lazy execution* used by packages like Polars, in which the system optimizes computational efficiency by first analyzing the full computational graph.
 
 #### General-purpose versus domain-specific workflow engines
 
@@ -296,14 +296,19 @@ With the growth of data science within industry and research, there has been an
 
 It's also worth noting that there are a number of domain-specific workflow engines that are specialized for particular kinds of data and workflows.  Examples include [Galaxy](https://galaxyproject.org/) which is specialized for bioinformatics and genomics, and [Nipype](https://nipype.readthedocs.io/en/latest/index.html) which is specialized for neuroimaging analysis workflows. If your research community uses one of these then it's worth exploring that engine as your first option, since it will probably be well supported within the community. However, a benefit of using a general-purpose engine is that they will often be better maintained and supported, and AI tools will likely have more examples to work from in generating workflows.
 
-#### A language-specific workflow management example: Prefect
+### A language-specific workflow management example: Prefect
 
 
+#### Configuration management
 
+The initial version of the Prefect workflow generated by Claude had the default parameter settings for each workflow hard-coded into the task definitions in Python.  This is not a great practice, since it means that any changes in parameter settings require changes in the code, making it difficult to easily test different parameter settings.  A better practice is to put the parameter settings into a human-editable configuration file, which can be specified upon execution of the workflow.  YAML is a common markup language for configuration files, which is used in both this workflow and the following one.
 
-#### A general-purpose workflow management example: Snakemake
 
 
+### A general-purpose workflow management example: Snakemake
+
+
+#### Pipeline optimization
 
 The first time that I ran my workflow using snakemake, I noticed that it was substantially slower than when I ran it with Prefect.  When I asked Claude about this, it gave me a reasonable answer:
 
@@ -319,64 +324,9 @@ I asked Claude to fix this, and it returned the following change:
 >  4. Set NUMBA_NUM_THREADS and OMP_NUM_THREADS environment variables in dimred.py
 >   In contrast, Prefect tasks run in the main process with access to all CPUs by default, which is why it was faster.
 
-This solves the problem but it's an odd choice: in particular, it will probably fail if there are fewer than 8 threads available on the system. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might fail if the requested number of cores are not available. We will discuss optimization further in a later chapter.
-
-
-## Modularity and reusability
-
-- separate analysis logic from workflow orchestration
-- analysis modules should be tested (e.g. with synthetic data)
-
-
-
-## Idempotency
-
-- running it multiple time should give same answer as running it once
-- 
-
-- somewhere talk about in-place operations and their challenges
-
-- local mutation - never change an object that is passed in as an argument
-    - always copy
-    - if the package uses copy-on-write then this is cheap (only copied metadata)
-    - this is not default in pandas 1.x but coming in 2.x
-        - google says it's possible using pd.options.mode.copy_on_write = True - need to confirm
-    - need to check for other frameworks
-
-- lazy frames (polars)
-
-- any function that must mutate in place should do so clearly
-    - e.g. normalize_(x) (apparently pytorch style for mutating functions?)
-    - or using "inplace" in the function name
-
-
-- can encode state in type (e.g. a lightweight class that tracks state ,e.g. "NormalizedArray")
-- or track stage explicitly (e.g. Dataset(stage='normalized', data=array))
-
-- use zarr to save each pipeline step as a new group:
-
-dataset.zarr/
-├── raw/
-│   └── signal
-├── zscored/
-│   └── signal
-├── filtered/
-│   └── signal
-
-- can also store parameters as attrs in zarr
-- e.g. z.attrs.update({
-    "stage": "zscore",
-    "mean_method": "time",
-    "std_ddof": 1,
-})
-
-
-also look at arrow for columnar data - look into arrow immutability
-
+This solves the problem but it's an odd choice: in particular, it will probably fail if there are fewer than 8 threads available on the system. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might fail if the requested number of cores are not available. We will discuss optimization in much greater detail in a later chapter.
 
-## Deferred execution
 
-- dask, xarray
 
 
 ## Tracking provenance

From 63cccd45a0ea95d3b4c847bfca05487f4efe6b18 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 10:03:58 -0800
Subject: [PATCH 68/87] Add Snakemake report generation for workflow results
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add report/ directory with RST caption files for each figure type
- Add global report declaration to Snakefile
- Update preprocessing.smk rules to declare figures as outputs with report() wrapper
- Update pseudobulk.smk checkpoint to include figure with report() wrapper
- Update per_cell_type.smk rules to include figures with report() wrapper and subcategory
- Update common.smk aggregate function to include figure files
- Add report and report-zip targets to Makefile
- Update WORKFLOW_OVERVIEW.md with report generation documentation

Usage: snakemake --report report.html --config datadir=/path/to/data

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          | 11 +++++
 .../rnaseq/snakemake_workflow/Makefile        | 25 +++++++++-
 .../rnaseq/snakemake_workflow/Snakefile       |  4 ++
 .../snakemake_workflow/WORKFLOW_OVERVIEW.md   | 44 +++++++++++++++++
 .../snakemake_workflow/report/clustering.rst  |  4 ++
 .../snakemake_workflow/report/de_results.rst  |  4 ++
 .../report/doublet_umap.rst                   |  4 ++
 .../snakemake_workflow/report/enrichr.rst     |  4 ++
 .../snakemake_workflow/report/filtering.rst   |  4 ++
 .../rnaseq/snakemake_workflow/report/gsea.rst |  4 ++
 .../snakemake_workflow/report/hemoglobin.rst  |  4 ++
 .../rnaseq/snakemake_workflow/report/pca.rst  |  4 ++
 .../snakemake_workflow/report/prediction.rst  |  4 ++
 .../snakemake_workflow/report/pseudobulk.rst  |  4 ++
 .../snakemake_workflow/report/qc_scatter.rst  |  5 ++
 .../snakemake_workflow/report/qc_violin.rst   |  8 ++++
 .../rnaseq/snakemake_workflow/report/umap.rst |  4 ++
 .../snakemake_workflow/report/workflow.rst    | 29 +++++++++++
 .../snakemake_workflow/rules/common.smk       |  4 ++
 .../rules/per_cell_type.smk                   | 18 +++++++
 .../rules/preprocessing.smk                   | 48 +++++++++++++++++--
 .../snakemake_workflow/rules/pseudobulk.smk   |  6 +++
 22 files changed, 241 insertions(+), 5 deletions(-)
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/clustering.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/de_results.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/doublet_umap.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/enrichr.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/filtering.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/gsea.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/hemoglobin.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pca.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/prediction.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pseudobulk.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_scatter.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_violin.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/umap.rst
 create mode 100644 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/workflow.rst

diff --git a/problems_to_solve.md b/problems_to_solve.md
index ee73576..94a86b1 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -3,6 +3,17 @@
 Open problems marked with [ ]
 Fixed problems marked with [x]
 
+[x] For the Snakemake workflow I would like to use the Snakemake report generating functions to create a report showing the results from each of the analyses.
+    - Added `report: "report/workflow.rst"` global declaration to Snakefile
+    - Created `report/` directory with RST caption files for each figure type
+    - Updated preprocessing.smk rules (filtering, qc, dimred, clustering) to declare figures as outputs with `report()` wrapper
+    - Updated pseudobulk.smk checkpoint to include pseudobulk figure with `report()` wrapper
+    - Updated per_cell_type.smk rules (GSEA, Enrichr, prediction) to include figures with `report()` wrapper and cell_type subcategory
+    - Updated common.smk `aggregate_per_cell_type_outputs()` to include figure files
+    - Added `report` and `report-zip` targets to Makefile
+    - Updated WORKFLOW_OVERVIEW.md with report generation documentation
+    - Usage: `snakemake --report report.html --config datadir=/path/to/data` or `make report`
+
 [x] For the Prefect workflow, the default parameters for each workflow module are embedded in the python code for the workflow. I would rather that they be defined using a configuration file.  Please extract all of the parameters into a configuration file (using whatever format you think is most appropriate) and read those in during workflow execution rather than hard-coding.
     - Created `prefect_workflow/config/config.yaml` with all workflow parameters
     - Parameters organized by step: filtering, qc, preprocessing, dimred, clustering, pseudobulk, differential_expression, pathway_analysis, overrepresentation, predictive_modeling
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
index 52d3e71..0947d14 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
@@ -1,5 +1,28 @@
 include ../../../../.env
-export 
+export
 
+# Generate rule dependency graph
 rulegraph:
 	snakemake --rulegraph --config datadir=$(DATADIR)/immune_aging/workflow/ --cores 2 | dot -Tpng > rulegraph.png
+
+# Run the full workflow
+run:
+	snakemake --cores 8 --config datadir=$(DATADIR)/immune_aging/workflow/
+
+# Generate HTML report (run after workflow completes)
+report:
+	snakemake --report $(DATADIR)/immune_aging/workflow/wf_snakemake/report.html --config datadir=$(DATADIR)/immune_aging/workflow/
+
+# Generate ZIP report (for larger reports with many figures)
+report-zip:
+	snakemake --report $(DATADIR)/immune_aging/workflow/wf_snakemake/report.zip --config datadir=$(DATADIR)/immune_aging/workflow/
+
+# Dry run - show what would be executed
+dry-run:
+	snakemake -n --config datadir=$(DATADIR)/immune_aging/workflow/
+
+# Clean all outputs
+clean:
+	rm -rf $(DATADIR)/immune_aging/workflow/wf_snakemake/
+
+.PHONY: rulegraph run report report-zip dry-run clean
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
index 7dcda81..796a140 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile
@@ -44,6 +44,10 @@ min_version("8.0")
 configfile: "config/config.yaml"
 
 
+# Global report description
+report: "report/workflow.rst"
+
+
 # Validate required config
 if config.get("datadir") is None:
     raise ValueError(
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
index ab08ea9..b39b832 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md
@@ -363,6 +363,50 @@ snakemake --cores 16 preprocessing_only --config datadir=/path/to/data
 
 # Force re-run from a specific step
 snakemake --cores 16 --forcerun dimensionality_reduction --config datadir=/path/to/data
+
+# Generate HTML report (after workflow completes)
+snakemake --report /path/to/data/wf_snakemake/report.html --config datadir=/path/to/data
+
+# Generate ZIP report (for larger reports)
+snakemake --report /path/to/data/wf_snakemake/report.zip --config datadir=/path/to/data
+```
+
+---
+
+## Report Generation
+
+The workflow includes Snakemake's built-in report generation functionality. After the workflow completes, you can generate a self-contained HTML report that includes:
+
+- **Runtime statistics**: Execution times for each rule
+- **Provenance information**: Input/output file tracking
+- **Workflow topology**: Visual representation of rule dependencies
+- **Analysis results**: Figures from each analysis step
+
+### Report Contents
+
+The report organizes results by analysis step:
+
+| Category | Contents |
+|----------|----------|
+| Step 2: Filtering | Donor cell count distribution |
+| Step 3: Quality Control | QC violin plots, scatter plots, hemoglobin distribution, doublet UMAP |
+| Step 5: Dimensionality Reduction | PCA and UMAP visualizations |
+| Step 6: Clustering | UMAP with cell type and cluster annotations |
+| Step 7: Pseudobulking | Pseudobulk sample characteristics |
+| Step 9: Pathway Analysis (GSEA) | GSEA pathway plots per cell type |
+| Step 10: Overrepresentation Analysis | Enrichr pathway plots per cell type |
+| Step 11: Predictive Modeling | Age prediction performance per cell type |
+
+### Using the Makefile
+
+If using the provided Makefile:
+
+```bash
+# Generate HTML report
+make report
+
+# Generate ZIP report (recommended for many cell types)
+make report-zip
 ```
 
 ---
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/clustering.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/clustering.rst
new file mode 100644
index 0000000..79cc652
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/clustering.rst
@@ -0,0 +1,4 @@
+UMAP visualization with cell type and Leiden clustering.
+
+Cell types are annotated from the original dataset. Leiden clustering
+identifies communities of cells with similar expression profiles.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/de_results.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/de_results.rst
new file mode 100644
index 0000000..3210df8
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/de_results.rst
@@ -0,0 +1,4 @@
+Differential expression results for {{ snakemake.wildcards.cell_type }}.
+
+Contains log2 fold changes, p-values, and adjusted p-values from
+DESeq2 analysis comparing conditions within this cell type.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/doublet_umap.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/doublet_umap.rst
new file mode 100644
index 0000000..efc9341
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/doublet_umap.rst
@@ -0,0 +1,4 @@
+UMAP visualization of predicted doublets.
+
+Doublets (cells containing RNA from multiple cells) are computationally
+detected and shown here in the context of the full UMAP embedding.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/enrichr.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/enrichr.rst
new file mode 100644
index 0000000..fb9dc2b
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/enrichr.rst
@@ -0,0 +1,4 @@
+Enrichr pathway analysis for {{ snakemake.wildcards.cell_type }}.
+
+Overrepresentation analysis of differentially expressed genes using
+the Enrichr database to identify enriched biological processes.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/filtering.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/filtering.rst
new file mode 100644
index 0000000..2afe459
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/filtering.rst
@@ -0,0 +1,4 @@
+Distribution of cell counts per donor after filtering.
+
+This plot shows the number of cells from each donor that passed quality filters,
+helping to identify potential batch effects or sample quality issues.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/gsea.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/gsea.rst
new file mode 100644
index 0000000..bc4c4e0
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/gsea.rst
@@ -0,0 +1,4 @@
+Gene Set Enrichment Analysis (GSEA) results for {{ snakemake.wildcards.cell_type }}.
+
+Shows significantly enriched pathways based on the ranking of genes
+by their differential expression statistics.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/hemoglobin.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/hemoglobin.rst
new file mode 100644
index 0000000..ea70d4f
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/hemoglobin.rst
@@ -0,0 +1,4 @@
+Distribution of hemoglobin gene expression.
+
+High hemoglobin gene expression can indicate red blood cell contamination.
+Cells exceeding the threshold are filtered out to improve data quality.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pca.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pca.rst
new file mode 100644
index 0000000..805e6ec
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pca.rst
@@ -0,0 +1,4 @@
+PCA visualization of cells colored by cell type.
+
+Principal component analysis reduces dimensionality while preserving
+the major sources of variation in gene expression.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/prediction.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/prediction.rst
new file mode 100644
index 0000000..da779b7
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/prediction.rst
@@ -0,0 +1,4 @@
+Age prediction performance for {{ snakemake.wildcards.cell_type }}.
+
+Cross-validated prediction of donor age from gene expression using
+machine learning models. Shows correlation between predicted and actual age.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pseudobulk.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pseudobulk.rst
new file mode 100644
index 0000000..3fcbdd4
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pseudobulk.rst
@@ -0,0 +1,4 @@
+Distribution of pseudobulk sample characteristics.
+
+Shows the distribution of cells per sample and total counts after
+aggregating single-cell data to pseudobulk samples per donor and cell type.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_scatter.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_scatter.rst
new file mode 100644
index 0000000..5e2b9f4
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_scatter.rst
@@ -0,0 +1,5 @@
+Scatter plot of QC metrics with doublet predictions.
+
+Shows the relationship between gene counts and UMI counts per cell,
+colored by predicted doublet status. Doublets typically have elevated
+counts in both dimensions.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_violin.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_violin.rst
new file mode 100644
index 0000000..e4d4415
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_violin.rst
@@ -0,0 +1,8 @@
+Violin plots of quality control metrics.
+
+Shows the distribution of key QC metrics across cells:
+- Number of genes detected per cell
+- Total UMI counts per cell
+- Mitochondrial gene percentage
+
+These metrics help identify low-quality cells for filtering.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/umap.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/umap.rst
new file mode 100644
index 0000000..64c8b38
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/umap.rst
@@ -0,0 +1,4 @@
+UMAP visualization colored by total counts.
+
+UMAP provides a non-linear dimensionality reduction that preserves
+local structure. Coloring by total counts helps assess technical variation.
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/workflow.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/workflow.rst
new file mode 100644
index 0000000..f011d94
--- /dev/null
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/workflow.rst
@@ -0,0 +1,29 @@
+This workflow performs single-cell RNA-seq analysis of immune aging data.
+
+The analysis consists of 11 steps:
+
+**Global Preprocessing (Steps 1-7)**
+
+1. Data Download - Retrieve raw data from repository
+2. Data Filtering - Remove low-quality cells and cell types
+3. Quality Control - Filter cells based on QC metrics and detect doublets
+4. Preprocessing - Normalize and select highly variable genes
+5. Dimensionality Reduction - PCA and UMAP computation
+6. Clustering - Leiden clustering for cell type identification
+7. Pseudobulking - Aggregate single-cell data to pseudobulk per donor/cell-type
+
+**Per-Cell-Type Analysis (Steps 8-11)**
+
+For each cell type discovered in step 7:
+
+8. Differential Expression - Compare gene expression between conditions
+9. Pathway Analysis (GSEA) - Identify enriched biological pathways
+10. Overrepresentation Analysis - Enrichr analysis of DE genes
+11. Predictive Modeling - Age prediction from gene expression
+
+Configuration
+=============
+
+Dataset: ``{{ snakemake.config["dataset_name"] }}``
+
+Data directory: ``{{ snakemake.config["datadir"] }}``
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk
index 3c11e87..1bff4bb 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk
@@ -86,6 +86,10 @@ def aggregate_per_cell_type_outputs(wildcards):
                 ct_dir / "enrichr_up.pkl",
                 ct_dir / "enrichr_down.pkl",
                 ct_dir / "prediction_results.pkl",
+                # Figures for report
+                ct_dir / "figures" / "gsea_pathways.png",
+                ct_dir / "figures" / "enrichr_pathways.png",
+                ct_dir / "figures" / "age_prediction_performance.png",
             ]
         )
 
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
index 9d06fa6..c5b0149 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
@@ -39,6 +39,12 @@ rule pathway_analysis:
         de_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "de_results.parquet",
     output:
         gsea_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "gsea_results.pkl",
+        fig_gsea=report(
+            RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "gsea_pathways.png",
+            caption="report/gsea.rst",
+            category="Step 9: Pathway Analysis (GSEA)",
+            subcategory="{cell_type}",
+        ),
     params:
         cell_type=lambda wildcards: wildcards.cell_type,
         gene_sets=config["pathway_analysis"]["gene_sets"],
@@ -59,6 +65,12 @@ rule overrepresentation:
     output:
         enr_up=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "enrichr_up.pkl",
         enr_down=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "enrichr_down.pkl",
+        fig_enrichr=report(
+            RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "enrichr_pathways.png",
+            caption="report/enrichr.rst",
+            category="Step 10: Overrepresentation Analysis",
+            subcategory="{cell_type}",
+        ),
     params:
         cell_type=lambda wildcards: wildcards.cell_type,
         gene_sets=config["overrepresentation"]["gene_sets"],
@@ -84,6 +96,12 @@ rule predictive_modeling:
         / "per_cell_type"
         / "{cell_type}"
         / "prediction_results.pkl",
+        fig_prediction=report(
+            RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "age_prediction_performance.png",
+            caption="report/prediction.rst",
+            category="Step 11: Predictive Modeling",
+            subcategory="{cell_type}",
+        ),
     params:
         cell_type=lambda wildcards: wildcards.cell_type,
         n_splits=config["predictive_modeling"]["n_splits"],
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
index 7991264..29d4946 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
@@ -27,7 +27,12 @@ rule filter_data:
     input:
         DATADIR / f"dataset-{DATASET}_subset-immune_raw.h5ad",
     output:
-        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
+        checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
+        fig_donor_counts=report(
+            FIGURE_DIR / "donor_cell_counts_distribution.png",
+            caption="report/filtering.rst",
+            category="Step 2: Filtering",
+        ),
     params:
         cutoff_percentile=config["filtering"]["cutoff_percentile"],
         min_cells_per_celltype=config["filtering"]["min_cells_per_celltype"],
@@ -44,7 +49,27 @@ rule quality_control:
     input:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
     output:
-        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
+        checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
+        fig_violin=report(
+            FIGURE_DIR / "qc_violin_plots.png",
+            caption="report/qc_violin.rst",
+            category="Step 3: Quality Control",
+        ),
+        fig_scatter=report(
+            FIGURE_DIR / "qc_scatter_doublets.png",
+            caption="report/qc_scatter.rst",
+            category="Step 3: Quality Control",
+        ),
+        fig_hemoglobin=report(
+            FIGURE_DIR / "hemoglobin_distribution.png",
+            caption="report/hemoglobin.rst",
+            category="Step 3: Quality Control",
+        ),
+        fig_doublet_umap=report(
+            FIGURE_DIR / "doublet_detection_umap.png",
+            caption="report/doublet_umap.rst",
+            category="Step 3: Quality Control",
+        ),
     threads: workflow.cores
     params:
         min_genes=config["qc"]["min_genes"],
@@ -82,7 +107,17 @@ rule dimensionality_reduction:
     input:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 4, "preprocessed"),
     output:
-        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"),
+        checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"),
+        fig_pca=report(
+            FIGURE_DIR / "pca_cell_type.png",
+            caption="report/pca.rst",
+            category="Step 5: Dimensionality Reduction",
+        ),
+        fig_umap=report(
+            FIGURE_DIR / "umap_total_counts.png",
+            caption="report/umap.rst",
+            category="Step 5: Dimensionality Reduction",
+        ),
     threads: workflow.cores
     params:
         batch_key=config["dimred"]["batch_key"],
@@ -100,7 +135,12 @@ rule clustering:
     input:
         CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"),
     output:
-        CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"),
+        checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"),
+        fig_clustering=report(
+            FIGURE_DIR / "umap_cell_type_leiden.png",
+            caption="report/clustering.rst",
+            category="Step 6: Clustering",
+        ),
     params:
         resolution=config["clustering"]["resolution"],
         figure_dir=str(FIGURE_DIR),
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
index 678937e..7e71baf 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
@@ -26,6 +26,12 @@ checkpoint pseudobulk:
         cell_types=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_cell_types.json",
         # Gene name mapping (needed for DE analysis)
         var_to_feature=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_var_to_feature.json",
+        # Pseudobulk figure
+        fig_pseudobulk=report(
+            FIGURE_DIR / "pseudobulk_violin.png",
+            caption="report/pseudobulk.rst",
+            category="Step 7: Pseudobulking",
+        ),
     params:
         group_col=config["pseudobulk"]["group_col"],
         donor_col=config["pseudobulk"]["donor_col"],

From 65d6706ee3ff1a15f4d019588d962fd67e534aeb Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 13:51:54 -0800
Subject: [PATCH 69/87] Add simple workflow example for Prefect, Snakemake, and
 Make
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Create a simple pandas-based data analysis workflow to demonstrate
workflow manager features. The workflow loads Self-Regulation Ontology
data, filters to numerical columns, joins datasets, computes Spearman
correlations, and generates a clustered heatmap.

Includes:
- Core modules: load_data, filter_data, join_data, correlation, visualization
- Prefect workflow with tasks and flows
- Snakemake workflow with rules and report generation
- GNU Make workflow with Makefile and CLI scripts

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 problems_to_solve.md                          |  31 ++++
 .../simple_workflow/__init__.py               |   0
 .../simple_workflow/correlation.py            |  43 +++++
 .../simple_workflow/filter_data.py            |  55 +++++++
 .../simple_workflow/join_data.py              |  54 +++++++
 .../simple_workflow/load_data.py              |  86 ++++++++++
 .../simple_workflow/make_workflow/Makefile    | 107 ++++++++++++
 .../simple_workflow/make_workflow/__init__.py |   0
 .../scripts/compute_correlation.py            |  42 +++++
 .../make_workflow/scripts/download_data.py    |  35 ++++
 .../make_workflow/scripts/filter_data.py      |  42 +++++
 .../make_workflow/scripts/generate_heatmap.py |  38 +++++
 .../make_workflow/scripts/join_data.py        |  44 +++++
 .../prefect_workflow/__init__.py              |   0
 .../simple_workflow/prefect_workflow/flows.py | 115 +++++++++++++
 .../prefect_workflow/run_workflow.py          |  43 +++++
 .../simple_workflow/prefect_workflow/tasks.py | 153 ++++++++++++++++++
 .../snakemake_workflow/Snakefile              | 145 +++++++++++++++++
 .../snakemake_workflow/__init__.py            |   0
 .../snakemake_workflow/config/config.yaml     |  15 ++
 .../snakemake_workflow/report/heatmap.rst     |   1 +
 .../snakemake_workflow/report/workflow.rst    |  10 ++
 .../scripts/compute_correlation.py            |  34 ++++
 .../scripts/download_data.py                  |  26 +++
 .../snakemake_workflow/scripts/filter_data.py |  33 ++++
 .../scripts/generate_heatmap.py               |  40 +++++
 .../snakemake_workflow/scripts/join_data.py   |  35 ++++
 .../simple_workflow/visualization.py          |  85 ++++++++++
 28 files changed, 1312 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/correlation.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/filter_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/join_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/load_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/make_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/prefect_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/prefect_workflow/flows.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/prefect_workflow/run_workflow.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/prefect_workflow/tasks.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/__init__.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/config/config.yaml
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/heatmap.rst
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/workflow.rst
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/generate_heatmap.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/visualization.py

diff --git a/problems_to_solve.md b/problems_to_solve.md
index 94a86b1..f45c496 100644
--- a/problems_to_solve.md
+++ b/problems_to_solve.md
@@ -3,6 +3,37 @@
 Open problems marked with [ ]
 Fixed problems marked with [x]
 
+[x] I would like to generate a new example of a very simple pandas-based data analysis workflow for demonstrating the features of Prefect and snakemake. Put the new code into src/BetterCodeBetterScience/simple_workflow.  The example should include separate modules that implement each of the following functions:
+- load these two files (using the first column as the index for each):
+  - https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv
+  - https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv
+- Filter out any non-numerical variables from each
+- join the two data frames based on the index
+- compute the correlation matrix across all measures using Spearman correlation
+- generate a clustered heatmap from the correlation matrix using Seaborn
+    - Created `simple_workflow/` directory with modular functions:
+      - `load_data.py`: Functions to load CSV data from URLs with optional caching
+      - `filter_data.py`: Functions to filter dataframes to numerical columns only
+      - `join_data.py`: Functions to join dataframes based on index
+      - `correlation.py`: Functions to compute Spearman correlation matrices
+      - `visualization.py`: Functions to generate clustered heatmaps with Seaborn
+    - Created `prefect_workflow/` subdirectory:
+      - `tasks.py`: Prefect task definitions wrapping each workflow function
+      - `flows.py`: Main workflow flow orchestrating all steps
+      - `run_workflow.py`: CLI entry point
+      - Usage: `python run_workflow.py --output-dir ./output`
+    - Created `snakemake_workflow/` subdirectory:
+      - `Snakefile`: Workflow rules with dependencies
+      - `config/config.yaml`: Configuration for URLs and heatmap settings
+      - `scripts/*.py`: Scripts for each workflow step
+      - `report/`: RST files for Snakemake report generation
+      - Usage: `snakemake --cores 1 --config output_dir=/path/to/output`
+    - Created `make_workflow/` subdirectory:
+      - `Makefile`: GNU Make-based workflow with proper dependencies
+      - `scripts/*.py`: Standalone CLI scripts for each step
+      - Usage: `make OUTPUT_DIR=/path/to/output all`
+
+
 [x] For the Snakemake workflow I would like to use the Snakemake report generating functions to create a report showing the results from each of the analyses.
     - Added `report: "report/workflow.rst"` global declaration to Snakefile
     - Created `report/` directory with RST caption files for each figure type
diff --git a/src/BetterCodeBetterScience/simple_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/simple_workflow/correlation.py b/src/BetterCodeBetterScience/simple_workflow/correlation.py
new file mode 100644
index 0000000..935b194
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/correlation.py
@@ -0,0 +1,43 @@
+"""Correlation computation module for the simple workflow example.
+
+This module provides functions to compute correlation matrices.
+"""
+
+import pandas as pd
+
+
+def compute_spearman_correlation(df: pd.DataFrame) -> pd.DataFrame:
+    """Compute Spearman correlation matrix for a dataframe.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input dataframe with numerical columns
+
+    Returns
+    -------
+    pd.DataFrame
+        Spearman correlation matrix
+    """
+    return df.corr(method="spearman")
+
+
+def compute_correlation_matrix(
+    df: pd.DataFrame,
+    method: str = "spearman",
+) -> pd.DataFrame:
+    """Compute correlation matrix using the specified method.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input dataframe with numerical columns
+    method : str
+        Correlation method: 'pearson', 'spearman', or 'kendall' (default: 'spearman')
+
+    Returns
+    -------
+    pd.DataFrame
+        Correlation matrix
+    """
+    return df.corr(method=method)
diff --git a/src/BetterCodeBetterScience/simple_workflow/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/filter_data.py
new file mode 100644
index 0000000..292d73a
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/filter_data.py
@@ -0,0 +1,55 @@
+"""Data filtering module for the simple workflow example.
+
+This module provides functions to filter dataframes to keep only numerical columns.
+"""
+
+import pandas as pd
+
+
+def filter_numerical_columns(df: pd.DataFrame) -> pd.DataFrame:
+    """Filter a dataframe to keep only numerical columns.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input dataframe
+
+    Returns
+    -------
+    pd.DataFrame
+        Dataframe with only numerical columns
+    """
+    numerical_df = df.select_dtypes(include=["number"])
+    return numerical_df
+
+
+def filter_meaningful_variables(df: pd.DataFrame) -> pd.DataFrame:
+    """Filter meaningful variables dataframe to numerical columns only.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Meaningful variables dataframe
+
+    Returns
+    -------
+    pd.DataFrame
+        Filtered dataframe with only numerical columns
+    """
+    return filter_numerical_columns(df)
+
+
+def filter_demographics(df: pd.DataFrame) -> pd.DataFrame:
+    """Filter demographics dataframe to numerical columns only.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Demographics dataframe
+
+    Returns
+    -------
+    pd.DataFrame
+        Filtered dataframe with only numerical columns
+    """
+    return filter_numerical_columns(df)
diff --git a/src/BetterCodeBetterScience/simple_workflow/join_data.py b/src/BetterCodeBetterScience/simple_workflow/join_data.py
new file mode 100644
index 0000000..f5c8090
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/join_data.py
@@ -0,0 +1,54 @@
+"""Data joining module for the simple workflow example.
+
+This module provides functions to join dataframes based on their index.
+"""
+
+import pandas as pd
+
+
+def join_dataframes(
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+    how: str = "inner",
+) -> pd.DataFrame:
+    """Join two dataframes based on their index.
+
+    Parameters
+    ----------
+    df1 : pd.DataFrame
+        First dataframe
+    df2 : pd.DataFrame
+        Second dataframe
+    how : str
+        Type of join: 'inner', 'outer', 'left', 'right' (default: 'inner')
+
+    Returns
+    -------
+    pd.DataFrame
+        Joined dataframe
+    """
+    return df1.join(df2, how=how, lsuffix="_mv", rsuffix="_demo")
+
+
+def join_meaningful_and_demographics(
+    meaningful_vars: pd.DataFrame,
+    demographics: pd.DataFrame,
+    how: str = "inner",
+) -> pd.DataFrame:
+    """Join meaningful variables and demographics dataframes.
+
+    Parameters
+    ----------
+    meaningful_vars : pd.DataFrame
+        Meaningful variables dataframe (filtered to numerical)
+    demographics : pd.DataFrame
+        Demographics dataframe (filtered to numerical)
+    how : str
+        Type of join (default: 'inner')
+
+    Returns
+    -------
+    pd.DataFrame
+        Joined dataframe
+    """
+    return join_dataframes(meaningful_vars, demographics, how=how)
diff --git a/src/BetterCodeBetterScience/simple_workflow/load_data.py b/src/BetterCodeBetterScience/simple_workflow/load_data.py
new file mode 100644
index 0000000..59a3c98
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/load_data.py
@@ -0,0 +1,86 @@
+"""Data loading module for the simple workflow example.
+
+This module provides functions to load CSV data from URLs or local files.
+"""
+
+from pathlib import Path
+
+import pandas as pd
+
+
+def load_csv_from_url(url: str, index_col: int = 0) -> pd.DataFrame:
+    """Load a CSV file from a URL.
+
+    Parameters
+    ----------
+    url : str
+        URL to the CSV file
+    index_col : int
+        Column to use as index (default: 0, first column)
+
+    Returns
+    -------
+    pd.DataFrame
+        Loaded dataframe with the first column as index
+    """
+    return pd.read_csv(url, index_col=index_col)
+
+
+def load_meaningful_variables(
+    url: str = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv",
+    cache_path: Path | None = None,
+) -> pd.DataFrame:
+    """Load the meaningful variables dataset.
+
+    Parameters
+    ----------
+    url : str
+        URL to the meaningful variables CSV file
+    cache_path : Path, optional
+        If provided, save/load from this local path
+
+    Returns
+    -------
+    pd.DataFrame
+        Meaningful variables dataframe
+    """
+    if cache_path is not None and cache_path.exists():
+        return pd.read_csv(cache_path, index_col=0)
+
+    df = load_csv_from_url(url)
+
+    if cache_path is not None:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        df.to_csv(cache_path)
+
+    return df
+
+
+def load_demographics(
+    url: str = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv",
+    cache_path: Path | None = None,
+) -> pd.DataFrame:
+    """Load the demographics dataset.
+
+    Parameters
+    ----------
+    url : str
+        URL to the demographics CSV file
+    cache_path : Path, optional
+        If provided, save/load from this local path
+
+    Returns
+    -------
+    pd.DataFrame
+        Demographics dataframe
+    """
+    if cache_path is not None and cache_path.exists():
+        return pd.read_csv(cache_path, index_col=0)
+
+    df = load_csv_from_url(url)
+
+    if cache_path is not None:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        df.to_csv(cache_path)
+
+    return df
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile b/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile
new file mode 100644
index 0000000..b1c642f
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile
@@ -0,0 +1,107 @@
+# Simple Correlation Workflow using Make
+#
+# This Makefile demonstrates a simple data analysis pipeline using Make.
+# Each target represents a step in the workflow, with dependencies ensuring
+# correct execution order.
+#
+# Usage:
+#   make OUTPUT_DIR=/path/to/output all
+#   make OUTPUT_DIR=/path/to/output clean
+#   make OUTPUT_DIR=/path/to/output help
+
+# Configuration
+OUTPUT_DIR ?= ./output
+DATA_DIR := $(OUTPUT_DIR)/data
+RESULTS_DIR := $(OUTPUT_DIR)/results
+FIGURES_DIR := $(OUTPUT_DIR)/figures
+LOGS_DIR := $(OUTPUT_DIR)/logs
+
+# Data URLs
+MV_URL := https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv
+DEMO_URL := https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv
+
+# Python command
+PYTHON := python
+
+# Default target
+.PHONY: all
+all: $(FIGURES_DIR)/correlation_heatmap.png
+
+# Help target
+.PHONY: help
+help:
+	@echo "Simple Correlation Workflow"
+	@echo ""
+	@echo "Usage: make OUTPUT_DIR=/path/to/output <target>"
+	@echo ""
+	@echo "Targets:"
+	@echo "  all      - Run full workflow (default)"
+	@echo "  clean    - Remove all generated files"
+	@echo "  help     - Show this help message"
+	@echo ""
+	@echo "Individual steps:"
+	@echo "  download_mv    - Download meaningful variables data"
+	@echo "  download_demo  - Download demographics data"
+	@echo "  filter_mv      - Filter meaningful variables to numerical"
+	@echo "  filter_demo    - Filter demographics to numerical"
+	@echo "  join           - Join the two datasets"
+	@echo "  correlation    - Compute correlation matrix"
+	@echo "  heatmap        - Generate clustered heatmap"
+
+# Create directories
+$(DATA_DIR) $(RESULTS_DIR) $(FIGURES_DIR) $(LOGS_DIR):
+	mkdir -p $@
+
+# Step 1a: Download meaningful variables
+.PHONY: download_mv
+download_mv: $(DATA_DIR)/meaningful_variables.csv
+
+$(DATA_DIR)/meaningful_variables.csv: | $(DATA_DIR) $(LOGS_DIR)
+	$(PYTHON) scripts/download_data.py "$(MV_URL)" "$@" > $(LOGS_DIR)/download_mv.log 2>&1
+
+# Step 1b: Download demographics
+.PHONY: download_demo
+download_demo: $(DATA_DIR)/demographics.csv
+
+$(DATA_DIR)/demographics.csv: | $(DATA_DIR) $(LOGS_DIR)
+	$(PYTHON) scripts/download_data.py "$(DEMO_URL)" "$@" > $(LOGS_DIR)/download_demo.log 2>&1
+
+# Step 2a: Filter meaningful variables
+.PHONY: filter_mv
+filter_mv: $(DATA_DIR)/meaningful_variables_numerical.csv
+
+$(DATA_DIR)/meaningful_variables_numerical.csv: $(DATA_DIR)/meaningful_variables.csv | $(LOGS_DIR)
+	$(PYTHON) scripts/filter_data.py "$<" "$@" > $(LOGS_DIR)/filter_mv.log 2>&1
+
+# Step 2b: Filter demographics
+.PHONY: filter_demo
+filter_demo: $(DATA_DIR)/demographics_numerical.csv
+
+$(DATA_DIR)/demographics_numerical.csv: $(DATA_DIR)/demographics.csv | $(LOGS_DIR)
+	$(PYTHON) scripts/filter_data.py "$<" "$@" > $(LOGS_DIR)/filter_demo.log 2>&1
+
+# Step 3: Join datasets
+.PHONY: join
+join: $(DATA_DIR)/joined_data.csv
+
+$(DATA_DIR)/joined_data.csv: $(DATA_DIR)/meaningful_variables_numerical.csv $(DATA_DIR)/demographics_numerical.csv | $(LOGS_DIR)
+	$(PYTHON) scripts/join_data.py "$<" "$(word 2,$^)" "$@" > $(LOGS_DIR)/join.log 2>&1
+
+# Step 4: Compute correlation
+.PHONY: correlation
+correlation: $(RESULTS_DIR)/correlation_matrix.csv
+
+$(RESULTS_DIR)/correlation_matrix.csv: $(DATA_DIR)/joined_data.csv | $(RESULTS_DIR) $(LOGS_DIR)
+	$(PYTHON) scripts/compute_correlation.py "$<" "$@" > $(LOGS_DIR)/correlation.log 2>&1
+
+# Step 5: Generate heatmap
+.PHONY: heatmap
+heatmap: $(FIGURES_DIR)/correlation_heatmap.png
+
+$(FIGURES_DIR)/correlation_heatmap.png: $(RESULTS_DIR)/correlation_matrix.csv | $(FIGURES_DIR) $(LOGS_DIR)
+	$(PYTHON) scripts/generate_heatmap.py "$<" "$@" > $(LOGS_DIR)/heatmap.log 2>&1
+
+# Clean target
+.PHONY: clean
+clean:
+	rm -rf $(OUTPUT_DIR)
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py
new file mode 100644
index 0000000..500366e
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Compute Spearman correlation matrix.
+
+Usage:
+    python compute_correlation.py <input_path> <output_path>
+"""
+
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.correlation import (
+    compute_spearman_correlation,
+)
+
+
+def main():
+    """Compute Spearman correlation matrix."""
+    if len(sys.argv) != 3:
+        print("Usage: python compute_correlation.py <input_path> <output_path>")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    output_path = Path(sys.argv[2])
+
+    # Load data
+    df = pd.read_csv(input_path, index_col=0)
+    print(f"Loaded {df.shape} from {input_path}")
+
+    # Compute correlation
+    corr_matrix = compute_spearman_correlation(df)
+    print(f"Computed Spearman correlation matrix: {corr_matrix.shape}")
+
+    # Save
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    corr_matrix.to_csv(output_path)
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py
new file mode 100644
index 0000000..b843979
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py
@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""Download data from URL and save to CSV.
+
+Usage:
+    python download_data.py <url> <output_path>
+"""
+
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+
+def main():
+    """Download data from URL."""
+    if len(sys.argv) != 3:
+        print("Usage: python download_data.py <url> <output_path>")
+        sys.exit(1)
+
+    url = sys.argv[1]
+    output_path = Path(sys.argv[2])
+
+    # Create output directory
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Download and save
+    df = pd.read_csv(url, index_col=0)
+    df.to_csv(output_path)
+
+    print(f"Downloaded {len(df)} rows from {url}")
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py
new file mode 100644
index 0000000..62f0c86
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Filter dataframe to numerical columns only.
+
+Usage:
+    python filter_data.py <input_path> <output_path>
+"""
+
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.filter_data import (
+    filter_numerical_columns,
+)
+
+
+def main():
+    """Filter data to numerical columns."""
+    if len(sys.argv) != 3:
+        print("Usage: python filter_data.py <input_path> <output_path>")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    output_path = Path(sys.argv[2])
+
+    # Load data
+    df = pd.read_csv(input_path, index_col=0)
+    print(f"Loaded {df.shape} from {input_path}")
+
+    # Filter to numerical columns
+    df_num = filter_numerical_columns(df)
+    print(f"Filtered to {df_num.shape} (numerical columns only)")
+
+    # Save
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df_num.to_csv(output_path)
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py
new file mode 100644
index 0000000..1f55cde
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Generate clustered heatmap from correlation matrix.
+
+Usage:
+    python generate_heatmap.py <input_path> <output_path>
+"""
+
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.visualization import (
+    generate_clustered_heatmap,
+)
+
+
+def main():
+    """Generate and save clustered heatmap."""
+    if len(sys.argv) != 3:
+        print("Usage: python generate_heatmap.py <input_path> <output_path>")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    output_path = Path(sys.argv[2])
+
+    # Load correlation matrix
+    corr_matrix = pd.read_csv(input_path, index_col=0)
+    print(f"Loaded correlation matrix: {corr_matrix.shape}")
+
+    # Generate heatmap
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    generate_clustered_heatmap(corr_matrix, output_path=output_path)
+    print(f"Saved heatmap to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py
new file mode 100644
index 0000000..593a713
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Join two dataframes based on their index.
+
+Usage:
+    python join_data.py <input1_path> <input2_path> <output_path>
+"""
+
+import sys
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.join_data import join_dataframes
+
+
+def main():
+    """Join the two datasets."""
+    if len(sys.argv) != 4:
+        print("Usage: python join_data.py <input1_path> <input2_path> <output_path>")
+        sys.exit(1)
+
+    input1_path = Path(sys.argv[1])
+    input2_path = Path(sys.argv[2])
+    output_path = Path(sys.argv[3])
+
+    # Load data
+    df1 = pd.read_csv(input1_path, index_col=0)
+    df2 = pd.read_csv(input2_path, index_col=0)
+
+    print(f"Dataset 1: {df1.shape}")
+    print(f"Dataset 2: {df2.shape}")
+
+    # Join
+    joined = join_dataframes(df1, df2)
+    print(f"Joined: {joined.shape}")
+
+    # Save
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    joined.to_csv(output_path)
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/flows.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/flows.py
new file mode 100644
index 0000000..498e670
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/flows.py
@@ -0,0 +1,115 @@
+"""Prefect flow definitions for the simple correlation workflow.
+
+This workflow demonstrates Prefect features with a simple pandas-based analysis:
+1. Load two datasets from URLs
+2. Filter to numerical columns
+3. Join the datasets
+4. Compute Spearman correlation
+5. Generate a clustered heatmap
+"""
+
+from pathlib import Path
+
+from prefect import flow, get_run_logger
+
+from BetterCodeBetterScience.simple_workflow.prefect_workflow.tasks import (
+    compute_correlation_task,
+    filter_numerical_task,
+    generate_heatmap_task,
+    join_dataframes_task,
+    load_demographics_task,
+    load_meaningful_variables_task,
+    save_correlation_task,
+)
+
+
+@flow(name="simple_correlation_workflow", log_prints=True)
+def run_workflow(
+    output_dir: Path,
+    cache_data: bool = True,
+) -> Path:
+    """Run the simple correlation workflow.
+
+    Steps:
+    1. Load meaningful variables and demographics datasets
+    2. Filter both to numerical columns only
+    3. Join the datasets on their index
+    4. Compute Spearman correlation matrix
+    5. Generate clustered heatmap
+
+    Parameters
+    ----------
+    output_dir : Path
+        Directory to save outputs (correlation matrix CSV and heatmap)
+    cache_data : bool
+        Whether to cache downloaded data locally (default: True)
+
+    Returns
+    -------
+    Path
+        Path to the generated heatmap
+    """
+    logger = get_run_logger()
+
+    # Setup directories
+    output_dir = Path(output_dir)
+    data_dir = output_dir / "data"
+    results_dir = output_dir / "results"
+    figures_dir = output_dir / "figures"
+
+    for d in [data_dir, results_dir, figures_dir]:
+        d.mkdir(parents=True, exist_ok=True)
+
+    # Step 1: Load data (can run in parallel)
+    logger.info("Step 1: Loading datasets...")
+    mv_cache = data_dir / "meaningful_variables.csv" if cache_data else None
+    demo_cache = data_dir / "demographics.csv" if cache_data else None
+
+    meaningful_vars = load_meaningful_variables_task(cache_path=mv_cache)
+    demographics = load_demographics_task(cache_path=demo_cache)
+
+    logger.info(f"  Meaningful variables: {meaningful_vars.shape}")
+    logger.info(f"  Demographics: {demographics.shape}")
+
+    # Step 2: Filter to numerical columns
+    logger.info("Step 2: Filtering to numerical columns...")
+    meaningful_vars_num = filter_numerical_task(meaningful_vars)
+    demographics_num = filter_numerical_task(demographics)
+
+    logger.info(f"  Meaningful variables (numerical): {meaningful_vars_num.shape}")
+    logger.info(f"  Demographics (numerical): {demographics_num.shape}")
+
+    # Step 3: Join datasets
+    logger.info("Step 3: Joining datasets...")
+    joined_df = join_dataframes_task(meaningful_vars_num, demographics_num)
+    logger.info(f"  Joined dataset: {joined_df.shape}")
+
+    # Step 4: Compute correlation matrix
+    logger.info("Step 4: Computing Spearman correlation matrix...")
+    corr_matrix = compute_correlation_task(joined_df)
+    logger.info(f"  Correlation matrix: {corr_matrix.shape}")
+
+    # Save correlation matrix
+    corr_path = results_dir / "correlation_matrix.csv"
+    save_correlation_task(corr_matrix, corr_path)
+    logger.info(f"  Saved correlation matrix to: {corr_path}")
+
+    # Step 5: Generate heatmap
+    logger.info("Step 5: Generating clustered heatmap...")
+    heatmap_path = figures_dir / "correlation_heatmap.png"
+    generate_heatmap_task(corr_matrix, heatmap_path)
+    logger.info(f"  Saved heatmap to: {heatmap_path}")
+
+    logger.info("Workflow complete!")
+    return heatmap_path
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) < 2:
+        print("Usage: python flows.py <output_dir>")
+        sys.exit(1)
+
+    output_dir = Path(sys.argv[1])
+    run_workflow(output_dir)
diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/run_workflow.py
new file mode 100644
index 0000000..e85c670
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/run_workflow.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""CLI entry point for the simple correlation Prefect workflow.
+
+Usage:
+    python run_workflow.py --output-dir ./output
+    python run_workflow.py --output-dir ./output --no-cache
+"""
+
+import argparse
+from pathlib import Path
+
+from BetterCodeBetterScience.simple_workflow.prefect_workflow.flows import run_workflow
+
+
+def main():
+    """Run the simple correlation workflow from the command line."""
+    parser = argparse.ArgumentParser(
+        description="Run the simple correlation workflow with Prefect"
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        required=True,
+        help="Directory to save outputs",
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="Do not cache downloaded data locally",
+    )
+
+    args = parser.parse_args()
+
+    result = run_workflow(
+        output_dir=args.output_dir,
+        cache_data=not args.no_cache,
+    )
+
+    print(f"\nWorkflow complete! Heatmap saved to: {result}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/tasks.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/tasks.py
new file mode 100644
index 0000000..4d5193e
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/tasks.py
@@ -0,0 +1,153 @@
+"""Prefect task definitions for the simple correlation workflow.
+
+Each task wraps a function from the modular workflow modules.
+"""
+
+from pathlib import Path
+
+import pandas as pd
+from prefect import task
+
+from BetterCodeBetterScience.simple_workflow.correlation import (
+    compute_spearman_correlation,
+)
+from BetterCodeBetterScience.simple_workflow.filter_data import (
+    filter_numerical_columns,
+)
+from BetterCodeBetterScience.simple_workflow.join_data import join_dataframes
+from BetterCodeBetterScience.simple_workflow.load_data import (
+    load_demographics,
+    load_meaningful_variables,
+)
+from BetterCodeBetterScience.simple_workflow.visualization import (
+    generate_clustered_heatmap,
+    save_correlation_matrix,
+)
+
+
+@task(name="load_meaningful_variables")
+def load_meaningful_variables_task(
+    cache_path: Path | None = None,
+) -> pd.DataFrame:
+    """Load meaningful variables dataset.
+
+    Parameters
+    ----------
+    cache_path : Path, optional
+        Path to cache the downloaded data
+
+    Returns
+    -------
+    pd.DataFrame
+        Meaningful variables dataframe
+    """
+    return load_meaningful_variables(cache_path=cache_path)
+
+
+@task(name="load_demographics")
+def load_demographics_task(
+    cache_path: Path | None = None,
+) -> pd.DataFrame:
+    """Load demographics dataset.
+
+    Parameters
+    ----------
+    cache_path : Path, optional
+        Path to cache the downloaded data
+
+    Returns
+    -------
+    pd.DataFrame
+        Demographics dataframe
+    """
+    return load_demographics(cache_path=cache_path)
+
+
+@task(name="filter_numerical_columns")
+def filter_numerical_task(df: pd.DataFrame) -> pd.DataFrame:
+    """Filter dataframe to keep only numerical columns.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input dataframe
+
+    Returns
+    -------
+    pd.DataFrame
+        Filtered dataframe
+    """
+    return filter_numerical_columns(df)
+
+
+@task(name="join_dataframes")
+def join_dataframes_task(
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+) -> pd.DataFrame:
+    """Join two dataframes based on their index.
+
+    Parameters
+    ----------
+    df1 : pd.DataFrame
+        First dataframe
+    df2 : pd.DataFrame
+        Second dataframe
+
+    Returns
+    -------
+    pd.DataFrame
+        Joined dataframe
+    """
+    return join_dataframes(df1, df2)
+
+
+@task(name="compute_correlation")
+def compute_correlation_task(df: pd.DataFrame) -> pd.DataFrame:
+    """Compute Spearman correlation matrix.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input dataframe
+
+    Returns
+    -------
+    pd.DataFrame
+        Correlation matrix
+    """
+    return compute_spearman_correlation(df)
+
+
+@task(name="save_correlation_matrix")
+def save_correlation_task(
+    corr_matrix: pd.DataFrame,
+    output_path: Path,
+) -> None:
+    """Save correlation matrix to CSV.
+
+    Parameters
+    ----------
+    corr_matrix : pd.DataFrame
+        Correlation matrix
+    output_path : Path
+        Output path
+    """
+    save_correlation_matrix(corr_matrix, output_path)
+
+
+@task(name="generate_heatmap")
+def generate_heatmap_task(
+    corr_matrix: pd.DataFrame,
+    output_path: Path,
+) -> None:
+    """Generate and save clustered heatmap.
+
+    Parameters
+    ----------
+    corr_matrix : pd.DataFrame
+        Correlation matrix
+    output_path : Path
+        Output path for the figure
+    """
+    generate_clustered_heatmap(corr_matrix, output_path)
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile
new file mode 100644
index 0000000..88104ce
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile
@@ -0,0 +1,145 @@
+"""Simple correlation Snakemake workflow.
+
+This workflow demonstrates Snakemake features with a simple pandas-based analysis:
+1. Load two datasets from URLs
+2. Filter to numerical columns
+3. Join the datasets
+4. Compute Spearman correlation
+5. Generate a clustered heatmap
+
+Usage:
+    # Run full workflow
+    snakemake --cores 1 --config output_dir=/path/to/output
+
+    # Dry run
+    snakemake -n --config output_dir=/path/to/output
+
+    # Generate report
+    snakemake --report report.html --config output_dir=/path/to/output
+"""
+
+from pathlib import Path
+
+from snakemake.utils import min_version
+
+min_version("8.0")
+
+
+# Load configuration
+configfile: "config/config.yaml"
+
+
+# Global report
+report: "report/workflow.rst"
+
+
+# Validate required config
+if config.get("output_dir") is None:
+    raise ValueError("output_dir must be provided via --config output_dir=/path/to/output")
+
+OUTPUT_DIR = Path(config["output_dir"])
+DATA_DIR = OUTPUT_DIR / "data"
+RESULTS_DIR = OUTPUT_DIR / "results"
+FIGURES_DIR = OUTPUT_DIR / "figures"
+
+
+# Default target
+rule all:
+    input:
+        FIGURES_DIR / "correlation_heatmap.png",
+
+
+# Step 1a: Download meaningful variables data
+rule download_meaningful_variables:
+    output:
+        DATA_DIR / "meaningful_variables.csv",
+    params:
+        url=config["meaningful_variables_url"],
+    log:
+        OUTPUT_DIR / "logs" / "download_meaningful_variables.log",
+    script:
+        "scripts/download_data.py"
+
+
+# Step 1b: Download demographics data
+rule download_demographics:
+    output:
+        DATA_DIR / "demographics.csv",
+    params:
+        url=config["demographics_url"],
+    log:
+        OUTPUT_DIR / "logs" / "download_demographics.log",
+    script:
+        "scripts/download_data.py"
+
+
+# Step 2a: Filter meaningful variables to numerical columns
+rule filter_meaningful_variables:
+    input:
+        DATA_DIR / "meaningful_variables.csv",
+    output:
+        DATA_DIR / "meaningful_variables_numerical.csv",
+    log:
+        OUTPUT_DIR / "logs" / "filter_meaningful_variables.log",
+    script:
+        "scripts/filter_data.py"
+
+
+# Step 2b: Filter demographics to numerical columns
+rule filter_demographics:
+    input:
+        DATA_DIR / "demographics.csv",
+    output:
+        DATA_DIR / "demographics_numerical.csv",
+    log:
+        OUTPUT_DIR / "logs" / "filter_demographics.log",
+    script:
+        "scripts/filter_data.py"
+
+
+# Step 3: Join the two datasets
+rule join_datasets:
+    input:
+        meaningful_vars=DATA_DIR / "meaningful_variables_numerical.csv",
+        demographics=DATA_DIR / "demographics_numerical.csv",
+    output:
+        DATA_DIR / "joined_data.csv",
+    log:
+        OUTPUT_DIR / "logs" / "join_datasets.log",
+    script:
+        "scripts/join_data.py"
+
+
+# Step 4: Compute correlation matrix
+rule compute_correlation:
+    input:
+        DATA_DIR / "joined_data.csv",
+    output:
+        RESULTS_DIR / "correlation_matrix.csv",
+    params:
+        method=config["correlation_method"],
+    log:
+        OUTPUT_DIR / "logs" / "compute_correlation.log",
+    script:
+        "scripts/compute_correlation.py"
+
+
+# Step 5: Generate clustered heatmap
+rule generate_heatmap:
+    input:
+        RESULTS_DIR / "correlation_matrix.csv",
+    output:
+        report(
+            FIGURES_DIR / "correlation_heatmap.png",
+            caption="report/heatmap.rst",
+            category="Results",
+        ),
+    params:
+        figsize=config["heatmap"]["figsize"],
+        cmap=config["heatmap"]["cmap"],
+        vmin=config["heatmap"]["vmin"],
+        vmax=config["heatmap"]["vmax"],
+    log:
+        OUTPUT_DIR / "logs" / "generate_heatmap.log",
+    script:
+        "scripts/generate_heatmap.py"
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/config/config.yaml b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/config/config.yaml
new file mode 100644
index 0000000..332399f
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/config/config.yaml
@@ -0,0 +1,15 @@
+# Configuration for the simple correlation Snakemake workflow
+
+# Data URLs
+meaningful_variables_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv"
+demographics_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv"
+
+# Correlation settings
+correlation_method: "spearman"
+
+# Heatmap settings
+heatmap:
+  figsize: [12, 10]
+  cmap: "coolwarm"
+  vmin: -1.0
+  vmax: 1.0
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/heatmap.rst b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/heatmap.rst
new file mode 100644
index 0000000..8700d3b
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/heatmap.rst
@@ -0,0 +1 @@
+Clustered correlation heatmap showing Spearman correlations between all numerical variables from the meaningful variables and demographics datasets. Variables are hierarchically clustered to reveal patterns of related measures.
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/workflow.rst b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/workflow.rst
new file mode 100644
index 0000000..0dadb46
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/workflow.rst
@@ -0,0 +1,10 @@
+Simple Correlation Workflow
+===========================
+
+This workflow demonstrates a simple pandas-based data analysis pipeline:
+
+1. **Data Loading**: Downloads two datasets from the Self-Regulation Ontology project
+2. **Filtering**: Removes non-numerical columns from both datasets
+3. **Joining**: Combines the datasets based on their common index (subject IDs)
+4. **Correlation**: Computes Spearman correlation matrix across all measures
+5. **Visualization**: Generates a clustered heatmap showing correlation patterns
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py
new file mode 100644
index 0000000..5095888
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py
@@ -0,0 +1,34 @@
+"""Snakemake script for computing correlation matrix."""
+
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.correlation import (
+    compute_correlation_matrix,
+)
+
+
+def main():
+    """Compute Spearman correlation matrix."""
+    # ruff: noqa: F821
+    input_path = Path(snakemake.input[0])
+    output_path = Path(snakemake.output[0])
+    method = snakemake.params.method
+
+    # Load data
+    df = pd.read_csv(input_path, index_col=0)
+    print(f"Loaded {df.shape} from {input_path}")
+
+    # Compute correlation
+    corr_matrix = compute_correlation_matrix(df, method=method)
+    print(f"Computed {method} correlation matrix: {corr_matrix.shape}")
+
+    # Save
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    corr_matrix.to_csv(output_path)
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py
new file mode 100644
index 0000000..61474f2
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py
@@ -0,0 +1,26 @@
+"""Snakemake script for downloading data from URL."""
+
+from pathlib import Path
+
+import pandas as pd
+
+
+def main():
+    """Download data from URL."""
+    # ruff: noqa: F821
+    url = snakemake.params.url
+    output_path = Path(snakemake.output[0])
+
+    # Create output directory
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Download and save
+    df = pd.read_csv(url, index_col=0)
+    df.to_csv(output_path)
+
+    print(f"Downloaded {len(df)} rows from {url}")
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py
new file mode 100644
index 0000000..325b818
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py
@@ -0,0 +1,33 @@
+"""Snakemake script for filtering data to numerical columns."""
+
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.filter_data import (
+    filter_numerical_columns,
+)
+
+
+def main():
+    """Filter data to numerical columns."""
+    # ruff: noqa: F821
+    input_path = Path(snakemake.input[0])
+    output_path = Path(snakemake.output[0])
+
+    # Load data
+    df = pd.read_csv(input_path, index_col=0)
+    print(f"Loaded {df.shape} from {input_path}")
+
+    # Filter to numerical columns
+    df_num = filter_numerical_columns(df)
+    print(f"Filtered to {df_num.shape} (numerical columns only)")
+
+    # Save
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df_num.to_csv(output_path)
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/generate_heatmap.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/generate_heatmap.py
new file mode 100644
index 0000000..cb59946
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/generate_heatmap.py
@@ -0,0 +1,40 @@
+"""Snakemake script for generating clustered heatmap."""
+
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.visualization import (
+    generate_clustered_heatmap,
+)
+
+
+def main():
+    """Generate and save clustered heatmap."""
+    # ruff: noqa: F821
+    input_path = Path(snakemake.input[0])
+    output_path = Path(snakemake.output[0])
+    figsize = tuple(snakemake.params.figsize)
+    cmap = snakemake.params.cmap
+    vmin = snakemake.params.vmin
+    vmax = snakemake.params.vmax
+
+    # Load correlation matrix
+    corr_matrix = pd.read_csv(input_path, index_col=0)
+    print(f"Loaded correlation matrix: {corr_matrix.shape}")
+
+    # Generate heatmap
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    generate_clustered_heatmap(
+        corr_matrix,
+        output_path=output_path,
+        figsize=figsize,
+        cmap=cmap,
+        vmin=vmin,
+        vmax=vmax,
+    )
+    print(f"Saved heatmap to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py
new file mode 100644
index 0000000..73b915d
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py
@@ -0,0 +1,35 @@
+"""Snakemake script for joining two dataframes."""
+
+from pathlib import Path
+
+import pandas as pd
+
+from BetterCodeBetterScience.simple_workflow.join_data import join_dataframes
+
+
+def main():
+    """Join the two datasets."""
+    # ruff: noqa: F821
+    mv_path = Path(snakemake.input.meaningful_vars)
+    demo_path = Path(snakemake.input.demographics)
+    output_path = Path(snakemake.output[0])
+
+    # Load data
+    meaningful_vars = pd.read_csv(mv_path, index_col=0)
+    demographics = pd.read_csv(demo_path, index_col=0)
+
+    print(f"Meaningful variables: {meaningful_vars.shape}")
+    print(f"Demographics: {demographics.shape}")
+
+    # Join
+    joined = join_dataframes(meaningful_vars, demographics)
+    print(f"Joined: {joined.shape}")
+
+    # Save
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    joined.to_csv(output_path)
+    print(f"Saved to {output_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/BetterCodeBetterScience/simple_workflow/visualization.py b/src/BetterCodeBetterScience/simple_workflow/visualization.py
new file mode 100644
index 0000000..5c30f19
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/visualization.py
@@ -0,0 +1,85 @@
+"""Visualization module for the simple workflow example.
+
+This module provides functions to generate heatmaps from correlation matrices.
+"""
+
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+
+
+def generate_clustered_heatmap(
+    corr_matrix: pd.DataFrame,
+    output_path: Path | None = None,
+    figsize: tuple[int, int] = (12, 10),
+    cmap: str = "coolwarm",
+    vmin: float = -1.0,
+    vmax: float = 1.0,
+) -> sns.matrix.ClusterGrid:
+    """Generate a clustered heatmap from a correlation matrix.
+
+    Parameters
+    ----------
+    corr_matrix : pd.DataFrame
+        Correlation matrix
+    output_path : Path, optional
+        If provided, save the figure to this path
+    figsize : tuple
+        Figure size (width, height) in inches
+    cmap : str
+        Colormap name (default: 'coolwarm')
+    vmin : float
+        Minimum value for color scale
+    vmax : float
+        Maximum value for color scale
+
+    Returns
+    -------
+    sns.matrix.ClusterGrid
+        The ClusterGrid object containing the heatmap
+    """
+    # Create clustered heatmap
+    g = sns.clustermap(
+        corr_matrix,
+        cmap=cmap,
+        vmin=vmin,
+        vmax=vmax,
+        figsize=figsize,
+        dendrogram_ratio=(0.1, 0.1),
+        cbar_pos=(0.02, 0.8, 0.03, 0.15),
+        xticklabels=True,
+        yticklabels=True,
+    )
+
+    # Rotate x-axis labels for readability
+    plt.setp(g.ax_heatmap.get_xticklabels(), rotation=90, fontsize=6)
+    plt.setp(g.ax_heatmap.get_yticklabels(), rotation=0, fontsize=6)
+
+    # Set title
+    g.fig.suptitle("Clustered Correlation Heatmap (Spearman)", y=1.02, fontsize=14)
+
+    # Save if output path provided
+    if output_path is not None:
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        g.savefig(output_path, dpi=150, bbox_inches="tight")
+
+    return g
+
+
+def save_correlation_matrix(
+    corr_matrix: pd.DataFrame,
+    output_path: Path,
+) -> None:
+    """Save a correlation matrix to a CSV file.
+
+    Parameters
+    ----------
+    corr_matrix : pd.DataFrame
+        Correlation matrix
+    output_path : Path
+        Path to save the CSV file
+    """
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    corr_matrix.to_csv(output_path)

From 2a13fd2da2718ab4c50715368daa0161d389d98b Mon Sep 17 00:00:00 2001
From: Russ Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 14:40:23 -0800
Subject: [PATCH 70/87] add reporting cmd

---
 src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
index 52d3e71..59a7b59 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
@@ -3,3 +3,6 @@ export
 
 rulegraph:
 	snakemake --rulegraph --config datadir=$(DATADIR)/immune_aging/workflow/ --cores 2 | dot -Tpng > rulegraph.png
+
+report:
+	snakemake --verbose --report report.html --config datadir=$(DATADIR)/immune_aging/ --cores 1

From c37360e7247df64240b1fa4e6b214fbdf4789ee8 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 14:44:05 -0800
Subject: [PATCH 71/87] fix paths

---
 .../rnaseq/snakemake_workflow/Makefile            | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
index 0947d14..147bd26 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile
@@ -3,26 +3,25 @@ export
 
 # Generate rule dependency graph
 rulegraph:
-	snakemake --rulegraph --config datadir=$(DATADIR)/immune_aging/workflow/ --cores 2 | dot -Tpng > rulegraph.png
+	snakemake --rulegraph --config datadir=$(DATADIR)/immune_aging/wf_snakemake/ --cores 2 | dot -Tpng > rulegraph.png
 
 # Run the full workflow
 run:
-	snakemake --cores 8 --config datadir=$(DATADIR)/immune_aging/workflow/
-
+	snakemake --cores 8 --config datadir=$(DATADIR)/immune_aging/wf_snakemake/
 # Generate HTML report (run after workflow completes)
 report:
-	snakemake --report $(DATADIR)/immune_aging/workflow/wf_snakemake/report.html --config datadir=$(DATADIR)/immune_aging/workflow/
+	snakemake --report $(DATADIR)/immune_aging/wf_snakemake/report.html --config datadir=$(DATADIR)/immune_aging/
 
 # Generate ZIP report (for larger reports with many figures)
 report-zip:
-	snakemake --report $(DATADIR)/immune_aging/workflow/wf_snakemake/report.zip --config datadir=$(DATADIR)/immune_aging/workflow/
+	snakemake --report $(DATADIR)/immune_aging/workflow/wf_snakemake/report.zip --config datadir=$(DATADIR)/immune_aging/
 
 # Dry run - show what would be executed
 dry-run:
-	snakemake -n --config datadir=$(DATADIR)/immune_aging/workflow/
+	snakemake -n --config datadir=$(DATADIR)/immune_aging/wf_snakemake/
 
 # Clean all outputs
 clean:
-	rm -rf $(DATADIR)/immune_aging/workflow/wf_snakemake/
-
+	rm -rf $(DATADIR)/immune_aging/wf_snakemake
+	
 .PHONY: rulegraph run report report-zip dry-run clean

From daebf73f03aa764bd77c45380537332dadf79e94 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 14:51:46 -0800
Subject: [PATCH 72/87] Fix missing doublet UMAP visualization in QC step
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The doublet_detection_umap.png was declared as an output in the
Snakemake workflow but never generated because:
1. plot_doublets() was never called in run_qc_pipeline()
2. No UMAP coordinates existed at the QC step

Added compute_umap_for_qc() to compute a simple UMAP embedding
specifically for doublet visualization. This runs on a temporary
copy to preserve raw counts, then copies coordinates back.

Updated run_qc_pipeline() to compute UMAP and plot doublets after
detection but before filtering, so both doublets and singlets are
visible in the visualization.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../modular_workflow/quality_control.py       | 51 ++++++++++++++++++-
 1 file changed, 49 insertions(+), 2 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
index 92fa012..3e83822 100644
--- a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
+++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py
@@ -224,16 +224,56 @@ def detect_doublets_per_donor(
     return adata_combined
 
 
+def compute_umap_for_qc(adata: ad.AnnData, n_pcs: int = 30) -> ad.AnnData:
+    """Compute a simple UMAP embedding for QC visualization.
+
+    This computes a quick UMAP on the raw counts for visualizing
+    doublet detection results. This is separate from the main
+    dimensionality reduction in step 5.
+
+    Parameters
+    ----------
+    adata : AnnData
+        AnnData object (raw counts in .X)
+    n_pcs : int
+        Number of principal components to use
+
+    Returns
+    -------
+    AnnData
+        AnnData with UMAP coordinates in .obsm['X_umap']
+    """
+    # Work on a copy to avoid modifying the original
+    adata_temp = adata.copy()
+
+    # Basic preprocessing for UMAP computation
+    sc.pp.normalize_total(adata_temp, target_sum=1e4)
+    sc.pp.log1p(adata_temp)
+    sc.pp.highly_variable_genes(adata_temp, n_top_genes=2000, flavor="seurat_v3")
+    sc.pp.pca(adata_temp, n_comps=n_pcs, use_highly_variable=True)
+    sc.pp.neighbors(adata_temp, n_neighbors=15, n_pcs=n_pcs)
+    sc.tl.umap(adata_temp)
+
+    # Copy UMAP coordinates back to original
+    adata.obsm["X_umap"] = adata_temp.obsm["X_umap"]
+
+    return adata
+
+
 def plot_doublets(adata: ad.AnnData, figure_dir: Path | None = None) -> None:
     """Visualize doublet detection results on UMAP.
 
     Parameters
     ----------
     adata : AnnData
-        AnnData object with doublet annotations
+        AnnData object with doublet annotations and UMAP coordinates
     figure_dir : Path, optional
         Directory to save figures
     """
+    if "X_umap" not in adata.obsm:
+        print("Warning: No UMAP coordinates found, skipping doublet plot")
+        return
+
     sc.pl.umap(adata, color=["doublet_score", "predicted_doublet"], size=20, show=False)
     if figure_dir is not None:
         plt.savefig(
@@ -312,8 +352,15 @@ def run_qc_pipeline(
         adata, min_genes, max_genes, min_counts, max_counts, max_hb_pct
     )
 
-    # Detect and filter doublets
+    # Detect doublets
     adata = detect_doublets_per_donor(adata, expected_doublet_rate)
+
+    # Compute UMAP for doublet visualization (before filtering)
+    print("Computing UMAP for doublet visualization...")
+    adata = compute_umap_for_qc(adata)
+    plot_doublets(adata, figure_dir)
+
+    # Filter doublets
     adata = filter_doublets(adata)
 
     # Save raw counts for HVG selection (step 4) and pseudobulking (step 7)

From a07cecb66f80d0cd8ab36d6dea508ae5a31cba4d Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 15:22:06 -0800
Subject: [PATCH 73/87] Fix report caption paths in Snakemake rule files
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Caption paths were relative to the rules/ directory but pointed to
report/ instead of ../report/. This caused "caption file not found"
errors when generating Snakemake reports.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../snakemake_workflow/rules/per_cell_type.smk   |  6 +++---
 .../snakemake_workflow/rules/preprocessing.smk   | 16 ++++++++--------
 .../snakemake_workflow/rules/pseudobulk.smk      |  2 +-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
index c5b0149..ea5bbe1 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk
@@ -41,7 +41,7 @@ rule pathway_analysis:
         gsea_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "gsea_results.pkl",
         fig_gsea=report(
             RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "gsea_pathways.png",
-            caption="report/gsea.rst",
+            caption="../report/gsea.rst",
             category="Step 9: Pathway Analysis (GSEA)",
             subcategory="{cell_type}",
         ),
@@ -67,7 +67,7 @@ rule overrepresentation:
         enr_down=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "enrichr_down.pkl",
         fig_enrichr=report(
             RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "enrichr_pathways.png",
-            caption="report/enrichr.rst",
+            caption="../report/enrichr.rst",
             category="Step 10: Overrepresentation Analysis",
             subcategory="{cell_type}",
         ),
@@ -98,7 +98,7 @@ rule predictive_modeling:
         / "prediction_results.pkl",
         fig_prediction=report(
             RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "age_prediction_performance.png",
-            caption="report/prediction.rst",
+            caption="../report/prediction.rst",
             category="Step 11: Predictive Modeling",
             subcategory="{cell_type}",
         ),
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
index 29d4946..5700454 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk
@@ -30,7 +30,7 @@ rule filter_data:
         checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"),
         fig_donor_counts=report(
             FIGURE_DIR / "donor_cell_counts_distribution.png",
-            caption="report/filtering.rst",
+            caption="../report/filtering.rst",
             category="Step 2: Filtering",
         ),
     params:
@@ -52,22 +52,22 @@ rule quality_control:
         checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"),
         fig_violin=report(
             FIGURE_DIR / "qc_violin_plots.png",
-            caption="report/qc_violin.rst",
+            caption="../report/qc_violin.rst",
             category="Step 3: Quality Control",
         ),
         fig_scatter=report(
             FIGURE_DIR / "qc_scatter_doublets.png",
-            caption="report/qc_scatter.rst",
+            caption="../report/qc_scatter.rst",
             category="Step 3: Quality Control",
         ),
         fig_hemoglobin=report(
             FIGURE_DIR / "hemoglobin_distribution.png",
-            caption="report/hemoglobin.rst",
+            caption="../report/hemoglobin.rst",
             category="Step 3: Quality Control",
         ),
         fig_doublet_umap=report(
             FIGURE_DIR / "doublet_detection_umap.png",
-            caption="report/doublet_umap.rst",
+            caption="../report/doublet_umap.rst",
             category="Step 3: Quality Control",
         ),
     threads: workflow.cores
@@ -110,12 +110,12 @@ rule dimensionality_reduction:
         checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"),
         fig_pca=report(
             FIGURE_DIR / "pca_cell_type.png",
-            caption="report/pca.rst",
+            caption="../report/pca.rst",
             category="Step 5: Dimensionality Reduction",
         ),
         fig_umap=report(
             FIGURE_DIR / "umap_total_counts.png",
-            caption="report/umap.rst",
+            caption="../report/umap.rst",
             category="Step 5: Dimensionality Reduction",
         ),
     threads: workflow.cores
@@ -138,7 +138,7 @@ rule clustering:
         checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"),
         fig_clustering=report(
             FIGURE_DIR / "umap_cell_type_leiden.png",
-            caption="report/clustering.rst",
+            caption="../report/clustering.rst",
             category="Step 6: Clustering",
         ),
     params:
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
index 7e71baf..606ab86 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk
@@ -29,7 +29,7 @@ checkpoint pseudobulk:
         # Pseudobulk figure
         fig_pseudobulk=report(
             FIGURE_DIR / "pseudobulk_violin.png",
-            caption="report/pseudobulk.rst",
+            caption="../report/pseudobulk.rst",
             category="Step 7: Pseudobulking",
         ),
     params:

From de06d21c74d178aa1920a486c388d299d8de65ff Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Tue, 23 Dec 2025 15:34:37 -0800
Subject: [PATCH 74/87] Fix Snakemake scripts to use named output references
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Scripts were using snakemake.output[0] but the rules have named
outputs (checkpoint=, fig_*=). This caused checkpoint files to not
be saved to the correct path. Changed to snakemake.output.checkpoint
in filter.py, qc.py, dimred.py, and cluster.py.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 .../rnaseq/snakemake_workflow/scripts/cluster.py                | 2 +-
 .../rnaseq/snakemake_workflow/scripts/dimred.py                 | 2 +-
 .../rnaseq/snakemake_workflow/scripts/filter.py                 | 2 +-
 .../rnaseq/snakemake_workflow/scripts/qc.py                     | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
index 4a67cb4..ff8ed68 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py
@@ -15,7 +15,7 @@ def main():
     """Run clustering pipeline."""
     # ruff: noqa: F821
     input_file = Path(snakemake.input[0])
-    output_file = Path(snakemake.output[0])
+    output_file = Path(snakemake.output.checkpoint)
 
     # Get parameters
     resolution = snakemake.params.resolution
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
index 4ce8f1e..4e72cb6 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py
@@ -22,7 +22,7 @@ def main():
     print(f"Running with {snakemake.threads} threads")
 
     input_file = Path(snakemake.input[0])
-    output_file = Path(snakemake.output[0])
+    output_file = Path(snakemake.output.checkpoint)
 
     # Get parameters
     batch_key = snakemake.params.batch_key
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
index 4935521..41a24bc 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py
@@ -15,7 +15,7 @@ def main():
     """Load data and run filtering pipeline."""
     # ruff: noqa: F821
     input_file = Path(snakemake.input[0])
-    output_file = Path(snakemake.output[0])
+    output_file = Path(snakemake.output.checkpoint)
 
     # Get parameters
     cutoff_percentile = snakemake.params.cutoff_percentile
diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
index 4839258..abda90f 100644
--- a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
+++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py
@@ -15,7 +15,7 @@ def main():
     """Run quality control pipeline."""
     # ruff: noqa: F821
     input_file = Path(snakemake.input[0])
-    output_file = Path(snakemake.output[0])
+    output_file = Path(snakemake.output.checkpoint)
 
     # Get parameters
     min_genes = snakemake.params.min_genes

From 7dcc0a160b71479367a22942ea680065785ece5a Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 05:55:15 -0800
Subject: [PATCH 75/87] file naming

---
 myst.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/myst.yml b/myst.yml
index 741d1b8..edc3d9b 100644
--- a/myst.yml
+++ b/myst.yml
@@ -23,7 +23,7 @@ project:
     - file: book/project_organization.md
     - file: book/data_management.md
 # - file: workflows
-# - file: validation_robustness.md
+# - file: validation.md
 # - file: performance
 # - file: HPC
 # - file: sharing

From dd97412f3edc1024c550c92df596589c019cb678 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 05:56:51 -0800
Subject: [PATCH 76/87] simplify workflow

---
 .../simple_workflow/make_workflow/Makefile    | 107 ++----------------
 .../scripts/compute_correlation.py            |  22 ++--
 .../make_workflow/scripts/download_data.py    |  32 +++---
 .../make_workflow/scripts/filter_data.py      |  34 +++---
 .../make_workflow/scripts/generate_heatmap.py |  12 +-
 .../make_workflow/scripts/join_data.py        |  28 ++---
 6 files changed, 69 insertions(+), 166 deletions(-)

diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile b/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile
index b1c642f..b3367b6 100644
--- a/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile
@@ -1,107 +1,20 @@
 # Simple Correlation Workflow using Make
 #
-# This Makefile demonstrates a simple data analysis pipeline using Make.
-# Each target represents a step in the workflow, with dependencies ensuring
-# correct execution order.
-#
 # Usage:
-#   make OUTPUT_DIR=/path/to/output all
-#   make OUTPUT_DIR=/path/to/output clean
-#   make OUTPUT_DIR=/path/to/output help
+#   make all              - Run full workflow
+#   make clean            - Remove output directory
 
-# Configuration
 OUTPUT_DIR ?= ./output
-DATA_DIR := $(OUTPUT_DIR)/data
-RESULTS_DIR := $(OUTPUT_DIR)/results
-FIGURES_DIR := $(OUTPUT_DIR)/figures
-LOGS_DIR := $(OUTPUT_DIR)/logs
-
-# Data URLs
-MV_URL := https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv
-DEMO_URL := https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv
-
-# Python command
-PYTHON := python
-
-# Default target
-.PHONY: all
-all: $(FIGURES_DIR)/correlation_heatmap.png
-
-# Help target
-.PHONY: help
-help:
-	@echo "Simple Correlation Workflow"
-	@echo ""
-	@echo "Usage: make OUTPUT_DIR=/path/to/output <target>"
-	@echo ""
-	@echo "Targets:"
-	@echo "  all      - Run full workflow (default)"
-	@echo "  clean    - Remove all generated files"
-	@echo "  help     - Show this help message"
-	@echo ""
-	@echo "Individual steps:"
-	@echo "  download_mv    - Download meaningful variables data"
-	@echo "  download_demo  - Download demographics data"
-	@echo "  filter_mv      - Filter meaningful variables to numerical"
-	@echo "  filter_demo    - Filter demographics to numerical"
-	@echo "  join           - Join the two datasets"
-	@echo "  correlation    - Compute correlation matrix"
-	@echo "  heatmap        - Generate clustered heatmap"
-
-# Create directories
-$(DATA_DIR) $(RESULTS_DIR) $(FIGURES_DIR) $(LOGS_DIR):
-	mkdir -p $@
-
-# Step 1a: Download meaningful variables
-.PHONY: download_mv
-download_mv: $(DATA_DIR)/meaningful_variables.csv
-
-$(DATA_DIR)/meaningful_variables.csv: | $(DATA_DIR) $(LOGS_DIR)
-	$(PYTHON) scripts/download_data.py "$(MV_URL)" "$@" > $(LOGS_DIR)/download_mv.log 2>&1
-
-# Step 1b: Download demographics
-.PHONY: download_demo
-download_demo: $(DATA_DIR)/demographics.csv
-
-$(DATA_DIR)/demographics.csv: | $(DATA_DIR) $(LOGS_DIR)
-	$(PYTHON) scripts/download_data.py "$(DEMO_URL)" "$@" > $(LOGS_DIR)/download_demo.log 2>&1
-
-# Step 2a: Filter meaningful variables
-.PHONY: filter_mv
-filter_mv: $(DATA_DIR)/meaningful_variables_numerical.csv
-
-$(DATA_DIR)/meaningful_variables_numerical.csv: $(DATA_DIR)/meaningful_variables.csv | $(LOGS_DIR)
-	$(PYTHON) scripts/filter_data.py "$<" "$@" > $(LOGS_DIR)/filter_mv.log 2>&1
-
-# Step 2b: Filter demographics
-.PHONY: filter_demo
-filter_demo: $(DATA_DIR)/demographics_numerical.csv
-
-$(DATA_DIR)/demographics_numerical.csv: $(DATA_DIR)/demographics.csv | $(LOGS_DIR)
-	$(PYTHON) scripts/filter_data.py "$<" "$@" > $(LOGS_DIR)/filter_demo.log 2>&1
-
-# Step 3: Join datasets
-.PHONY: join
-join: $(DATA_DIR)/joined_data.csv
-
-$(DATA_DIR)/joined_data.csv: $(DATA_DIR)/meaningful_variables_numerical.csv $(DATA_DIR)/demographics_numerical.csv | $(LOGS_DIR)
-	$(PYTHON) scripts/join_data.py "$<" "$(word 2,$^)" "$@" > $(LOGS_DIR)/join.log 2>&1
-
-# Step 4: Compute correlation
-.PHONY: correlation
-correlation: $(RESULTS_DIR)/correlation_matrix.csv
-
-$(RESULTS_DIR)/correlation_matrix.csv: $(DATA_DIR)/joined_data.csv | $(RESULTS_DIR) $(LOGS_DIR)
-	$(PYTHON) scripts/compute_correlation.py "$<" "$@" > $(LOGS_DIR)/correlation.log 2>&1
 
-# Step 5: Generate heatmap
-.PHONY: heatmap
-heatmap: $(FIGURES_DIR)/correlation_heatmap.png
+.PHONY: all clean
 
-$(FIGURES_DIR)/correlation_heatmap.png: $(RESULTS_DIR)/correlation_matrix.csv | $(FIGURES_DIR) $(LOGS_DIR)
-	$(PYTHON) scripts/generate_heatmap.py "$<" "$@" > $(LOGS_DIR)/heatmap.log 2>&1
+all:
+	mkdir -p $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures
+	python scripts/download_data.py $(OUTPUT_DIR)/data
+	python scripts/filter_data.py $(OUTPUT_DIR)/data
+	python scripts/join_data.py $(OUTPUT_DIR)/data
+	python scripts/compute_correlation.py $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results
+	python scripts/generate_heatmap.py $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures
 
-# Clean target
-.PHONY: clean
 clean:
 	rm -rf $(OUTPUT_DIR)
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py
index 500366e..e09a55b 100644
--- a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py
@@ -2,7 +2,7 @@
 """Compute Spearman correlation matrix.
 
 Usage:
-    python compute_correlation.py <input_path> <output_path>
+    python compute_correlation.py <data_dir> <results_dir>
 """
 
 import sys
@@ -18,24 +18,20 @@
 def main():
     """Compute Spearman correlation matrix."""
     if len(sys.argv) != 3:
-        print("Usage: python compute_correlation.py <input_path> <output_path>")
+        print("Usage: python compute_correlation.py <data_dir> <results_dir>")
         sys.exit(1)
 
-    input_path = Path(sys.argv[1])
-    output_path = Path(sys.argv[2])
+    data_dir = Path(sys.argv[1])
+    results_dir = Path(sys.argv[2])
 
-    # Load data
-    df = pd.read_csv(input_path, index_col=0)
-    print(f"Loaded {df.shape} from {input_path}")
+    # Load joined data
+    df = pd.read_csv(data_dir / "joined_data.csv", index_col=0)
+    print(f"Loaded joined data: {df.shape}")
 
     # Compute correlation
     corr_matrix = compute_spearman_correlation(df)
-    print(f"Computed Spearman correlation matrix: {corr_matrix.shape}")
-
-    # Save
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    corr_matrix.to_csv(output_path)
-    print(f"Saved to {output_path}")
+    corr_matrix.to_csv(results_dir / "correlation_matrix.csv")
+    print(f"Saved correlation matrix: {corr_matrix.shape}")
 
 
 if __name__ == "__main__":
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py
index b843979..a3abe23 100644
--- a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
-"""Download data from URL and save to CSV.
+"""Download data files.
 
 Usage:
-    python download_data.py <url> <output_path>
+    python download_data.py <data_dir>
 """
 
 import sys
@@ -10,25 +10,27 @@
 
 import pandas as pd
 
+MV_URL = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv"
+DEMO_URL = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv"
+
 
 def main():
-    """Download data from URL."""
-    if len(sys.argv) != 3:
-        print("Usage: python download_data.py <url> <output_path>")
+    """Download both data files."""
+    if len(sys.argv) != 2:
+        print("Usage: python download_data.py <data_dir>")
         sys.exit(1)
 
-    url = sys.argv[1]
-    output_path = Path(sys.argv[2])
-
-    # Create output directory
-    output_path.parent.mkdir(parents=True, exist_ok=True)
+    data_dir = Path(sys.argv[1])
 
-    # Download and save
-    df = pd.read_csv(url, index_col=0)
-    df.to_csv(output_path)
+    # Download meaningful variables
+    mv_df = pd.read_csv(MV_URL, index_col=0)
+    mv_df.to_csv(data_dir / "meaningful_variables.csv")
+    print(f"Downloaded meaningful_variables.csv ({len(mv_df)} rows)")
 
-    print(f"Downloaded {len(df)} rows from {url}")
-    print(f"Saved to {output_path}")
+    # Download demographics
+    demo_df = pd.read_csv(DEMO_URL, index_col=0)
+    demo_df.to_csv(data_dir / "demographics.csv")
+    print(f"Downloaded demographics.csv ({len(demo_df)} rows)")
 
 
 if __name__ == "__main__":
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py
index 62f0c86..73c13bc 100644
--- a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
-"""Filter dataframe to numerical columns only.
+"""Filter dataframes to numerical columns only.
 
 Usage:
-    python filter_data.py <input_path> <output_path>
+    python filter_data.py <data_dir>
 """
 
 import sys
@@ -16,26 +16,24 @@
 
 
 def main():
-    """Filter data to numerical columns."""
-    if len(sys.argv) != 3:
-        print("Usage: python filter_data.py <input_path> <output_path>")
+    """Filter both datasets to numerical columns."""
+    if len(sys.argv) != 2:
+        print("Usage: python filter_data.py <data_dir>")
         sys.exit(1)
 
-    input_path = Path(sys.argv[1])
-    output_path = Path(sys.argv[2])
+    data_dir = Path(sys.argv[1])
 
-    # Load data
-    df = pd.read_csv(input_path, index_col=0)
-    print(f"Loaded {df.shape} from {input_path}")
+    # Filter meaningful variables
+    mv_df = pd.read_csv(data_dir / "meaningful_variables.csv", index_col=0)
+    mv_num = filter_numerical_columns(mv_df)
+    mv_num.to_csv(data_dir / "meaningful_variables_numerical.csv")
+    print(f"Filtered meaningful_variables: {mv_df.shape} -> {mv_num.shape}")
 
-    # Filter to numerical columns
-    df_num = filter_numerical_columns(df)
-    print(f"Filtered to {df_num.shape} (numerical columns only)")
-
-    # Save
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    df_num.to_csv(output_path)
-    print(f"Saved to {output_path}")
+    # Filter demographics
+    demo_df = pd.read_csv(data_dir / "demographics.csv", index_col=0)
+    demo_num = filter_numerical_columns(demo_df)
+    demo_num.to_csv(data_dir / "demographics_numerical.csv")
+    print(f"Filtered demographics: {demo_df.shape} -> {demo_num.shape}")
 
 
 if __name__ == "__main__":
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py
index 1f55cde..11b0415 100644
--- a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py
@@ -2,7 +2,7 @@
 """Generate clustered heatmap from correlation matrix.
 
 Usage:
-    python generate_heatmap.py <input_path> <output_path>
+    python generate_heatmap.py <results_dir> <figures_dir>
 """
 
 import sys
@@ -18,18 +18,18 @@
 def main():
     """Generate and save clustered heatmap."""
     if len(sys.argv) != 3:
-        print("Usage: python generate_heatmap.py <input_path> <output_path>")
+        print("Usage: python generate_heatmap.py <results_dir> <figures_dir>")
         sys.exit(1)
 
-    input_path = Path(sys.argv[1])
-    output_path = Path(sys.argv[2])
+    results_dir = Path(sys.argv[1])
+    figures_dir = Path(sys.argv[2])
 
     # Load correlation matrix
-    corr_matrix = pd.read_csv(input_path, index_col=0)
+    corr_matrix = pd.read_csv(results_dir / "correlation_matrix.csv", index_col=0)
     print(f"Loaded correlation matrix: {corr_matrix.shape}")
 
     # Generate heatmap
-    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path = figures_dir / "correlation_heatmap.png"
     generate_clustered_heatmap(corr_matrix, output_path=output_path)
     print(f"Saved heatmap to {output_path}")
 
diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py
index 593a713..b8f09f4 100644
--- a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py
@@ -2,7 +2,7 @@
 """Join two dataframes based on their index.
 
 Usage:
-    python join_data.py <input1_path> <input2_path> <output_path>
+    python join_data.py <data_dir>
 """
 
 import sys
@@ -15,30 +15,24 @@
 
 def main():
     """Join the two datasets."""
-    if len(sys.argv) != 4:
-        print("Usage: python join_data.py <input1_path> <input2_path> <output_path>")
+    if len(sys.argv) != 2:
+        print("Usage: python join_data.py <data_dir>")
         sys.exit(1)
 
-    input1_path = Path(sys.argv[1])
-    input2_path = Path(sys.argv[2])
-    output_path = Path(sys.argv[3])
+    data_dir = Path(sys.argv[1])
 
-    # Load data
-    df1 = pd.read_csv(input1_path, index_col=0)
-    df2 = pd.read_csv(input2_path, index_col=0)
+    # Load filtered data
+    mv_df = pd.read_csv(data_dir / "meaningful_variables_numerical.csv", index_col=0)
+    demo_df = pd.read_csv(data_dir / "demographics_numerical.csv", index_col=0)
 
-    print(f"Dataset 1: {df1.shape}")
-    print(f"Dataset 2: {df2.shape}")
+    print(f"Meaningful variables: {mv_df.shape}")
+    print(f"Demographics: {demo_df.shape}")
 
     # Join
-    joined = join_dataframes(df1, df2)
+    joined = join_dataframes(mv_df, demo_df)
+    joined.to_csv(data_dir / "joined_data.csv")
     print(f"Joined: {joined.shape}")
 
-    # Save
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    joined.to_csv(output_path)
-    print(f"Saved to {output_path}")
-
 
 if __name__ == "__main__":
     main()

From 066be6766db7e4806358c45c97bc8780a6737e6c Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 05:57:39 -0800
Subject: [PATCH 77/87] clean up figure

---
 .../simple_workflow/visualization.py                  | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/BetterCodeBetterScience/simple_workflow/visualization.py b/src/BetterCodeBetterScience/simple_workflow/visualization.py
index 5c30f19..f6dddca 100644
--- a/src/BetterCodeBetterScience/simple_workflow/visualization.py
+++ b/src/BetterCodeBetterScience/simple_workflow/visualization.py
@@ -13,7 +13,7 @@
 def generate_clustered_heatmap(
     corr_matrix: pd.DataFrame,
     output_path: Path | None = None,
-    figsize: tuple[int, int] = (12, 10),
+    figsize: tuple[int, int] = (8, 10),
     cmap: str = "coolwarm",
     vmin: float = -1.0,
     vmax: float = 1.0,
@@ -49,13 +49,12 @@ def generate_clustered_heatmap(
         figsize=figsize,
         dendrogram_ratio=(0.1, 0.1),
         cbar_pos=(0.02, 0.8, 0.03, 0.15),
-        xticklabels=True,
+        xticklabels=False,
         yticklabels=True,
     )
 
-    # Rotate x-axis labels for readability
-    plt.setp(g.ax_heatmap.get_xticklabels(), rotation=90, fontsize=6)
-    plt.setp(g.ax_heatmap.get_yticklabels(), rotation=0, fontsize=6)
+    # Set y-axis label font size
+    plt.setp(g.ax_heatmap.get_yticklabels(), rotation=0, fontsize=3)
 
     # Set title
     g.fig.suptitle("Clustered Correlation Heatmap (Spearman)", y=1.02, fontsize=14)
@@ -63,7 +62,7 @@ def generate_clustered_heatmap(
     # Save if output path provided
     if output_path is not None:
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        g.savefig(output_path, dpi=150, bbox_inches="tight")
+        g.savefig(output_path, dpi=300, bbox_inches="tight")
 
     return g
 

From 584e0c112dad82c7036c98ae4761a518bdc6622f Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 05:59:00 -0800
Subject: [PATCH 78/87] add return values

---
 src/BetterCodeBetterScience/simple_workflow/filter_data.py | 1 +
 src/BetterCodeBetterScience/simple_workflow/load_data.py   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/BetterCodeBetterScience/simple_workflow/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/filter_data.py
index 292d73a..c4b3bbe 100644
--- a/src/BetterCodeBetterScience/simple_workflow/filter_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/filter_data.py
@@ -53,3 +53,4 @@ def filter_demographics(df: pd.DataFrame) -> pd.DataFrame:
         Filtered dataframe with only numerical columns
     """
     return filter_numerical_columns(df)
+
diff --git a/src/BetterCodeBetterScience/simple_workflow/load_data.py b/src/BetterCodeBetterScience/simple_workflow/load_data.py
index 59a3c98..5f67460 100644
--- a/src/BetterCodeBetterScience/simple_workflow/load_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/load_data.py
@@ -84,3 +84,4 @@ def load_demographics(
         df.to_csv(cache_path)
 
     return df
+

From 7e87b67e13246fc56cfd0ed1801fc8b8a7c4009d Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 05:59:23 -0800
Subject: [PATCH 79/87] first draft of simple workflows

---
 book/workflows.md | 123 ++++++++++++++++++++++++++++++++++++----------
 1 file changed, 98 insertions(+), 25 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index 041d1f1..075c0f8 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -20,7 +20,7 @@ Third, we care about the *engineering quality* of the code, which includes:
 
 - *Maintainability*: The workflow is structured and documented so that others (including your future self) can easily maintain, update, and extend it in the future.
 - *Modularity*: The workflow is composed of a set of independently testable modules, which can be swapped in or out relatively easily.
-- *Idempotency*: This term from computer science means that the result of the workflow does not change after its first successful run, which allows safely rerunning the workflow when there is a failure.
+- *Idempotency*: This term from computer science means that the result of the workflow does not change after its first successful run, which allows safely rerunning the workflow.
 - *Traceability*:  All operations are logged, and provenance information is stored for outputs.
 
 Finally, we care about the *efficiency* of the workflow implementation. This includes:
@@ -91,10 +91,99 @@ Name: EverArrested, dtype: float64
 
 Note that `pandas` data frames also include an explicit `.pipe` method that allows using arbitrary functions within a pipeline.  While these kinds of pipelines can be useful for simple data processing operations, they can become very difficult to debug, so I would generally avoid using complex functions within a method chain.
 
+## A simple workflow example
 
-## An example of a complex workflow
+Most real scientific workflows are complex and can often run for hours, and we will encounter such a complex workflow later in the chapter. However, we will start our discussion of workflows with a relatively simple and fast-running example that will help us understand the basic concepts of workflow execution. We will use the same data as above (from Eisenberg et al.) to perform a simple workflow:
 
-In this chapter we will focus primarily on complex workflows that have many stages. I will use a running example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features described earlier.  For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from about 1.3 million immune system cells for about 35K transcripts.  I chose this particular example for several reasons:
+- Load the demographic and meaningful variables files
+- Filter out any non-numeric variables from each data frame
+- Join the data frames using their shared index
+- Compute the correlation matrix across all variables
+- Generate a clustered heatmap for the correlation matrix
+
+### Running a simple workflow using UNIX make
+
+One of the simplest ways to organize a workflow is using the UNIX `make` command, which executes commands defined in a file named `Makefile`.  `make` is a very handy general-purpose tool that every user of UNIX systems should become familiar with.  The Makefile defines a set of labeled commands, like this:
+
+```Makefile
+
+all: step1 step2
+
+step1:
+    python step1.py
+
+step2:
+    python step2.py
+```
+
+In this case, the command `make step1` will run `python step1.py`, `make step2` will run `python step2.py`, and `make all` will run both of those commands. This should already show you why `make` is such a handy tool: Any time there is a command that you run regularly in a particular directory, you can put it into a `Makefile` and then execute it with just a single `make` call.  Here is how we could build a very simple Makefile to run our simple workflow:
+
+```Makefile
+# Simple Correlation Workflow using Make
+#
+# Usage:
+#   make all              - Run full workflow
+#   make clean            - Remove output directory
+
+# if OUTPUT_DIR isn't already defined, set it to the default
+OUTPUT_DIR ?= ./output
+
+# run commands even if files exist with these names
+.PHONY: all clean
+
+all:
+	mkdir -p $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures
+	python scripts/download_data.py $(OUTPUT_DIR)/data
+	python scripts/filter_data.py $(OUTPUT_DIR)/data
+	python scripts/join_data.py $(OUTPUT_DIR)/data
+	python scripts/compute_correlation.py $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results
+	python scripts/generate_heatmap.py $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures
+
+clean:
+	rm -rf $(OUTPUT_DIR)
+```
+
+We can run the entire workflow by simply running `make all`.  We could also take advantage of another feature of `make`: it only triggers the action if a file with the name of the action doesn't exist.  Thus, if the command was `make results/output.txt`, then the action would only be triggered if the file does not exist.  This is why we had to put the `.PHONY` command in the makefile above: it's telling `make` that those are not meant to be interpreted as file names, but rather as commands, so that they will be run even if files named "all" or "clean" exist.
+
+For a very simple workflow `make` can be useful, but we will see below why this wouldn't be sufficient for a complex workflow.  For those workflows we could either build our own more complex workflow management system, or we could use an existing software tool that is built to manage workflow execution, known as a *workflow engine*.  Later in the chapter I will show an example of a purpose-built workflow management system, but for this first example we will now turn to a general-purpose workflow engine.
+
+### Using a workflow engine
+
+There is a wide variety of workflow engines available for data analysis workflows, most of which are centered around the concept of an "execution graph".  This is a graph in the sense described by graph theory, which refers to a set of nodes that are connected by lines (known as "edges").  Workflow execution graphs are a particular kind of graph known as a *directed acyclic graph*, or *DAG* for short. Each node in the graph represents a single step in the workflow, and each edge represents the dependency relationships that exist between nodes.  DAGs have two important features.  First, the edges are directed, which means that they move in one direction that is represented graphically as an arrow.  These represent the dependencies within the workflow.  For example, in our workflow step 1 (obtaining the data) must occur before step 2 (filtering the data), so the graph would have an edge from step 1 with an arrow pointing at step 2.  Second, the graph is *acyclic*, which means that it doesn't have any cycles, that is, it never circles back on itself.  Cycles would be problematic, since they could result in workflows that executed in an infinite loop as the cycle repeated itself.  
+
+Most workflow engines provide tools to visualize a workflow as a DAG. #simpleDAG-fig shows our example workflow visualized using the Snakemake tool that we will introduce below:
+
+```{figure} images/simple-DAG.png
+:label: simpleDAG-fig
+:align: center
+:width: 300px
+
+The execution graph for the simple example analysis workflow visualized as a DAG.
+```
+
+The use of DAGs to represent workflows provides a number of important benefits:
+
+- The engine can identify independent pathways through the graph, which can then be executed in parallel
+- If one node of the graph changes, the engine can identify which downstream nodes need to be rerun
+- If a node fails, the engine can continue with executing the nodes that don't depend on the failed node either directly or indirectly
+
+There are a couple of additional benefits to using a workflow engine, which we will discuss in more detail in the context of a more complex workflow. The first is that they generally deal automatically with the storage of intermediate results (known as *checkpointing*), which can help speed up execution when nothing has changed.  The second is that the workflow engine uses the execution graph to optimize the computation, only performing those operations that are actually needed.  This is similar in spirit to the concept of *lazy execution* used by packages like Polars, in which the system optimizes computational efficiency by first analyzing the full computational graph.
+
+#### General-purpose versus domain-specific workflow engines
+
+With the growth of data science within industry and research, there has been an explosion of new workflow management systems that aim to solve particular problems; a list of these can be found at [awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines).  One important distinction between engines is the degree to which the workflow definition is built into the code, or whether it is defined in a *domain-specific language* (DSL).  We will look at two examples below, one of which (Prefect) builds the workflow details in the code, and the other (Snakemake) uses a specialized syntax built on Python to define the workflow.
+
+It's also worth noting that there are a number of domain-specific workflow engines that are specialized for particular kinds of data and workflows.  Examples include [Galaxy](https://galaxyproject.org/) which is specialized for bioinformatics and genomics, and [Nipype](https://nipype.readthedocs.io/en/latest/index.html) which is specialized for neuroimaging analysis workflows. If your research community uses one of these then it's worth exploring that engine as your first option, since it will probably be well supported within the community. However, a benefit of using a general-purpose engine is that they will often be better maintained and supported, and AI tools will likely have more examples to work from in generating workflows.
+
+### Using the Snakemake workflow engine
+
+
+
+- show how one can run snakemake with an output file name to reconstruct that file (using --force if it already exists)
+
+## Scaling to complex workflows
+
+We now turn to a more realistic and complex scientific data analysis workflow. For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from 982 people comprising about 1.3 million immune system cells for about 35K transcripts.  I chose this particular example for several reasons:
 
 - It is a realistic example of a workflow that a researcher might actually perform.
 - The data are large enough to call for a real workflow management scheme, but small enough to be processed on a single laptop (assuming it has decent memory). 
@@ -102,6 +191,8 @@ In this chapter we will focus primarily on complex workflows that have many stag
 - There is an established Python library ([scanpy](https://scanpy.readthedocs.io/en/stable/)) that implements the necessary workflow components.
 - It's an example outside of my own research domain, to help demonstrate the applicability of the book's ideas across a broader set of data types.
 
+I will use this example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features described above. 
+
 ### Starting point: One huge notebook
 
 I developed the initial version of this workflow as many researchers would: by creating a Jupyter notebook that implements the entire workflow, which can be found [here]().  Although I don't usually prefer to do code generation using a chatbot, I did most of the coding for this example using the Google Gemini 3 chatbot, for a couple of reasons.  First, this model seemed particularly knowledgeable about this kind of analysis and the relevant packages.  Second, I found it useful to read the commentary about why particular analysis steps were being selected.  For debugging I used a mixture of the Gemini 3 chatbot and the VSCode Copilot agent, depending on the nature of the problem; for problems specific to the RNA-seq analysis tools I used Gemini, while for standard Python/Pandas issues I used Copilot. The total execution time for this notebook is about two hours on an M3 Max Macbook Pro.  
@@ -268,11 +359,8 @@ Combining these strategies of reducing data duplication, eliminating some interm
 
 The use of a modular architecture for our stateless workflow helps to separate the actual workflow components from the execution logic of the workflow.  One important benefit of this is that it allows us to plug those modules into any other workflow system, and as long as the inputs are correct it should work. We will see that next when we create new versions of this workflow using two common workflow engines.
 
-### Using a workflow engine
-
-There is a wide variety of workflow engines available for data analysis workflows, most of which are centered around the concept of an "execution graph."  This is a graph in the sense described by graph theory, which refers to a set of nodes that are connected by lines (known as "edges").  Workflow execution graphs are a particular kind of graph known as a *directed acyclic graph*, or *DAG* for short. Each node in the graph represents a single step in the workflow, and each edge represents the dependency relationships that exist between nodes.  DAGs have two important features.  First, the edges are directed, which means that they move in one direction that is represented graphically as an arrow.  These represent the dependencies within the workflow.  For example, in our workflow step 1 (obtaining the data) must occur before step 2 (filtering the data), so the graph would have an edge from step 1 with an arrow pointing at step 2.  Second, the graph is *acyclic*, which means that it doesn't have any cycles, that is, it never circles back on itself.  Cycles would be problematic, since they could result in workflows that executed in an infinite loop as the cycle repeated itself.  
 
-Most workflow engines provide tools to visualize a workflow as a DAG. #DAG-fig shows our example workflow visualized using the Snakemake tool that we will introduce below:
+### Using a workflow engine
 
 ```{figure} images/snakemake-DAG.png
 :label: DAG-fig
@@ -282,22 +370,10 @@ Most workflow engines provide tools to visualize a workflow as a DAG. #DAG-fig s
 The execution graph for the RNA-seq analysis workflow visualized as a DAG.
 ```
 
-The use of DAGs to represent workflows provides a number of important benefits:
-
-- The engine can identify independent pathways through the graph, which can then be executed in parallel
-- If one node of the graph changes, the engine can identify which downstream nodes need to be rerun
-- If a node fails, the engine can continue with executing the nodes that don't depend on the failed node either directly or indirectly
-
-There are a couple of additional benefits to using a workflow engine. The first is that they generally deal automatically with checkpointing and caching of intermediate results.  The second is that the workflow engine uses the execution graph to optimize the computation, only performing those operations that are actually needed.  This is similar in spirit to the concept of *lazy execution* used by packages like Polars, in which the system optimizes computational efficiency by first analyzing the full computational graph.
-
-#### General-purpose versus domain-specific workflow engines
-
-With the growth of data science within industry and research, there has been an explosion of new workflow management systems that aim to solve particular problems; a list of these can be found at [awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines).  One important distinction between engines is the degree to which the workflow definition is built into the code, or whether it is defined in a *domain-specific language* (DSL).  We will look at two examples below, one of which (Prefect) builds the workflow details in the code, and the other (Snakemake) uses a specialized syntax built on Python to define the workflow.
-
-It's also worth noting that there are a number of domain-specific workflow engines that are specialized for particular kinds of data and workflows.  Examples include [Galaxy](https://galaxyproject.org/) which is specialized for bioinformatics and genomics, and [Nipype](https://nipype.readthedocs.io/en/latest/index.html) which is specialized for neuroimaging analysis workflows. If your research community uses one of these then it's worth exploring that engine as your first option, since it will probably be well supported within the community. However, a benefit of using a general-purpose engine is that they will often be better maintained and supported, and AI tools will likely have more examples to work from in generating workflows.
 
 ### A language-specific workflow management example: Prefect
 
+- First build a very simple workflow example using Prefect
 
 #### Configuration management
 
@@ -307,6 +383,7 @@ The initial version of the Prefect workflow generated by Claude had the default
 
 ### A general-purpose workflow management example: Snakemake
 
+- First build the simple example using snakemake
 
 #### Pipeline optimization
 
@@ -324,7 +401,7 @@ I asked Claude to fix this, and it returned the following change:
 >  4. Set NUMBA_NUM_THREADS and OMP_NUM_THREADS environment variables in dimred.py
 >   In contrast, Prefect tasks run in the main process with access to all CPUs by default, which is why it was faster.
 
-This solves the problem but it's an odd choice: in particular, it will probably fail if there are fewer than 8 threads available on the system. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might fail if the requested number of cores are not available. We will discuss optimization in much greater detail in a later chapter.
+This solves the problem but it's a brittle soluution: in particular, it will probably fail if there are fewer than 8 threads available on the system and it won't take advantage of more than 8 if they are available. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might not be optimal. We will discuss optimization in much greater detail in a later chapter, but whenever a pipeline takes much longer to run using a workflow manager than one would expect, it's likely that there is optimization to be done.
 
 
 
@@ -365,10 +442,6 @@ https://workflowhub.eu/
 ## Report generation
 
 
- 
-
-
-
 ## Scaling workflows
 
 - maybe leave this to the HPC chapter?

From 89a5ab2798aeed594c9db659d37344be4693a653 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 05:59:36 -0800
Subject: [PATCH 80/87] initial add

---
 book/images/simple-DAG.png | Bin 0 -> 92015 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 book/images/simple-DAG.png

diff --git a/book/images/simple-DAG.png b/book/images/simple-DAG.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa0abe0ef4f8934fbacc93ea7450fd29087430f1
GIT binary patch
literal 92015
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%0D^VeHrU&X=Mfr2
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

literal 0
HcmV?d00001


From 40f8edd180403b4265b68d92de8efac6f361498c Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 05:59:47 -0800
Subject: [PATCH 81/87] initial add

---
 .../simple_workflow/snakemake_workflow/Makefile                 | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile

diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
new file mode 100644
index 0000000..c31e427
--- /dev/null
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
@@ -0,0 +1,2 @@
+graph:
+	snakemake --rulegraph --config output_dir=./output --cores 2 | dot -Tpng -Gdpi=300  > output/rulegraph.png

From 08ce603b006ce557663167b04155af58865c2d0e Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 08:34:34 -0800
Subject: [PATCH 82/87] remove .snakemake before running

---
 .../simple_workflow/snakemake_workflow/Makefile            | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
index c31e427..2b72b47 100644
--- a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
@@ -1,2 +1,9 @@
+run:
+	-rm .snakemake
+	snakemake --cores 1 --config output_dir=~/data_unsynced/BCBS/simple_workflow/wf_snakemake
+
+report:
+	snakemake --report report.html --config output_dir=~/data_unsynced/BCBS/simple_workflow/wf_snakemake
+
 graph:
 	snakemake --rulegraph --config output_dir=./output --cores 2 | dot -Tpng -Gdpi=300  > output/rulegraph.png

From bfc5de03366b7caa34e1b7cb56379e545cea3979 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 12:27:28 -0800
Subject: [PATCH 83/87] add expanduser to deal with relative paths

---
 .../snakemake_workflow/scripts/compute_correlation.py       | 4 ++--
 .../snakemake_workflow/scripts/download_data.py             | 2 +-
 .../snakemake_workflow/scripts/filter_data.py               | 4 ++--
 .../simple_workflow/snakemake_workflow/scripts/join_data.py | 6 +++---
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py
index 5095888..33a29a1 100644
--- a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py
@@ -12,8 +12,8 @@
 def main():
     """Compute Spearman correlation matrix."""
     # ruff: noqa: F821
-    input_path = Path(snakemake.input[0])
-    output_path = Path(snakemake.output[0])
+    input_path = Path(snakemake.input[0]).expanduser()
+    output_path = Path(snakemake.output[0]).expanduser()
     method = snakemake.params.method
 
     # Load data
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py
index 61474f2..abad205 100644
--- a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py
@@ -9,7 +9,7 @@ def main():
     """Download data from URL."""
     # ruff: noqa: F821
     url = snakemake.params.url
-    output_path = Path(snakemake.output[0])
+    output_path = Path(snakemake.output[0]).expanduser()
 
     # Create output directory
     output_path.parent.mkdir(parents=True, exist_ok=True)
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py
index 325b818..6e5af11 100644
--- a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py
@@ -12,8 +12,8 @@
 def main():
     """Filter data to numerical columns."""
     # ruff: noqa: F821
-    input_path = Path(snakemake.input[0])
-    output_path = Path(snakemake.output[0])
+    input_path = Path(snakemake.input[0]).expanduser()
+    output_path = Path(snakemake.output[0]).expanduser()
 
     # Load data
     df = pd.read_csv(input_path, index_col=0)
diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py
index 73b915d..b484d92 100644
--- a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py
@@ -10,9 +10,9 @@
 def main():
     """Join the two datasets."""
     # ruff: noqa: F821
-    mv_path = Path(snakemake.input.meaningful_vars)
-    demo_path = Path(snakemake.input.demographics)
-    output_path = Path(snakemake.output[0])
+    mv_path = Path(snakemake.input.meaningful_vars).expanduser()
+    demo_path = Path(snakemake.input.demographics).expanduser()
+    output_path = Path(snakemake.output[0]).expanduser()
 
     # Load data
     meaningful_vars = pd.read_csv(mv_path, index_col=0)

From 0aee5574177b15d593efea8bb612e2a2e97658c0 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 12:27:57 -0800
Subject: [PATCH 84/87] add log dir and onstart

---
 .../simple_workflow/snakemake_workflow/Snakefile            | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile
index 88104ce..789fd98 100644
--- a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile
@@ -41,6 +41,12 @@ OUTPUT_DIR = Path(config["output_dir"])
 DATA_DIR = OUTPUT_DIR / "data"
 RESULTS_DIR = OUTPUT_DIR / "results"
 FIGURES_DIR = OUTPUT_DIR / "figures"
+LOGS_DIR = OUTPUT_DIR / "logs"
+
+
+# Create output directories at workflow start
+onstart:
+    shell(f"mkdir -p {DATA_DIR} {RESULTS_DIR} {FIGURES_DIR} {LOGS_DIR}")
 
 
 # Default target

From 71f286f3535f77d92bbb8766f5f6e1512e3415f4 Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 12:28:41 -0800
Subject: [PATCH 85/87] use DATADIR var instead of hard coding

---
 .../snakemake_workflow/Makefile                | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
index 2b72b47..95954e9 100644
--- a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
+++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile
@@ -1,9 +1,19 @@
-run:
+OUTPUT_DIR := /Users/poldrack/data_unsynced/BCBS/simple_workflow/wf_snakemake
+
+.PHONY: run report graph
+
+clean:
 	-rm .snakemake
-	snakemake --cores 1 --config output_dir=~/data_unsynced/BCBS/simple_workflow/wf_snakemake
+	-rm -rf $(OUTPUT_DIR)/*
+
+run:
+	snakemake --cores 1 --config output_dir=$(OUTPUT_DIR)
+
+dryrun:
+	snakemake --dry-run --cores 1 --config output_dir=$(OUTPUT_DIR)
 
 report:
-	snakemake --report report.html --config output_dir=~/data_unsynced/BCBS/simple_workflow/wf_snakemake
+	snakemake --report $(OUTPUT_DIR)/report.html --config output_dir=$(OUTPUT_DIR)
 
 graph:
-	snakemake --rulegraph --config output_dir=./output --cores 2 | dot -Tpng -Gdpi=300  > output/rulegraph.png
+	snakemake --rulegraph --config output_dir=$(OUTPUT_DIR) --cores 2 | dot -Tpng -Gdpi=300  > output/rulegraph.png

From 3206f8d8bbe882683015f433f3a1ed0d35b38eaa Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 12:30:31 -0800
Subject: [PATCH 86/87] add .snakemake

---
 .gitignore | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitignore b/.gitignore
index 977d7ee..c1df5e4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,10 @@ __pycache__
 .hypothesis
 .env
 ._*
+.snakemake
+
+# Workflow output directories
+**/simple_workflow/*/output/
 
 data
 exports

From f7e942cb7706161b495e44924542dfa48273518e Mon Sep 17 00:00:00 2001
From: Russell Poldrack <poldrack@gmail.com>
Date: Wed, 24 Dec 2025 12:31:34 -0800
Subject: [PATCH 87/87] close to a first draft. merging for now, will return to
 finish later

---
 book/workflows.md | 426 +++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 365 insertions(+), 61 deletions(-)

diff --git a/book/workflows.md b/book/workflows.md
index 075c0f8..4fea77a 100644
--- a/book/workflows.md
+++ b/book/workflows.md
@@ -32,7 +32,7 @@ It's worth noting that these different desiderata will sometimes conflict with o
 
 ## Pipelines versus workflows
 
-The terms *workflow* and *pipeline* are sometimes used interchangeably, but in this chapter I will use them to refer to different kinds of applications. I will use *workflow* as the more general term to refer to any set of analysis procedures that are implemented as separate modules.  I will use the term *pipeline* to refer more specifically to a data analysis workflow where several operations are combined into a single command through the use of *pipes*, which are a syntactic construct that feed the output of one process directly into the next process as input.  Some readers may be familiar with pipes from the UNIX command line, where they are represented by the vertical bar "|".  For example, let's say that we had a log file that contains the following entries:
+The terms *workflow* and *pipeline* are sometimes used interchangeably, but in this chapter I will use them to refer to different kinds of applications. I will use *workflow* as the more general term to refer to any set of analysis procedures that are implemented as separate modules.  I will use the term *pipeline* to refer more specifically to a data analysis workflow where several operations are combined into a single command through the use of *pipes*, which are a syntactic construct that feed the results of one process directly into the next process.  Some readers may be familiar with pipes from the UNIX command line, where they are represented by the vertical bar "|".  For example, let's say that we had a log file that contains the following entries:
 
 ```bash
 2024-01-15 10:23:45 ERROR: Database connection failed
@@ -58,6 +58,8 @@ where:
 - `sort -rn`  sorts the rows in reverse numerical order (largest to smallest)
 - `> error_summary.txt` redirects the output into a file called `error_summary.txt`
 
+Pipes are also commonly used in the R ecosystem, where they are a fundamental component of the *tidyverse* group of packages.
+
 #### Method chaining
 
 One way that simple pipelines can be built in Python is using *method chaining*, where each method returns an object on which the next method is called; this is slightly different from the operation of UNIX pipes, where it is the result of each command that is being passed through the pipe.  This is commonly used to perform data transformations in `pandas`, as it allows composing multiple transformations into a single command.  As an example, we will work with the Eisenberg et al. dataset that we used in a previous chapter, to compute the probability of having ever been arrested separately for males and females in the sample. To do this we need to perform a number of operations:
@@ -91,9 +93,38 @@ Name: EverArrested, dtype: float64
 
 Note that `pandas` data frames also include an explicit `.pipe` method that allows using arbitrary functions within a pipeline.  While these kinds of pipelines can be useful for simple data processing operations, they can become very difficult to debug, so I would generally avoid using complex functions within a method chain.
 
+
+## FAIR-inspired practices for workflows
+    - FAIR workflows 
+        - https://pmc.ncbi.nlm.nih.gov/articles/PMC10538699/
+        - https://www.nature.com/articles/s41597-025-04451-9
+        - this seems really heavyweight.  
+    - 80/20 approach to reproducible workflows
+        - version control + documentation
+        - requirements file or container
+        - clear workflow structure
+        - standard file formats
+    - The full FAIR approach may be necessary in some contexts
+
+In the earlier chapter on Data Management I discussed the FAIR (Findable, Accessible, Interoperable, and Reusable) principles for data.  Since those principles were proposed in 2016 they have been extended to many other types of research objects, including workflows (REFS - https://www.nature.com/articles/s41597-025-04451-9).  The reader who is not an informatician is likely to quickly glaze over when reading these articles, as they ...
+
+Realizing that most scientists are unlikely to go to the lengths of a fully FAIR workflow, and preferring that the perfect never be the enemy of the good, I think that we can take an "80/20" approach, meaning that we can get 80% of the benefits for about 20% of the effort.  We can adhere to the spirit of the FAIR Workflows principle by adopting the following principles, based in part on the "Ten Quick Tips for FAIR Workflows" presented by de Visser et al., (2023; https://pmc.ncbi.nlm.nih.gov/articles/PMC10538699):
+
+- *Metadata*:  Provide sufficient metadata in a standard machine-readable format to make the workflow findable once it is shared.
+- *Version control*:  All workflow code should be kept under version control and hosted on a public repository such as Github.
+- *Documentation*: Workflows should be well documented. Documentation should focus primarily on the scientific motivation and technical design of the workflow, along with instructions on how to run it and description of the outputs.
+- *Standard organization schemes*: Both the workflow files (code and configuration) and data files should follow established standards for organization.
+- *Standard file formats*: The inputs and outputs to the workflow should use established standard file formats rather than inventing new formats.
+- *Configurability*: The workflow should be easily configurable, and example configuration files should be included in the repository.
+- *Requirements*: The requirements for the workflow should be clearly specified, either in a file (such as `pyproject.toml` or `requiremets.txt`) or in a container configuration file (such as a Dockerfile).
+- *Clear workflow structure*: The workflow structure should be easily understandable.
+
+There are certainly some contexts where a more formal structure adhering in detail to the FAIR Workflows standard may be required, as in large collaborative projects with specific compliance objectives, but these rough guidelines should get a researcher most of the way there.
+
+
 ## A simple workflow example
 
-Most real scientific workflows are complex and can often run for hours, and we will encounter such a complex workflow later in the chapter. However, we will start our discussion of workflows with a relatively simple and fast-running example that will help us understand the basic concepts of workflow execution. We will use the same data as above (from Eisenberg et al.) to perform a simple workflow:
+Most real scientific workflows are complex and can often run for hours, and we will encounter such a complex workflow later in the chapter. However, we will start our discussion of workflows with a relatively simple and fast-running example that will help demonstrate the basic concepts of workflow execution. We will use the same data as above (from Eisenberg et al.) to perform a simple workflow:
 
 - Load the demographic and meaningful variables files
 - Filter out any non-numeric variables from each data frame
@@ -101,9 +132,11 @@ Most real scientific workflows are complex and can often run for hours, and we w
 - Compute the correlation matrix across all variables
 - Generate a clustered heatmap for the correlation matrix
 
-### Running a simple workflow using UNIX make
+I have implemented each of these components as a module [here]().  The simplest possible workflow would be a script that simply imnports and calls each of the methods in turn. For such a simple workflow this would be fine, but we will use the example to show how we might take advantage of more sophisticated workflow management tools.
+
+### Running a simple workflow using GNU make
 
-One of the simplest ways to organize a workflow is using the UNIX `make` command, which executes commands defined in a file named `Makefile`.  `make` is a very handy general-purpose tool that every user of UNIX systems should become familiar with.  The Makefile defines a set of labeled commands, like this:
+One of the simplest ways to organize a workflow is using the GNU `make` command, which executes commands defined in a file named `Makefile`.  `make` is a very handy general-purpose tool that every user of UNIX systems should become familiar with.  The Makefile defines a set of labeled commands, like this:
 
 ```Makefile
 
@@ -169,23 +202,315 @@ The use of DAGs to represent workflows provides a number of important benefits:
 
 There are a couple of additional benefits to using a workflow engine, which we will discuss in more detail in the context of a more complex workflow. The first is that they generally deal automatically with the storage of intermediate results (known as *checkpointing*), which can help speed up execution when nothing has changed.  The second is that the workflow engine uses the execution graph to optimize the computation, only performing those operations that are actually needed.  This is similar in spirit to the concept of *lazy execution* used by packages like Polars, in which the system optimizes computational efficiency by first analyzing the full computational graph.
 
-#### General-purpose versus domain-specific workflow engines
+### General-purpose versus domain-specific workflow engines
+
+With the growth of data science within industry and research, there has been an explosion of new workflow management systems that aim to solve particular problems; a list of these can be found at [awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines). It's also worth noting that there are a number of domain-specific workflow engines that are specialized for particular kinds of data and workflows.  Examples include [Galaxy](https://galaxyproject.org/) which is specialized for bioinformatics and genomics, and [Nipype](https://nipype.readthedocs.io/en/latest/index.html) which is specialized for neuroimaging analysis workflows. If your research community uses one of these then it's worth exploring that engine as your first option, since it will probably be well supported within the community. However, a benefit of using a general-purpose engine is that they will often be better maintained and supported, and AI tools will likely have more examples to work from in generating workflows.
+
+### Workflow management using Snakemake
+
+We will use the Snakemake workflow system for our example, which I chose for several reasons:
+
+- It is a very well-established project that is actively maintained.
+- It is Python-based, which makes it easy for Python users to grasp.
+- Because of its long history and wide use, AI coding assistants are quite familiar with it and can easily generate the necessary files for complex workflows.
+
+Snakemake is a sort of "make on steroids", designed specifically to manage complex computational workflows.  It uses a Python-like syntax to define the workflow, from which it infers the computational graph and optimizes the computation. The Snakemake workflow is defined using a `Snakefile`, the most important aspect of which is a set of rules that define the different workflow steps in terms of their outputs.  Here is an initial portion of the `Snakefile` for our simple workflow:
+
+```Python
+# Load configuration
+configfile: "config/config.yaml"
+
+# Global report
+report: "report/workflow.rst"
+
+OUTPUT_DIR = Path(config["output_dir"])
+DATA_DIR = OUTPUT_DIR / "data"
+RESULTS_DIR = OUTPUT_DIR / "results"
+FIGURES_DIR = OUTPUT_DIR / "figures"
+
+# Default target
+rule all:
+    input:
+        FIGURES_DIR / "correlation_heatmap.png",
+```
+
+What this does is first specify the configuration file, which is a YAML file that defines various parameters for the workflow.  Here are the contents of the config file for our simple example:
+
+```bash
+# Data URLs
+meaningful_variables_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv"
+demographics_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv"
+
+# Correlation settings
+correlation_method: "spearman"
+
+# Heatmap settings
+heatmap:
+  figsize: [12, 10]
+  cmap: "coolwarm"
+  vmin: -1.0
+  vmax: 1.0
+```
+
+The only rule shown here is the `all` rule, which takes as its input the correlation figure that is the final output of the workflow.  If snakemake is called and that file already exists, then it won't be rerun (since it's the only requirement for the rule) unless 1) the `--force` flag is included, which forces rerunning the entire workflow, or 2) a rerun is triggered by one of the changes that Snakemake looks for (discussed more below).  If the file doesn't exist, then Snakemake examines the additional rules to determine which steps need to be run in order to generate that output.  In this case, it would start with the rule that generates the correlation figure:
+
+```python
+# Step 5: Generate clustered heatmap
+rule generate_heatmap:
+    input:
+        RESULTS_DIR / "correlation_matrix.csv",
+    output:
+        report(
+            FIGURES_DIR / "correlation_heatmap.png",
+            caption="report/heatmap.rst",
+            category="Results",
+        ),
+    params:
+        figsize=config["heatmap"]["figsize"],
+        cmap=config["heatmap"]["cmap"],
+        vmin=config["heatmap"]["vmin"],
+        vmax=config["heatmap"]["vmax"],
+    log:
+        OUTPUT_DIR / "logs" / "generate_heatmap.log",
+    script:
+        "scripts/generate_heatmap.py"
+```
+
+This step uses the `generate_heatmap.py` script to generate the correlation figure, and it requires the `correlation_matrix.csv` file as input.  Snakemake would then work backward to identify which step is required to generate that file, which is the following:
+
+```python
+# Step 4: Compute correlation matrix
+rule compute_correlation:
+    input:
+        DATA_DIR / "joined_data.csv",
+    output:
+        RESULTS_DIR / "correlation_matrix.csv",
+    params:
+        method=config["correlation_method"],
+    log:
+        OUTPUT_DIR / "logs" / "compute_correlation.log",
+    script:
+        "scripts/compute_correlation.py"
+```
+
+By working backwards this way from the intended output, Snakemake can reconstruct the computational graph that we saw in #simpleDAG-fig.  It then uses this graph to plan the computations that will be performed.  
+
+
+#### Snakemake scripts
+
+In order for Snakemake to execute each of our modules, we need to wrap those modules in a script that can use the configuration information from the config file.  Here is an example of what the [generate_heatmap.py]() script would looks like:
+
+```python
+from pathlib import Path
+import pandas as pd
+from BetterCodeBetterScience.simple_workflow.visualization import (
+    generate_clustered_heatmap,
+)
+
+def main():
+    """Generate and save clustered heatmap."""
+    # ruff: noqa: F821
+    input_path = Path(snakemake.input[0])
+    output_path = Path(snakemake.output[0])
+    figsize = tuple(snakemake.params.figsize)
+    cmap = snakemake.params.cmap
+    vmin = snakemake.params.vmin
+    vmax = snakemake.params.vmax
+
+    # Load correlation matrix
+    corr_matrix = pd.read_csv(input_path, index_col=0)
+    print(f"Loaded correlation matrix: {corr_matrix.shape}")
+
+    # Generate heatmap
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    generate_clustered_heatmap(
+        corr_matrix,
+        output_path=output_path,
+        figsize=figsize,
+        cmap=cmap,
+        vmin=vmin,
+        vmax=vmax,
+    )
+    print(f"Saved heatmap to {output_path}")
+
+if __name__ == "__main__":
+    main()
+```
+
+You can see that the code refers to `snakemake` even though we haven't explicitly imported it; this is possible because the script is executed within the Snakemake environment which makes that object available, which contains all of the configuration details.  
+
+- Dry run
+
+```bash
+Config file config/config.yaml is extended by additional config specified via the command line.
+host: Russells-MacBook-Pro.local
+Building DAG of jobs...
+Job stats:
+job                              count
+-----------------------------  -------
+all                                  1
+compute_correlation                  1
+download_demographics                1
+download_meaningful_variables        1
+filter_demographics                  1
+filter_meaningful_variables          1
+generate_heatmap                     1
+join_datasets                        1
+total                                8
+
+... (omitting intermediate output)
+
+Job stats:
+job                              count
+-----------------------------  -------
+all                                  1
+compute_correlation                  1
+download_demographics                1
+download_meaningful_variables        1
+filter_demographics                  1
+filter_meaningful_variables          1
+generate_heatmap                     1
+join_datasets                        1
+total                                8
+
+Reasons:
+    (check individual jobs above for details)
+    input files updated by another job:
+        all, compute_correlation, filter_demographics, filter_meaningful_variables, generate_heatmap, join_datasets
+    output files have to be generated:
+        compute_correlation, download_demographics, download_meaningful_variables, filter_demographics, filter_meaningful_variables, generate_heatmap, join_datasets
+This was a dry-run (flag -n). The order of jobs does not reflect the order of execution.
+```
+
+Once we have confirmed that everything is set up properly, we can then use `snakemake` to run the workflow:
+
+```bash
+➤  snakemake --cores 1 --config output_dir=./output
+Config file config/config.yaml is extended by additional config specified via the command line.
+Assuming unrestricted shared filesystem usage.
+host: Russells-MacBook-Pro.local
+Building DAG of jobs...
+Using shell: /bin/bash
+Provided cores: 1 (use --cores to define parallelism)
+Rules claiming more threads will be scaled down.
+Job stats:
+job                              count
+-----------------------------  -------
+all                                  1
+compute_correlation                  1
+download_demographics                1
+download_meaningful_variables        1
+filter_demographics                  1
+filter_meaningful_variables          1
+generate_heatmap                     1
+join_datasets                        1
+total                                8
+
+Select jobs to execute...
+Execute 1 jobs...
+
+[Wed Dec 24 08:17:57 2025]
+localrule download_demographics:
+    output: output/data/demographics.csv
+    log: output/logs/download_demographics.log
+    jobid: 7
+    reason: Missing output files: output/data/demographics.csv
+    resources: tmpdir=/var/folders/r2/f85nyfr1785fj4257wkdj7480000gn/T
+Downloaded 522 rows from https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv
+Saved to output/data/demographics.csv
+[Wed Dec 24 08:17:58 2025]
+Finished jobid: 7 (Rule: download_demographics)
+1 of 8 steps (12%) done
+
+... (omitting intermediate output)
+
+8 of 8 steps (100%) done
+Complete log(s): .snakemake/log/2025-12-24T081757.266320.snakemake.log
+```
+
+One handy feature of snakemake is that, just like `make`, we can give it a specific target file and it will perform only the portions of the workflow that are required to regenerate that specific file. 
 
-With the growth of data science within industry and research, there has been an explosion of new workflow management systems that aim to solve particular problems; a list of these can be found at [awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines).  One important distinction between engines is the degree to which the workflow definition is built into the code, or whether it is defined in a *domain-specific language* (DSL).  We will look at two examples below, one of which (Prefect) builds the workflow details in the code, and the other (Snakemake) uses a specialized syntax built on Python to define the workflow.
+#### Best practices for Snakemake workflows
 
-It's also worth noting that there are a number of domain-specific workflow engines that are specialized for particular kinds of data and workflows.  Examples include [Galaxy](https://galaxyproject.org/) which is specialized for bioinformatics and genomics, and [Nipype](https://nipype.readthedocs.io/en/latest/index.html) which is specialized for neuroimaging analysis workflows. If your research community uses one of these then it's worth exploring that engine as your first option, since it will probably be well supported within the community. However, a benefit of using a general-purpose engine is that they will often be better maintained and supported, and AI tools will likely have more examples to work from in generating workflows.
+The Snakemake team has published a set of [best practices](https://snakemake.readthedocs.io/en/stable/snakefiles/best_practices.html) for the creation of Snakemake workflows, some of which I will outline here, along with one of my own (the first).
 
-### Using the Snakemake workflow engine
+#### Using a working directory- TBD
+By default Snakemake looks for a Snakefile in the current directory, so it's tempting to run the workflow from the code repository.  However, Snakemake creates a directory called `.snakemake` to store metadata in the directory where the workflow is run, which one generally doesn't want to mix with the code.  Thus, it's best to create a working directory with its own copy of the config file (to allow local modifications), and then run the command from that directory using the
 
+##### Workflow organization
+There is a [standard format](https://snakemake.readthedocs.io/en/stable/snakefiles/deployment.html#distribution-and-reproducibility) for the organization of Snakemake workflow directories, which one should follow when developing new workflows.  
+
+##### Snakefile formatting
+Snakemake comes with a set of commands that help ensure that Snakemake files are properly formatted and follow best practices.  First, there is a static analysis tool (i.e a "linter", akin to ruff or flake8 for Python code), which can automatically identify problems with Snakemake rule files.  Unfortunately, this tool assumes that one is using the Conda environment manager (which is increasingly being abandoned in favor of uv) or a container (which comes with substantial overhead), and it raises an issue for any rule that doesn't specify a Conda or container environment. Nonetheless, if those are ignored the linter can be useful in identifying problems. There is also a formatting tool called `snakefmt` (separately installed) that optimally formats Snakemake files in the way that `black` or `blue` format Python code.  These can both be useful tools when developing a new workflow.
+
+##### Configurability
+Workflow configuration details should be stored in configuration files, such as the `config.yaml` files that we have used in our workflow examples.  However, these files should not be used for runtime parameters, such as the number of cores or the output directory; those should instead be handled using Snakemake's standard arguments.  The initial workflow generated by Claude did not follow this guidance, and instead custom variables to define runtime details such as the output directory and the number of cores. (TBD - CHECK THIS)
+
+#### Updating the workflow when inputs change
+
+Once the workflow has completed successfully, re-running it will not result in the re-execution of any of the analyses:
+
+```bash
+snakemake --cores 1 --config output_dir=/Users/poldrack/data_unsynced/BCBS/simple_workflow/wf_snakemake
+Config file config/config.yaml is extended by additional config specified via the command line.
+Assuming unrestricted shared filesystem usage.
+host: Russells-MacBook-Pro.local
+Building DAG of jobs...
+Nothing to be done (all requested files are present and up to date).
+```
 
+However, Snakemake checks several features of the workflow (by default) when generating its DAG to see if anything relevant has changed.  By default it checks to see if any of the following have changed (configurable using the `-rerun-triggers` flag):
 
-- show how one can run snakemake with an output file name to reconstruct that file (using --force if it already exists)
+- modification times of input files
+- the code specified within the rule
+- the input files or parameters for the rule
 
-## Scaling to complex workflows
+Snakemake also checks for changes in the details of the software environment, but as of the date of writing this only works for Conda environments.  
 
-We now turn to a more realistic and complex scientific data analysis workflow. For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from 982 people comprising about 1.3 million immune system cells for about 35K transcripts.  I chose this particular example for several reasons:
+As an example, I will first update the modification time of the demographics file from a previous successful run using the `touch` command:
+
+```bash
+➤  ls -l data/meaningful_variables.csv
+Permissions Size User     Date Modified Name
+.rw-r--r--@ 1.2M poldrack 24 Dec 10:11  data/meaningful_variables.csv
+
+➤  touch data/meaningful_variables.csv
+
+➤  ls -l data/meaningful_variables.csv
+Permissions Size User     Date Modified Name
+.rw-r--r--@ 1.2M poldrack 24 Dec 10:14  data/meaningful_variables.csv
+```
+
+You can see that the touch command updated the modification time of the file.  Now let's rerun the `snakemake` command:
+
+```bash
+snakemake --cores 1 --config output_dir=/Users/poldrack/data_unsynced/BCBS/simple_workflow/wf_snakemake
+Config file config/config.yaml is extended by additional config specified via the command line.
+Assuming unrestricted shared filesystem usage.
+host: Russells-MacBook-Pro.local
+Building DAG of jobs...
+Using shell: /bin/bash
+Provided cores: 1 (use --cores to define parallelism)
+Rules claiming more threads will be scaled down.
+Job stats:
+job                            count
+---------------------------  -------
+all                                1
+compute_correlation                1
+filter_meaningful_variables        1
+generate_heatmap                   1
+join_datasets                      1
+total                              5
+```
+
+Similarly, Snakemake will rerun the workflow if any of the scripts used to run the workflow are modified.  However, it's important to note that it will not identify changes in the modules that are imported.  In that case you would need to rerun the workflow in order to re-execute the relevant steps.
+
+## Scaling to a complex workflow
+
+We now turn to a more realistic and complex scientific data analysis workflow. For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from 982 people comprising about 1.3 million peripheral blood mononuclear cells (i.e. white blood cells) for about 35K transcripts.  I chose this particular example for several reasons:
 
 - It is a realistic example of a workflow that a researcher might actually perform.
+- It has a large enough sample size to provide a robust answer to our scientific question.
 - The data are large enough to call for a real workflow management scheme, but small enough to be processed on a single laptop (assuming it has decent memory). 
 - The workflow has many different steps, some of which can take a significant amount of time (over 30 minutes)
 - There is an established Python library ([scanpy](https://scanpy.readthedocs.io/en/stable/)) that implements the necessary workflow components.
@@ -261,7 +586,7 @@ Here we will examine the first (recommended) option and the third solution; whil
 
 ### A workflow registry with checkpointing
 
-We start with a custom approach in order to get a better view of the details of workflow orchestration.   
+We start with a custom approach in order to get a better view of the details of workflow orchestration. It's important to note that I generally would not recommend building one's one custom workflow manager, at least not before trying a general-purpose workflow engine, but I will show an example of a custom workflow engine in order to provide a better understanding of the detailed process of workflow management.  We start with a prompt:
 
 > let's implement the recommended Stateless Workflow with Checkpointing.  Please generate new code within src/BetterCodeBetterScience/rnaseq/stateless_workflow.
 
@@ -359,105 +684,84 @@ Combining these strategies of reducing data duplication, eliminating some interm
 
 The use of a modular architecture for our stateless workflow helps to separate the actual workflow components from the execution logic of the workflow.  One important benefit of this is that it allows us to plug those modules into any other workflow system, and as long as the inputs are correct it should work. We will see that next when we create new versions of this workflow using two common workflow engines.
 
+### Managing a complex workflow with Snakemake
 
-### Using a workflow engine
+In general I recommend trying a general-purpose workflow engine instead of writing a custom one.  In this example I will focus on the Snakemake workflow engine; in the project repository there is also a parallel workflow developed using the [Prefect] workflow engine (which is integrated directly into the Python code), but I will not discuss it here.
+ #rnaseq-DAG-fig shows the DAG generated by Snakemake for the RNA-seq analysis workflow. 
 
 ```{figure} images/snakemake-DAG.png
-:label: DAG-fig
+:label: rnaseq-DAG-fig
 :align: center
 :width: 300px
 
 The execution graph for the RNA-seq analysis workflow visualized as a DAG.
 ```
 
+The `Snakemake` file is substantially larger for this complex workflow; to keep it from being even longer, we can also move some of the rules into separate rules files using the following syntax within the `Snakemake` file:
 
-### A language-specific workflow management example: Prefect
-
-- First build a very simple workflow example using Prefect
-
-#### Configuration management
-
-The initial version of the Prefect workflow generated by Claude had the default parameter settings for each workflow hard-coded into the task definitions in Python.  This is not a great practice, since it means that any changes in parameter settings require changes in the code, making it difficult to easily test different parameter settings.  A better practice is to put the parameter settings into a human-editable configuration file, which can be specified upon execution of the workflow.  YAML is a common markup language for configuration files, which is used in both this workflow and the following one.
-
-
-
-### A general-purpose workflow management example: Snakemake
+```bash
+# Include modular rule files
+include: "rules/common.smk"
+include: "rules/preprocessing.smk"
+include: "rules/pseudobulk.smk"
+include: "rules/per_cell_type.smk"
+```
 
-- First build the simple example using snakemake
 
 #### Pipeline optimization
 
-The first time that I ran my workflow using snakemake, I noticed that it was substantially slower than when I ran it with Prefect.  When I asked Claude about this, it gave me a reasonable answer:
+The first time that I ran this workflow using snakemake, I noticed that it was substantially slower than when I ran it using the custom workflow engine.  When I asked Claude about this, it gave me a reasonable answer:
 
 > The Snakemake rules don't specify a threads directive. By default, Snakemake runs each job with 1 thread, which limits parallelization of computationally intensive operations like neighbor computation and UMAP (which use numba internally).
 
 I asked Claude to fix this, and it returned the following change:
 
-
 >   Fixes applied:
 >  1. Added threads: 8 to dimensionality_reduction rule
 >  2. Added threads: 8 to quality_control rule (Scrublet)
 >  3. Added threads: 4 to preprocess rule
 >  4. Set NUMBA_NUM_THREADS and OMP_NUM_THREADS environment variables in dimred.py
->   In contrast, Prefect tasks run in the main process with access to all CPUs by default, which is why it was faster.
+>  In contrast, tasks run in the main process have access to all CPUs by default, which is why it was faster.
 
 This solves the problem but it's a brittle soluution: in particular, it will probably fail if there are fewer than 8 threads available on the system and it won't take advantage of more than 8 if they are available. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might not be optimal. We will discuss optimization in much greater detail in a later chapter, but whenever a pipeline takes much longer to run using a workflow manager than one would expect, it's likely that there is optimization to be done.
 
+#### Running snakemake
 
 
 
-## Tracking provenance
+It's important to know that when snakemake is run, it stores metadata regarding the workflow in a hidden directory called `.snakemake`.  It's generally a good idea to add this to the `.gitignore` file since one probably doesn't want to include detailed workflow metadata in one's git repository.  It's also a best practice to execute the 
 
+#### Report generation
 
+One of the very handy features of Snakemake is its ability to generate reports for workflow execution.  Report generation is as simple as:
 
-### Configuration management
-
-- how to configure a workflow
+```bash
+snakemake --report $DATADIR/immune_aging/wf_snakemake/report.html --config datadir=$DATADIR/immune_aging/
+```
 
-    - configuration files
-    - command line arguments
-    - defaults
+This command uses the metadata stored in the .snakemake 
 
-- interaction with provenance
+#### Tracking provenance
 
-- discuss fit-transform model somewhere
+As I discussed in the earlier chapter on data management, it is essential to be able to track the provenance of files in a workflow.  That is, how did the file come to be, and what other files did it depend on?  
 
-https://workflowhub.eu/
+#### Parametric sweeps
 
+A common pattern in some computational research domains is the *parametric sweep*, where a workflow is run using a range of values for specific parameters in the workflow.  A key to successful execution of parametric sweeps is proper organization of the outputs so that they can be easily processed by downstream tools.  Snakemake provides the ability to easily implement parametric sweeps simply by specifying a list of parameter values in the configuration file.  For example... TBD
 
 
-## Error handling and robustness
+## Testing workflows
 
-- Fail fast
-- Gracefully handle missing data
-- Checkpointing for long-running workflows
 - write tests for common edge cases
   - use a small toy dataset for testing
 - unit vs integration tests
 
 
-## Logging
-
-
-## Report generation
-
-
 ## Scaling workflows
 
 - maybe leave this to the HPC chapter?
 
+## Choosing a workflow engine
 
-## FAIR-inspired practices for workflows
-    - FAIR workflows 
-        - https://pmc.ncbi.nlm.nih.gov/articles/PMC10538699/
-        - https://www.nature.com/articles/s41597-025-04451-9
-        - this seems really heavyweight.  
-    - 80/20 approach to reproducible workflows
-        - version control + documentation
-        - requirements file or container
-        - clear workflow structure
-        - standard file formats
-    - The full FAIR approach may be necessary in some contexts
 
-